MCP GitHub Project Manager

Gerenciamento de projetos GitHub com inteligência artificial e rastreabilidade completa de requisitos.

Documentação

MCP GitHub Project Manager

Um servidor abrangente do Model Context Protocol (MCP) que fornece recursos avançados de gerenciamento de projetos GitHub com gerenciamento de tarefas com IA e rastreabilidade completa de requisitos. Transforme suas ideias de projeto em tarefas acionáveis com rastreamento completo de ponta a ponta, desde requisitos de negócios até a implementação.

Visão Geral

Este servidor implementa o Model Context Protocol para fornecer gerenciamento abrangente de projetos GitHub com recursos avançados de IA. Além do gerenciamento tradicional de projetos, ele oferece geração de tarefas com IA, rastreabilidade de requisitos e planejamento inteligente de projetos por meio da API GraphQL do GitHub, mantendo o estado e tratando erros de acordo com as especificações do MCP.

🚀 O Que Torna Isso Especial

Com IA: Transforme ideias de projetos em PRDs abrangentes e tarefas acionáveis usando vários provedores de IA
Rastreabilidade Completa: Rastreamento completo de ponta a ponta, desde requisitos de negócios → funcionalidades → casos de uso → tarefas
Análise Inteligente: Análise de complexidade, estimativa de esforço e recomendações de tarefas com IA
Padrões Profissionais: Documentação de requisitos em conformidade com IEEE 830 com gerenciamento de mudanças de nível empresarial

Início Rápido

Usando NPM

# Install the package globally
npm install -g mcp-github-project-manager

# Set up your environment variables
export GITHUB_TOKEN="your_github_token"
export GITHUB_OWNER="your_github_username_or_organization"
export GITHUB_REPO="your_repository_name"

# Run the MCP server
mcp-github-project-manager

Usando Docker

# Build the Docker image
docker build -t mcp-github-project-manager .

# Run with environment variables
docker run -it \
  -e GITHUB_TOKEN=your_github_token \
  -e GITHUB_OWNER=your_github_username_or_organization \
  -e GITHUB_REPO=your_repository_name \
  mcp-github-project-manager

Para mais detalhes sobre o uso do Docker, consulte DOCKER.md.

Principais Recursos

🤖 Gerenciamento de Tarefas com IA

Geração de PRD (generate_prd): Transforme ideias de projetos em Documentos de Requisitos de Produto abrangentes
Divisão Inteligente de Tarefas (parse_prd): Análise de PRDs com IA para gerar tarefas de desenvolvimento acionáveis
Adição Inteligente de Funcionalidades (add_feature): Adicione novas funcionalidades com análise automática de impacto e geração de tarefas
Análise de Complexidade de Tarefas (analyze_task_complexity): Análise detalhada com IA da complexidade das tarefas, estimativa de esforço e avaliação de riscos
Recomendações de Próximas Tarefas (get_next_task): Recomendações com IA para priorização ideal de tarefas
Expansão de Tarefas (expand_task): Divida tarefas complexas em subtarefas gerenciáveis automaticamente
Aprimoramento de PRD (enhance_prd): Melhore PRDs existentes com análise de lacunas e melhorias com IA

🎯 Geração Aprimorada de Contexto de Tarefas

Contexto Baseado em Rastreabilidade (Padrão): Contexto rico a partir da rastreabilidade de requisitos, sem dependência de IA
Contexto Aprimorado com IA (Opcional): Contexto abrangente de negócios, técnico e de implementação usando IA
Níveis de Contexto Configuráveis: Escolha entre profundidade de contexto mínima, padrão e completa
Contexto de Negócios: Extraia objetivos de negócios, impacto no usuário e métricas de sucesso
Contexto Técnico: Analise restrições técnicas, decisões de arquitetura e pontos de integração
Orientação de Implementação: Recomendações passo a passo geradas por IA
Referências Contextuais: Links para seções relevantes do PRD, funcionalidades e especificações técnicas
Critérios de Aceitação Aprimorados: Critérios detalhados e testáveis com métodos de verificação
Degradação Graciosa: Funciona perfeitamente sem chaves de IA, com fallback para contexto baseado em rastreabilidade

🔗 Rastreabilidade Completa de Requisitos

Rastreamento de Ponta a Ponta (create_traceability_matrix): Rastreabilidade completa desde requisitos de negócios do PRD → funcionalidades → casos de uso → tarefas
Links Bidirecionais: Rastreabilidade bidirecional completa com análise de impacto
Gerenciamento de Casos de Uso: Geração e rastreamento profissionais de casos de uso ator-objetivo-cenário
Análise de Cobertura: Métricas abrangentes de cobertura com identificação de lacunas
Detecção de Tarefas Órfãs: Identifique tarefas sem vínculos com requisitos
Análise de Impacto de Mudanças: Acompanhe mudanças em requisitos e seu impacto em todos os níveis

📊 Suporte a Múltiplos Provedores de IA

Anthropic Claude: Provedor de IA principal para raciocínio complexo
OpenAI GPT: Provedor alternativo com suporte a fallback
Google Gemini: Capacidades adicionais de IA
Perplexity: Tarefas de pesquisa e análise
Fallback Automático: Alternância perfeita entre provedores

🏗️ Gerenciamento Central de Projetos

Gerenciamento de Projetos: Crie e gerencie GitHub Projects (v2)
Issues e Marcos: Operações CRUD completas com filtragem avançada
Planejamento de Sprints: Planeje e gerencie sprints de desenvolvimento com assistência de IA
Campos e Visualizações Personalizados: Crie diferentes visualizações (quadro, tabela, linha do tempo, roadmap)
Versionamento de Recursos: Cache inteligente e bloqueio otimista

⚡ Recursos Avançados

Implementação MCP: Conformidade total com a especificação MCP com validação Zod
Integração GitHub: Integração com API GraphQL com limitação inteligente de taxa
Sincronização em Tempo Real: Sincronização bidirecional com o GitHub
Integração com Webhooks: Atualizações em tempo real via webhooks do GitHub
Acompanhamento de Progresso: Métricas abrangentes e relatórios de progresso
Sistema de Eventos: Acompanhe e reproduza eventos do projeto

Instalação

Opção 1: Instalar via npm (recomendado)

# Install the package globally
npm install -g mcp-github-project-manager

# Or install in your project
npm install mcp-github-project-manager

Opção 2: Instalar a partir do código-fonte

# Clone the repository
git clone https://github.com/kunwarVivek/mcp-github-project-manager.git
cd mcp-github-project-manager

# Install dependencies
npm install
# or
pnpm install

# Build the project
npm run build

Configurar variáveis de ambiente

# Copy the example environment file
cp .env.example .env

# Edit .env with your GitHub token and details

Configuração

Variáveis de Ambiente Obrigatórias

Configuração do GitHub

GITHUB_TOKEN=your_github_token
GITHUB_OWNER=repository_owner
GITHUB_REPO=repository_name

O token do GitHub requer estas permissões:

repo (Acesso total ao repositório)
project (Acesso a projetos)
write:org (Acesso à organização)

Configuração do Provedor de IA

Pelo menos um provedor de IA é necessário para recursos com IA:

# Primary AI providers (at least one required)
ANTHROPIC_API_KEY=your_anthropic_api_key_here
OPENAI_API_KEY=your_openai_api_key_here
GOOGLE_API_KEY=your_google_api_key_here
PERPLEXITY_API_KEY=your_perplexity_api_key_here

# AI Model Configuration (optional - uses defaults if not specified)
AI_MAIN_MODEL=claude-3-5-sonnet-20241022
AI_RESEARCH_MODEL=perplexity-llama-3.1-sonar-large-128k-online
AI_FALLBACK_MODEL=gpt-4o
AI_PRD_MODEL=claude-3-5-sonnet-20241022

# AI Task Generation Configuration (optional)
MAX_TASKS_PER_PRD=50
DEFAULT_COMPLEXITY_THRESHOLD=7
MAX_SUBTASK_DEPTH=3
AUTO_DEPENDENCY_DETECTION=true
AUTO_EFFORT_ESTIMATION=true

# Enhanced Task Context Generation Configuration (optional)
ENHANCED_TASK_GENERATION=true
AUTO_CREATE_TRACEABILITY=true
AUTO_GENERATE_USE_CASES=true
AUTO_CREATE_LIFECYCLE=true
ENHANCED_CONTEXT_LEVEL=standard
INCLUDE_BUSINESS_CONTEXT=false
INCLUDE_TECHNICAL_CONTEXT=false
INCLUDE_IMPLEMENTATION_GUIDANCE=false

Configuração do Provedor de IA

Anthropic Claude

Cadastre-se no Anthropic Console
Crie uma chave de API
Defina ANTHROPIC_API_KEY no seu ambiente

OpenAI

Cadastre-se na OpenAI Platform
Crie uma chave de API
Defina OPENAI_API_KEY no seu ambiente

Google Gemini

Cadastre-se no Google AI Studio
Crie uma chave de API
Defina GOOGLE_API_KEY no seu ambiente

Perplexity

Cadastre-se na Perplexity API
Crie uma chave de API
Defina PERPLEXITY_API_KEY no seu ambiente

Uso

Como ferramenta de linha de comando

Se instalado globalmente:

# Start the MCP server using stdio transport
mcp-github-project-manager

# Start with environment variables
GITHUB_TOKEN=your_token mcp-github-project-manager

# Start with command line arguments
mcp-github-project-manager --token=your_token --owner=your_username --repo=your_repo

# Use a specific .env file
mcp-github-project-manager --env-file=.env.production

# Show verbose output
mcp-github-project-manager --verbose

# Display help information
mcp-github-project-manager --help

Executando a partir do código-fonte com TypeScript

Se você está desenvolvendo ou executando a partir do código-fonte:

# Run directly with ts-node
node --loader ts-node/esm src/index.ts

# Run with command line arguments
node --loader ts-node/esm src/index.ts --token=your_token --owner=your_username --repo=your_repo

# Use the npm dev script (watches for changes)
npm run dev

# Display help information
node --loader ts-node/esm src/index.ts --help

Opções de Linha de Comando

Opção	Curta	Descrição
`--token <token>`	`-t`	Token de acesso pessoal do GitHub
`--owner <owner>`	`-o`	Proprietário do repositório GitHub (usuário ou organização)
`--repo <repo>`	`-r`	Nome do repositório GitHub
`--env-file <path>`	`-e`	Caminho para o arquivo .env (padrão: .env na raiz do projeto)
`--verbose`	`-v`	Ativar registro detalhado (verbose logging)
`--help`	`-h`	Exibir informações de ajuda
`--version`		Exibir informações de versão

Os argumentos de linha de comando têm precedência sobre as variáveis de ambiente.

Como módulo Node.js

import { Server } from "mcp-github-project-manager";

// Create and start an MCP server instance
const server = new Server({
  transport: "stdio", // or "http" for HTTP server
  config: {
    githubToken: process.env.GITHUB_TOKEN,
    githubOwner: process.env.GITHUB_OWNER,
    githubRepo: process.env.GITHUB_REPO
  }
});

server.start();

Integração com clientes MCP

// Example using an MCP client library
import { McpClient } from "@modelcontextprotocol/client";
import { spawn } from "child_process";

// Create a child process running the MCP server
const serverProcess = spawn("mcp-github-project-manager", [], {
  env: { ...process.env, GITHUB_TOKEN: "your_token" }
});

// Connect the MCP client to the server
const client = new McpClient({
  transport: {
    type: "process",
    process: serverProcess
  }
});

// Call MCP tools
const result = await client.callTool("create_project", {
  title: "My Project",
  description: "A new GitHub project"
});

Para mais exemplos, consulte o Guia do Usuário e o diretório examples/.

Exemplos de Uso das Ferramentas de IA

Fluxo de Trabalho Completo do Projeto

# 1. Generate PRD from project idea
generate_prd({
  "projectIdea": "AI-powered task management system with real-time collaboration",
  "projectName": "TaskAI Pro",
  "author": "product-team",
  "complexity": "high",
  "timeline": "6 months",
  "includeResearch": true
})

# 2. Parse PRD and generate tasks with traceability
parse_prd({
  "prdContent": "<generated PRD content>",
  "maxTasks": 30,
  "createTraceabilityMatrix": true,
  "includeUseCases": true,
  "projectId": "task-ai-pro"
})

# 3. Get next task recommendations
get_next_task({
  "sprintCapacity": 40,
  "teamSkills": ["react", "node.js", "typescript"],
  "maxComplexity": 7,
  "includeAnalysis": true
})

# 4. Analyze complex tasks
analyze_task_complexity({
  "taskTitle": "Implement real-time collaboration",
  "taskDescription": "Build WebSocket-based real-time collaboration with conflict resolution",
  "teamExperience": "mixed",
  "includeBreakdown": true,
  "includeRisks": true
})

# 5. Break down complex tasks
expand_task({
  "taskTitle": "Build analytics dashboard",
  "taskDescription": "Create comprehensive analytics dashboard with AI insights",
  "currentComplexity": 8,
  "targetComplexity": 3,
  "includeEstimates": true,
  "includeDependencies": true
})

Fluxo de Trabalho de Adição de Funcionalidades

# Add new feature with complete lifecycle
add_feature({
  "featureIdea": "Advanced Analytics Dashboard",
  "description": "Real-time analytics with custom charts and AI-powered insights",
  "requestedBy": "product-manager",
  "businessJustification": "Increase user engagement and provide actionable insights",
  "targetUsers": ["project-managers", "team-leads", "executives"],
  "autoApprove": true,
  "expandToTasks": true,
  "createLifecycle": true
})

# This automatically creates:
# ✅ Business requirement analysis
# ✅ Use cases with actor-goal-scenario structure
# ✅ Tasks with complete traceability links
# ✅ Lifecycle tracking for all tasks

Rastreabilidade de Requisitos

# Create comprehensive traceability matrix
create_traceability_matrix({
  "projectId": "task-ai-pro",
  "prdContent": "<PRD content>",
  "features": [...],
  "tasks": [...],
  "validateCompleteness": true
})

# Output includes:
# ✅ Business Requirements → Features → Use Cases → Tasks
# ✅ Bidirectional traceability links
# ✅ Coverage analysis with gap identification
# ✅ Orphaned task detection
# ✅ Unimplemented requirement tracking

Geração Aprimorada de Contexto de Tarefas

# Default: Traceability-based context (fast, no AI required)
parse_prd({
  "prdContent": "<PRD content>",
  "enhancedGeneration": true,
  "contextLevel": "standard"
})

# Enhanced: AI-powered comprehensive context
parse_prd({
  "prdContent": "<PRD content>",
  "enhancedGeneration": true,
  "contextLevel": "full",
  "includeBusinessContext": true,
  "includeTechnicalContext": true,
  "includeImplementationGuidance": true
})

# Performance optimized: Minimal context for speed
parse_prd({
  "prdContent": "<PRD content>",
  "enhancedGeneration": true,
  "contextLevel": "minimal",
  "includeBusinessContext": false,
  "includeTechnicalContext": false,
  "includeImplementationGuidance": false
})

Níveis de Geração de Contexto:

Mínimo: Apenas contexto básico de rastreabilidade (mais rápido)
Padrão: Rastreabilidade + contexto básico de negócios (padrão)
Completo: Contexto completo aprimorado com IA, incluindo orientação de implementação

O Contexto de Tarefas Gerado Inclui:

Contexto de Negócios: Por que a tarefa é importante, impacto no usuário, métricas de sucesso
Contexto da Funcionalidade: Informações da funcionalidade pai, histórias de usuário, valor de negócio
Contexto Técnico: Restrições, decisões de arquitetura, pontos de integração
Orientação de Implementação: Recomendações passo a passo, melhores práticas, armadilhas
Critérios de Aceitação Aprimorados: Métodos de verificação detalhados e prioridades
Referências Contextuais: Links para seções relevantes do PRD e especificações técnicas

🧪 Testando a Geração Aprimorada de Contexto

A funcionalidade de geração aprimorada de contexto inclui cobertura abrangente de testes:

Arquivos de Teste Criados:

src/__tests__/TaskContextGenerationService.test.ts - Testes do serviço central de geração de contexto
src/__tests__/TaskGenerationService.enhanced.test.ts - Testes de integração da geração aprimorada de tarefas
src/__tests__/ParsePRDTool.enhanced.test.ts - Testes de geração de contexto em nível de ferramenta

Cobertura de Testes:

Geração de contexto baseada em rastreabilidade (comportamento padrão)
Geração de contexto aprimorada com IA (quando a IA está disponível)
Fallback gracioso quando os serviços de IA não estão disponíveis
Validação de configuração e manipulação de variáveis de ambiente
Tratamento de erros e testes de resiliência
Testes de integração com o pipeline existente de geração de tarefas

Executando Testes de Geração de Contexto:

# Run all AI-related tests (includes context generation)
npm run test:ai

# Run specific context generation tests
npm test -- --testPathPattern="TaskContextGeneration"
npm test -- --testPathPattern="enhanced"

# Run all tests
npm test

🧪 Suíte Abrangente de Testes E2E

O MCP GitHub Project Manager inclui uma suíte abrangente de testes de ponta a ponta que testa todas as ferramentas MCP por meio da interface MCP real, com chamadas de API simuladas e reais.

Cobertura de Testes:

✅ 40+ Ferramentas de Gerenciamento de Projetos GitHub - Operações CRUD completas para projetos, marcos, issues, sprints, labels e mais
✅ 8 Ferramentas de Gerenciamento de Tarefas com IA - Geração de PRD, análise de tarefas, análise de complexidade, gerenciamento de funcionalidades e rastreabilidade
✅ Integração de Fluxos de Trabalho Complexos - Fluxos de trabalho com múltiplas ferramentas e cenários reais de gerenciamento de projetos
✅ Testes com API Real - Testes opcionais com APIs reais do GitHub e de IA
✅ Validação de Esquemas - Validação abrangente de argumentos para todas as ferramentas
✅ Tratamento de Erros - Testes de tratamento gracioso de erros e recuperação

Início Rápido:

# Run comprehensive E2E tests (mocked APIs)
npm run test:e2e:tools

# Run with real APIs (requires credentials)
npm run test:e2e:tools:real

# Use the interactive test runner
npm run test:e2e:runner

# Run specific test categories
npm run test:e2e:tools:github     # GitHub tools only
npm run test:e2e:tools:ai         # AI tools only
npm run test:e2e:tools:workflows  # Integration workflows

Opções do Executor de Testes:

# Interactive test runner with options
node scripts/run-e2e-tests.js --help

# Examples:
node scripts/run-e2e-tests.js --real-api --github-only
node scripts/run-e2e-tests.js --build --verbose --timeout 120
node scripts/run-e2e-tests.js --ai-only --real-api

Configuração do Ambiente para Testes com API Real:

API do GitHub (Obrigatória para ferramentas GitHub):

GITHUB_TOKEN=ghp_your_github_token
GITHUB_OWNER=your-github-username
GITHUB_REPO=your-test-repository

APIs de IA (Obrigatórias para ferramentas de IA):

# At least one AI API key required
ANTHROPIC_API_KEY=sk-ant-your-anthropic-key
OPENAI_API_KEY=sk-your-openai-key
GOOGLE_API_KEY=your-google-ai-key
PERPLEXITY_API_KEY=pplx-your-perplexity-key

Habilitar Testes com API Real:

E2E_REAL_API=true npm run test:e2e:tools:real

Recursos dos Testes:

Validação de Registro de Ferramentas - Verifique se todas as ferramentas estão registradas corretamente com esquemas adequados
Conformidade com o Protocolo MCP - Garanta que todas as ferramentas sigam a especificação MCP
Validação de Formato de Resposta - Valide se as respostas das ferramentas correspondem aos formatos esperados
Testes de Integração de Fluxos de Trabalho - Teste fluxos de trabalho complexos com múltiplas ferramentas
Gerenciamento de Credenciais - Tratamento gracioso de credenciais ausentes
Monitoramento de Desempenho - Acompanhe o desempenho da execução das ferramentas
Testes Abrangentes de Erros - Valide o tratamento de erros e a recuperação

Documentação:

📖 Guia Abrangente de Testes E2E - Documentação detalhada de testes
🔧 Configuração de Testes - Configuração Jest para testes E2E
🛠️ Utilitários de Teste - Utilitários de teste reutilizáveis A suíte de testes E2E garante que todas as ferramentas MCP funcionem corretamente, tanto individualmente quanto em fluxos de trabalho complexos, proporcionando confiança na confiabilidade e na integração de todo o sistema.

Cenários de Teste Cobertos:

✅ Contexto baseado em rastreabilidade (sem necessidade de IA)
✅ Geração de contexto de negócios aprimorado por IA
✅ Geração de contexto técnico aprimorado por IA
✅ Geração de orientações de implementação
✅ Mesclagem de contexto e resolução de conflitos
✅ Tratamento de erros e degradação graciosa
✅ Validação de configuração e padrões
✅ Validação de parâmetros em nível de ferramenta
✅ Integração com o sistema de rastreabilidade existente

Instalação em Assistentes de IA

Instalação no Claude

Para instalar o servidor MCP no Claude Desktop:

{
  "mcpServers": {
    "github-project-manager": {
      "command": "npx",
      "args": ["-y", "mcp-github-project-manager"],
      "env": {
        "GITHUB_TOKEN": "your_github_token",
        "GITHUB_OWNER": "your_username",
        "GITHUB_REPO": "your_repo",
        "ANTHROPIC_API_KEY": "your_anthropic_api_key",
        "OPENAI_API_KEY": "your_openai_api_key",
        "GOOGLE_API_KEY": "your_google_api_key",
        "PERPLEXITY_API_KEY": "your_perplexity_api_key"
      }
    }
  }
}

Para o Claude Code CLI, execute:

claude mcp add github-project-manager -- npx -y mcp-github-project-manager

Instalação no Roocode

Adicione isto à sua configuração do Roocode:

{
  "mcpServers": {
    "github-project-manager": {
      "command": "npx",
      "args": ["-y", "mcp-github-project-manager"],
      "env": {
        "GITHUB_TOKEN": "your_github_token",
        "GITHUB_OWNER": "your_username",
        "GITHUB_REPO": "your_repo"
      }
    }
  }
}

Instalação no Windsurf

Adicione isto ao seu arquivo de configuração MCP do Windsurf:

{
  "mcpServers": {
    "github-project-manager": {
      "command": "npx",
      "args": ["-y", "mcp-github-project-manager"],
      "env": {
        "GITHUB_TOKEN": "your_github_token",
        "GITHUB_OWNER": "your_username",
        "GITHUB_REPO": "your_repo"
      }
    }
  }
}

Consulte a documentação MCP do Windsurf para obter mais informações.

Instalação no VS Code

Adicione isto ao seu arquivo de configuração MCP do VS Code:

{
  "servers": {
    "github-project-manager": {
      "type": "stdio",
      "command": "npx",
      "args": ["-y", "mcp-github-project-manager"],
      "env": {
        "GITHUB_TOKEN": "your_github_token",
        "GITHUB_OWNER": "your_username",
        "GITHUB_REPO": "your_repo"
      }
    }
  }
}

Consulte a documentação MCP do VS Code para obter mais informações.

Instalação no Cursor

Adicione isto ao seu arquivo de configuração MCP do Cursor:

{
  "mcpServers": {
    "github-project-manager": {
      "command": "npx",
      "args": ["-y", "mcp-github-project-manager"],
      "env": {
        "GITHUB_TOKEN": "your_github_token",
        "GITHUB_OWNER": "your_username",
        "GITHUB_REPO": "your_repo"
      }
    }
  }
}

Consulte a documentação MCP do Cursor para obter mais informações.

Usando Docker

Se você preferir executar o servidor MCP em um contêiner Docker:

Crie a Imagem Docker:

Crie um Dockerfile no diretório do seu projeto:

FROM node:18-alpine

WORKDIR /app

# Install the package globally
RUN npm install -g mcp-github-project-manager

# Default command to run the server
CMD ["mcp-github-project-manager"]

Crie a imagem:

docker build -t github-project-manager-mcp .

Configure Seu Cliente MCP:

Atualize a configuração do seu cliente MCP para usar o comando Docker:

{
  "mcpServers": {
    "github-project-manager": {
      "command": "docker",
      "args": ["run", "-i", "--rm", "github-project-manager-mcp"],
      "env": {
        "GITHUB_TOKEN": "your_github_token",
        "GITHUB_OWNER": "your_username",
        "GITHUB_REPO": "your_repo"
      }
    }
  }
}

Solução de Problemas

Problemas Comuns

Erros de Módulo Não Encontrado

Se você encontrar problemas de resolução de módulos, tente usar bunx em vez de npx:

{
  "mcpServers": {
    "github-project-manager": {
      "command": "bunx",
      "args": ["-y", "mcp-github-project-manager"]
    }
  }
}

Configuração Específica para Windows

No Windows, talvez seja necessário usar cmd para executar o comando:

{
  "mcpServers": {
    "github-project-manager": {
      "command": "cmd",
      "args": [
        "/c",
        "npx",
        "-y",
        "mcp-github-project-manager"
      ]
    }
  }
}

Problemas de Permissão

Se você encontrar problemas de permissão, certifique-se de que seu token do GitHub tenha as permissões necessárias listadas na seção de Configuração.

Arquitetura

O servidor segue os princípios da Clean Architecture com camadas distintas:

Camada de Domínio: Entidades principais, interfaces de repositório e esquemas Zod
Camada de Infraestrutura: Integração com a API do GitHub e implementações
Camada de Serviço: Coordenação da lógica de negócios
Camada MCP: Definições de ferramentas e tratamento de solicitações

Consulte ARCHITECTURE.md para obter a documentação detalhada da arquitetura.

Contribuição

Contribuições são bem-vindas! Consulte CONTRIBUTING.md para obter as diretrizes.

Faça um fork do repositório
Crie um branch de recurso: git checkout -b feature/amazing-feature
Faça commit das suas alterações: git commit -m 'Add some amazing feature'
Envie para o branch: git push origin feature/amazing-feature
Abra um Pull Request

Licença

Este projeto é licenciado sob a Licença MIT - consulte o arquivo LICENSE para obter detalhes.

Referências

Status Atual

Recursos Principais

Recurso	Status	Observações
Criação de Projetos	✅ Concluído	Suporte total para projetos v2
Gerenciamento de Marcos	✅ Concluído	Operações CRUD implementadas
Planejamento de Sprints	✅ Concluído	Incluindo rastreamento de métricas
Gerenciamento de Issues	✅ Concluído	Com suporte a campos personalizados
Versionamento de Recursos	✅ Concluído	Com bloqueio otimista e validação de esquema
Integração com Webhooks	📅 Planejado	Atualizações em tempo real

Recursos com IA

Recurso	Status	Observações
Geração de PRD	✅ Concluído	Suporte a IA de múltiplos provedores com criação abrangente de PRD
Geração de Tarefas	✅ Concluído	Análise de PRDs em tarefas acionáveis com IA
Adição de Recursos	✅ Concluído	Adição inteligente de recursos com análise de impacto
Análise de Complexidade de Tarefas	✅ Concluído	Análise detalhada com IA e avaliação de riscos
Recomendações de Tarefas	✅ Concluído	Recomendações de próximas tarefas com IA
Expansão de Tarefas	✅ Concluído	Divisão de tarefas complexas em subtarefas
Aprimoramento de PRD	✅ Concluído	Melhoria de PRD com IA e análise de lacunas
Rastreabilidade de Requisitos	✅ Concluído	Matriz de rastreabilidade de ponta a ponta com análise de cobertura

Rastreabilidade de Requisitos

Recurso	Status	Observações
Extração de Requisitos de Negócios	✅ Concluído	Extração de objetivos e métricas de sucesso do PRD
Geração de Casos de Uso	✅ Concluído	Estrutura ator-objetivo-cenário com alternativas
Links de Rastreabilidade	✅ Concluído	Links bidirecionais com análise de impacto
Análise de Cobertura	✅ Concluído	Identificação de lacunas e detecção de tarefas órfãs
Rastreamento de Alterações	✅ Concluído	Análise de impacto de alterações de requisitos
Rastreamento de Verificação	✅ Concluído	Mapeamento de casos de teste e status de verificação

Implementação MCP

Componente	Status	Observações
Definições de Ferramentas	✅ Concluído	Todas as ferramentas principais implementadas com validação Zod
Gerenciamento de Recursos	✅ Concluído	Operações CRUD completas com versionamento
Segurança	✅ Concluído	Validação de token e verificação de escopo
Tratamento de Erros	✅ Concluído	De acordo com as especificações MCP
Transporte	✅ Concluído	Suporte a Stdio e HTTP

Melhorias Recentes

Sistema de Recursos Aprimorado:
- Adicionada validação de esquema Zod para todos os tipos de recursos
- Implementado rastreamento de relacionamentos entre recursos
- Criado um ResourceFactory centralizado para acesso consistente a recursos
Integração Aprimorada com a API do GitHub:
- Adicionada limitação de taxa inteligente com limitação automática
- Implementado suporte a paginação para APIs REST e GraphQL
- Tratamento de erros aprimorado com tipos de erro específicos
Sistema Avançado de Ferramentas:
- Criado registro de definição de ferramentas com validação Zod
- Implementada formatação padronizada de respostas de ferramentas
- Adicionada documentação baseada em exemplos para todas as ferramentas
Formatação de Respostas Rica:
- Adicionado suporte a múltiplos tipos de conteúdo (JSON, Markdown, HTML, Texto)
- Implementadas atualizações de progresso para operações de longa duração
- Adicionado suporte a paginação para grandes conjuntos de resultados

Lacunas Funcionais Identificadas

Apesar das melhorias recentes, as seguintes lacunas funcionais ainda existem e são priorizadas para desenvolvimento futuro:

Estratégia de Cache Persistente:
- Embora o ResourceCache forneça cache em memória, ele não tem persistência entre reinicializações do servidor
- Sem cache distribuído para implantações de múltiplas instâncias
- Faltam políticas de despejo de cache para gerenciamento de memória
Processamento de Eventos em Tempo Real:
- Sem integração com webhooks para atualizações em tempo real do GitHub
- Falta um sistema de assinatura baseado em eventos para clientes
- Falta suporte a eventos enviados pelo servidor (SSE) para atualizações em streaming
Recursos Avançados do GitHub Projects v2:
- Suporte limitado para tipos de campos personalizados e validação
- Integração incompleta com os tipos de campos mais recentes do Projects v2 do GitHub
- Falta gerenciamento de regras de automação
Otimização de Desempenho:
- Sem agrupamento de consultas para recursos relacionados
- Falta atualização em segundo plano para recursos acessados com frequência
- Pré-busca incompleta para recursos relacionados
Visualização de Dados e Relatórios:
- Sem geradores de visualização integrados para métricas
- Faltam recursos de geração de relatórios
- Análise limitada de dados de séries temporais

Consulte docs/mcp/gaps-analysis.md para obter o status detalhado da implementação.

Documentação

Guia do Usuário - Instruções detalhadas de uso
Referência da API - Documentação abrangente das ferramentas
Tutoriais - Guias passo a passo
Exemplos - Exemplos de código para tarefas comuns
Arquitetura - Arquitetura e design do sistema
Contribuição - Diretrizes de desenvolvimento
Documentação MCP - Detalhes específicos do MCP

Documentação Interativa

Para uma exploração interativa da API, abra o API Explorer no seu navegador.

Desenvolvimento

Testes

# Unit tests
npm test

# Integration tests
npm run test:integration

# End-to-end tests
npm run test:e2e

Qualidade de Código

# Lint code
npm run lint

# Type check
npm run type-check

# Format code
npm run format

Contribuição

Aceitamos contribuições para o GitHub Project Manager MCP Server! Consulte nosso Guia de Contribuição para obter detalhes sobre:

Licença

MIT