@andrebuzeli/git-mcp 15.5.0 → 15.7.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@andrebuzeli/git-mcp",
-  "version": "15.5.0",
+  "version": "15.7.0",
   "private": false,
   "description": "MCP server para Git com operações locais e sincronização paralela GitHub/Gitea",
   "license": "MIT",

package/src/index.js

@@ -24,6 +24,7 @@ import { createGitDiffTool } from "./tools/git-diff.js";
 import { createGitCloneTool } from "./tools/git-clone.js";
 import { createGitHelpTool } from "./tools/git-help.js";
 import { getResources, readResource } from "./resources/index.js";
+import { createPromptsHandler, PROMPTS } from "./prompts/index.js";
 
 // Carrega variáveis de ambiente do arquivo .env (se existir)
 loadEnv();
@@ -46,11 +47,14 @@ if (!hasGitHub && !hasGitea) {
 
 const transport = new StdioServerTransport();
 const server = new Server(
-  { name: "git-mcpv2", version: "15.4.0" },
-  { capabilities: { tools: {}, resources: {} } }
+  { name: "git-mcpv2", version: "15.7.0" },
+  { capabilities: { tools: {}, resources: {}, prompts: {} } }
 );
 server.connect(transport);
 
+// Prompts handler
+const promptsHandler = createPromptsHandler(git, pm);
+
 // Ajv singleton para validação
 const ajv = new Ajv({ allErrors: true });
 
@@ -123,5 +127,20 @@ server.setRequestHandler(
   }
 );
 
+// ============ PROMPTS ============
+server.setRequestHandler(
+  (await import("@modelcontextprotocol/sdk/types.js")).ListPromptsRequestSchema,
+  async () => ({ prompts: PROMPTS })
+);
+
+server.setRequestHandler(
+  (await import("@modelcontextprotocol/sdk/types.js")).GetPromptRequestSchema,
+  async (req) => {
+    const name = req.params?.name || "";
+    const args = req.params?.arguments || {};
+    return await promptsHandler.get(name, args);
+  }
+);
+
 // Keep process alive
 process.stdin.resume();

package/src/prompts/index.js

@@ -0,0 +1,828 @@
+/**
+ * MCP Prompts para git-mcp
+ * 
+ * Prompts são templates reutilizáveis que guiam interações com o LLM.
+ * Diferente de Tools (executam lógica), Prompts retornam mensagens formatadas.
+ * UTILIZANDO APENAS O GIT-MCP
+ */
+
+// ============ PROMPT DEFINITIONS ============
+
+export const PROMPTS = [
+  {
+    name: "git-status",
+    description: "Mostra status completo do repositório Git. UTILIZANDO APENAS O GIT-MCP"
+  },
+  {
+    name: "git-history",
+    description: "Exibe histórico de commits do repositório. UTILIZANDO APENAS O GIT-MCP"
+  },
+  {
+    name: "git-remote",
+    description: "Lista e mostra informações dos remotes configurados. UTILIZANDO APENAS O GIT-MCP"
+  },
+  {
+    name: "git-commit",
+    description: "Prepara e cria commit das mudanças (sem configurar email). UTILIZANDO APENAS O GIT-MCP"
+  },
+  {
+    name: "git-push",
+    description: "Envia commits locais para os remotes (GitHub/Gitea). UTILIZANDO APENAS O GIT-MCP"
+  },
+  {
+    name: "git-cleanup",
+    description: "Limpa arquivos não rastreados do repositório. UTILIZANDO APENAS O GIT-MCP"
+  },
+  {
+    name: "git-review",
+    description: "Faz code review das mudanças atuais do repositório. UTILIZANDO APENAS O GIT-MCP"
+  },
+  {
+    name: "git-change",
+    description: "Gera changelog das mudanças desde última tag ou versão específica. UTILIZANDO APENAS O GIT-MCP"
+  },
+  {
+    name: "git-lint",
+    description: "Analisa código modificado procurando problemas comuns e más práticas. UTILIZANDO APENAS O GIT-MCP"
+  },
+  {
+    name: "git-debug",
+    description: "Ajuda a encontrar bugs analisando histórico de commits. UTILIZANDO APENAS O GIT-MCP"
+  },
+  {
+    name: "git-release",
+    description: "Cria release completa do projeto com tag e release notes. UTILIZANDO APENAS O GIT-MCP"
+  },
+  {
+    name: "git-update",
+    description: "Atualiza projeto completo nos providers: commit, push e sincroniza GitHub/Gitea. UTILIZANDO APENAS O GIT-MCP"
+  }
+];
+
+// ============ PROMPT TEMPLATES ============
+
+const PROMPT_TEMPLATES = {
+  "git-status": {
+    getMessages: (context) => [{
+      role: "user",
+      content: {
+        type: "text",
+        text: `# Status do Repositório Git
+
+Analise o status atual do repositório e forneça um resumo claro e acionável.
+
+## Status Atual
+
+- **Branch**: ${context.branch || "N/A"}
+- **Arquivos modificados**: ${context.modified?.length || 0}
+- **Arquivos staged**: ${context.staged?.length || 0}
+- **Arquivos não rastreados**: ${context.notAdded?.length || 0}
+- **Arquivos deletados**: ${context.deleted?.length || 0}
+- **Working tree limpa**: ${context.isClean ? "Sim" : "Não"}
+
+## Arquivos Modificados
+${context.modified?.map(f => `- ${f}`).join("\n") || "Nenhum"}
+
+## Arquivos Staged (prontos para commit)
+${context.staged?.map(f => `- ${f}`).join("\n") || "Nenhum"}
+
+## Arquivos Não Rastreados
+${context.notAdded?.map(f => `- ${f}`).join("\n") || "Nenhum"}
+
+## Instruções
+
+Forneça um resumo do status atual e sugira próximos passos. UTILIZANDO APENAS AS TOOLS DO GIT-MCP:
+- Use \`git-workflow\` para add, commit, push
+- Use \`git-branches\` para gerenciar branches
+- Use \`git-status\` apenas para consulta`
+      }
+    }]
+  },
+
+  "git-history": {
+    getMessages: (context) => {
+      const maxCount = context.maxCount || 20;
+      const userMessage = context.userMessage ? `\n\n## Observação do Usuário\n\n${context.userMessage}\n` : "";
+      
+      return [{
+        role: "user",
+        content: {
+          type: "text",
+          text: `# Histórico de Commits${userMessage}
+
+## Branch Atual
+${context.branch || "N/A"}
+
+## Últimos ${context.commits?.length || 0} Commits
+
+${context.commits?.map(c => {
+  const author = typeof c.author === 'object' ? c.author?.name : c.author || "Unknown";
+  const date = c.date ? new Date(c.date).toLocaleString('pt-BR') : "N/A";
+  return `### ${c.shortSha || c.sha?.substring(0, 7) || "N/A"}
+- **Autor**: ${author}
+- **Data**: ${date}
+- **Mensagem**: ${c.message || "Sem mensagem"}
+- **SHA completo**: ${c.sha || "N/A"}`;
+}).join("\n\n") || "Nenhum commit encontrado"}
+
+## Instruções
+
+Apresente o histórico de commits de forma organizada. UTILIZANDO APENAS AS TOOLS DO GIT-MCP:
+- Use \`git-history log\` para ver mais commits
+- Use \`git-diff compare\` para comparar commits
+- Use \`git-files read\` para ver arquivos em commits específicos`
+        }
+      }];
+    }
+  },
+
+  "git-remote": {
+    getMessages: (context) => [{
+      role: "user",
+      content: {
+        type: "text",
+        text: `# Remotes Configurados
+
+## Remotes Disponíveis
+
+${context.remotes?.map(r => `### ${r.name || r.remote || "N/A"}
+- **URL**: ${r.url || "N/A"}
+- **Tipo**: ${r.url?.includes("github.com") ? "GitHub" : r.url?.includes("gitea") ? "Gitea" : "Desconhecido"}
+`).join("\n") || "Nenhum remote configurado"}
+
+## Status dos Providers
+
+- **GitHub configurado**: ${context.hasGitHub ? "Sim" : "Não"}
+- **Gitea configurado**: ${context.hasGitea ? "Sim" : "Não"}
+
+## Instruções
+
+Apresente os remotes configurados e sugira configuração se necessário. UTILIZANDO APENAS AS TOOLS DO GIT-MCP:
+- Use \`git-remote list\` para ver remotes
+- Use \`git-remote ensure\` para configurar remotes automaticamente
+- Use \`git-workflow ensure-remotes\` como alternativa`
+      }
+    }]
+  },
+
+  "git-commit": {
+    getMessages: (context) => {
+      const userMessage = context.userMessage || "";
+      const suggestedMessage = userMessage || context.suggestedMessage || "";
+      
+      return [{
+        role: "user",
+        content: {
+          type: "text",
+          text: `# Criar Commit${userMessage ? `\n\n## Mensagem do Usuário\n\n${userMessage}\n` : ""}
+
+## Arquivos Staged (prontos para commit)
+${context.staged?.map(f => `- ${f}`).join("\n") || "Nenhum arquivo staged"}
+
+## Mudanças Staged
+\`\`\`diff
+${context.stagedDiff || "Use git-diff para ver mudanças"}
+\`\`\`
+
+## Status Atual
+- **Branch**: ${context.branch || "N/A"}
+- **Arquivos staged**: ${context.staged?.length || 0}
+- **Arquivos modificados (não staged)**: ${context.modified?.length || 0}
+
+## Instruções
+
+${context.staged?.length > 0 
+  ? `Crie um commit com as mudanças staged. ${userMessage ? `Use a mensagem fornecida pelo usuário: "${userMessage}"` : "Se não houver mensagem do usuário, sugira uma mensagem descritiva baseada nas mudanças."}
+
+UTILIZANDO APENAS AS TOOLS DO GIT-MCP:
+- Use \`git-workflow commit\` com a mensagem apropriada
+- NÃO configure email (o usuário não quer isso)
+- Se houver arquivos modificados não staged, sugira usar \`git-workflow add\` primeiro`
+  : `Não há arquivos staged para commit. Execute primeiro: \`git-workflow add\` com os arquivos desejados.
+
+UTILIZANDO APENAS AS TOOLS DO GIT-MCP:
+- Use \`git-workflow add\` para adicionar arquivos ao staging
+- Depois use \`git-workflow commit\` para criar o commit`}`
+        }
+      }];
+    }
+  },
+
+  "git-push": {
+    getMessages: (context) => {
+      const forceFlag = context.userMessage?.toLowerCase().includes("force") ? true : false;
+      
+      return [{
+        role: "user",
+        content: {
+          type: "text",
+          text: `# Push para Remotes
+
+## Status Atual
+- **Branch atual**: ${context.branch || "N/A"}
+- **Commits locais não enviados**: ${context.unpushedCommits || "Desconhecido"}
+- **Remotes configurados**: ${context.remotes?.map(r => r.name).join(", ") || "Nenhum"}
+- **Force push necessário?**: ${forceFlag ? "Sim (solicitado pelo usuário)" : "Não"}
+
+## Remotes Disponíveis
+${context.remotes?.map(r => `- **${r.name}**: ${r.url}`).join("\n") || "Nenhum"}
+
+## Instruções
+
+Envie os commits locais para os remotes (GitHub/Gitea). UTILIZANDO APENAS AS TOOLS DO GIT-MCP:
+- Use \`git-workflow push\` para enviar para todos os remotes em paralelo
+- ${forceFlag ? "Use force=true se necessário (foi solicitado)" : "Use force=true apenas se push for rejeitado"}
+- Se não houver remotes configurados, use \`git-remote ensure\` primeiro
+- Se não houver commits para enviar, informe o usuário`
+        }
+      }];
+    }
+  },
+
+  "git-cleanup": {
+    getMessages: (context) => [{
+      role: "user",
+      content: {
+        type: "text",
+        text: `# Limpar Arquivos Não Rastreados
+
+## Arquivos Não Rastreados Detectados
+${context.untrackedFiles?.map(f => `- ${f}`).join("\n") || "Nenhum arquivo não rastreado encontrado"}
+
+## Total de Arquivos para Limpar
+${context.untrackedFiles?.length || 0}
+
+## Instruções
+
+${context.untrackedFiles?.length > 0 
+  ? `Limpe os arquivos não rastreados do repositório. UTILIZANDO APENAS AS TOOLS DO GIT-MCP:
+- Use \`git-workflow clean\` para remover arquivos não rastreados
+- Antes de limpar, certifique-se de que não são arquivos importantes
+- Liste os arquivos que serão removidos antes de confirmar`
+  : `Não há arquivos não rastreados para limpar. O repositório está limpo.`}`
+      }
+    }]
+  },
+
+  "git-review": {
+    getMessages: (context) => {
+      const userMessage = context.userMessage ? `\n\n## Observação do Usuário\n\n${context.userMessage}\n` : "";
+      
+      return [{
+        role: "user",
+        content: {
+          type: "text",
+          text: `# Code Review Request${userMessage}
+
+Você é um code reviewer experiente. Analise as mudanças abaixo e forneça um review detalhado.
+
+## Mudanças para Review
+
+\`\`\`diff
+${context.diff || "Nenhuma mudança detectada"}
+\`\`\`
+
+## Arquivos Modificados
+${context.files?.map(f => `- ${f}`).join("\n") || "Nenhum arquivo modificado"}
+
+## Instruções de Review
+
+Por favor, analise:
+
+1. **🐛 Bugs Potenciais**: Identifique possíveis bugs ou erros lógicos
+2. **🔒 Segurança**: Verifique vulnerabilidades de segurança
+3. **⚡ Performance**: Aponte problemas de performance
+4. **📖 Legibilidade**: Sugira melhorias de código limpo
+5. **🧪 Testabilidade**: Comente sobre cobertura de testes
+6. **✅ Pontos Positivos**: Destaque o que está bem feito
+
+Formate sua resposta de forma clara e acionável. UTILIZANDO APENAS AS TOOLS DO GIT-MCP para coletar informações adicionais se necessário.`
+        }
+      }];
+    }
+  },
+
+  "git-change": {
+    getMessages: (context) => {
+      const sinceTag = context.userMessage || context.lastTag || null;
+      
+      return [{
+        role: "user",
+        content: {
+          type: "text",
+          text: `# Gerar Changelog
+
+## Informações da Versão
+
+- **Última tag**: ${context.lastTag || "Nenhuma tag encontrada"}
+- **Desde**: ${sinceTag || "última tag"}
+- **Branch**: ${context.branch || "N/A"}
+- **Commits desde última tag**: ${context.commits?.length || 0}
+
+## Commits para Changelog
+
+${context.commits?.map(c => {
+  const message = c.message || "Sem mensagem";
+  const sha = c.shortSha || c.sha?.substring(0, 7) || "N/A";
+  return `- \`${sha}\`: ${message}`;
+}).join("\n") || "Nenhum commit encontrado"}
+
+## Instruções
+
+Gere um changelog formatado baseado nos commits desde ${sinceTag || "a última tag"}. Organize por categorias:
+- ✨ **Features** (feat:, feature:)
+- 🐛 **Bug Fixes** (fix:, bug:)
+- 📝 **Documentation** (docs:)
+- 🔧 **Refactoring** (refactor:)
+- ⚡ **Performance** (perf:)
+- 🧪 **Tests** (test:)
+- 🔒 **Security** (security:)
+- 💥 **Breaking Changes** (BREAKING:)
+
+UTILIZANDO APENAS AS TOOLS DO GIT-MCP para coletar mais informações se necessário.`
+        }
+      }];
+    }
+  },
+
+  "git-lint": {
+    getMessages: (context) => [{
+      role: "user",
+      content: {
+        type: "text",
+        text: `# Análise de Código (Lint)
+
+## Arquivos para Analisar
+${context.modifiedFiles?.map(f => `- ${f}`).join("\n") || "Nenhum arquivo modificado"}
+
+## Mudanças nos Arquivos
+
+${context.fileContents?.map(({ file, content }) => {
+  const preview = content ? content.substring(0, 500) + (content.length > 500 ? "..." : "") : "Arquivo vazio ou não acessível";
+  return `### ${file}
+\`\`\`
+${preview}
+\`\`\``;
+}).join("\n\n") || "Nenhum conteúdo disponível"}
+
+## Instruções
+
+Analise o código modificado procurando:
+1. **Problemas comuns**: variáveis não usadas, imports desnecessários, código morto
+2. **Más práticas**: funções muito longas, complexidade ciclomática alta, código duplicado
+3. **Potenciais bugs**: uso incorreto de APIs, condições sempre verdadeiras/falsas
+4. **Performance**: loops ineficientes, operações custosas desnecessárias
+5. **Segurança**: uso inseguro de eval, concatenação SQL, XSS potencial
+6. **Padrões**: inconsistências de estilo, convenções de nomenclatura
+
+Forneça sugestões específicas e acionáveis. UTILIZANDO APENAS AS TOOLS DO GIT-MCP para coletar mais informações se necessário.`
+      }
+    }]
+  },
+
+  "git-debug": {
+    getMessages: (context) => {
+      const bugDescription = context.userMessage || "Qual bug você está procurando?";
+      const userContext = context.userMessage ? `\n\n## Descrição do Bug\n\n${bugDescription}\n` : `\n\n${bugDescription}`;
+      
+      return [{
+        role: "user",
+        content: {
+          type: "text",
+          text: `# Encontrar Bug no Histórico Git${userContext}
+
+Você é um detetive de bugs. Use o histórico Git para encontrar quando/onde um bug foi introduzido.
+
+## Informações do Repositório
+
+- **Branch**: ${context.branch || "N/A"}
+- **Total de commits**: ${context.totalCommits || "N/A"}
+
+## Últimos Commits
+${context.recentCommits?.map(c => {
+  const author = typeof c.author === 'object' ? c.author?.name : c.author || "Unknown";
+  return `- ${c.shortSha} | ${c.date} | ${author}: ${c.message}`;
+}).join("\n") || "Use git-history para ver commits"}
+
+## Estratégia de Debug
+
+1. **Identificar sintoma**: Descreva o bug que está procurando
+2. **Usar git-history**: Veja commits recentes
+3. **Analisar mudanças**: Compare commits suspeitos
+4. **Bisect manual**: 
+   - Identifique um commit "bom" (sem bug)
+   - Identifique um commit "ruim" (com bug)
+   - Analise commits no meio para encontrar o culpado
+5. **Verificar arquivo específico**: Leia arquivos em commits diferentes
+
+## Ferramentas Disponíveis
+
+UTILIZANDO APENAS AS TOOLS DO GIT-MCP:
+- \`git-history log\`: Ver histórico de commits
+- \`git-diff compare\`: Comparar entre commits/branches
+- \`git-files read\`: Ler arquivo em commit específico
+- \`git-diff show\`: Ver mudanças atuais
+
+Analise o histórico e sugira qual commit pode ter introduzido o bug.`
+        }
+      }];
+    }
+  },
+
+  "git-release": {
+    getMessages: (context) => [{
+      role: "user",
+      content: {
+        type: "text",
+        text: `# Criar Release do Projeto
+
+Você vai criar uma nova release deste projeto.
+
+## Informações Atuais
+
+- **Última tag**: ${context.lastTag || "Nenhuma tag encontrada"}
+- **Branch**: ${context.branch || "N/A"}
+- **Commits desde última tag**: ${context.commitsSinceTag || context.commits?.length || "N/A"}
+
+## Commits para esta Release
+${context.recentCommits?.map(c => `- ${c.shortSha}: ${c.message}`).join("\n") || "Use git-history para ver commits"}
+
+## Passos para Release
+
+1. **Determinar versão**: Baseado nos commits, sugira a próxima versão (semver)
+   - MAJOR (x.0.0): Breaking changes
+   - MINOR (0.x.0): Novas features
+   - PATCH (0.0.x): Bug fixes
+
+2. **Criar Tag**: Use \`git-tags create\` com:
+   - tag: "vX.Y.Z"
+   - message: Descrição da release
+
+3. **Push Tag**: Use \`git-tags push\`
+
+4. **Criar Release**: Use \`git-remote release-create\` com:
+   - tag: "vX.Y.Z"
+   - name: "Release vX.Y.Z"
+   - body: Release notes geradas
+
+## Template de Release Notes
+
+\`\`\`markdown
+## 🚀 Release vX.Y.Z
+
+### ✨ Novidades
+- Feature 1
+- Feature 2
+
+### 🐛 Correções
+- Fix 1
+- Fix 2
+
+### 📝 Outras Mudanças
+- Mudança 1
+\`\`\`
+
+Analise os commits e execute os passos para criar a release. UTILIZANDO APENAS AS TOOLS DO GIT-MCP.`
+      }
+    }]
+  },
+
+  "git-update": {
+    getMessages: (context) => [{
+      role: "user",
+      content: {
+        type: "text",
+        text: `# Atualizar Projeto nos Providers
+
+Você precisa atualizar este projeto Git nos providers remotos (GitHub/Gitea).
+
+## Status Atual do Repositório
+
+- **É repositório Git?**: ${context.isGitRepo ? "Sim" : "Não"}
+- **Branch atual**: ${context.branch || "N/A"}
+- **Arquivos modificados**: ${context.modified?.length || 0}
+- **Arquivos staged**: ${context.staged?.length || 0}
+- **Commits não enviados**: ${context.unpushedCommits || "N/A"}
+- **Remotes configurados**: ${context.remotes?.join(", ") || "Nenhum"}
+
+## Arquivos Modificados
+${context.modified?.map(f => `- ${f}`).join("\n") || "Nenhum"}
+
+## Instruções
+
+Atualize o projeto completo nos providers (GitHub e Gitea). Execute na ordem:
+
+1. **Se não é Git repo**: Use \`git-workflow init\` para inicializar
+2. **Se há arquivos modificados**: Use \`git-workflow add\` com files=["."]
+3. **Se há arquivos staged**: Use \`git-workflow commit\` com mensagem descritiva baseada nas mudanças
+4. **Se não há remotes**: Use \`git-remote ensure\` ou \`git-workflow ensure-remotes\` para configurar GitHub e Gitea
+5. **Se há commits locais**: Use \`git-workflow push\` para enviar para ambos os providers em paralelo
+
+UTILIZANDO APENAS AS TOOLS DO GIT-MCP. Execute todas as ferramentas git-* na ordem correta para sincronizar completamente o projeto nos dois providers.`
+      }
+    }]
+  }
+};
+
+// ============ PROMPT HANDLER ============
+
+/**
+ * Cria o handler de prompts para o MCP server
+ * @param {GitAdapter} git - Instância do GitAdapter
+ * @param {ProviderManager} pm - Instância do ProviderManager
+ */
+export function createPromptsHandler(git, pm) {
+  return {
+    list: async () => PROMPTS,
+    
+    get: async (name, args = {}) => {
+      const template = PROMPT_TEMPLATES[name];
+      if (!template) {
+        return {
+          description: `Prompt não encontrado: ${name}`,
+          messages: [{
+            role: "user",
+            content: { type: "text", text: `Erro: Prompt "${name}" não existe.` }
+          }]
+        };
+      }
+
+      // Coletar contexto baseado no prompt
+      const context = await gatherContext(name, args, git, pm);
+      
+      return {
+        description: PROMPTS.find(p => p.name === name)?.description || name,
+        messages: template.getMessages(context)
+      };
+    }
+  };
+}
+
+/**
+ * Coleta contexto necessário para cada prompt
+ */
+async function gatherContext(promptName, args, git, pm) {
+  const projectPath = args.projectPath || process.cwd();
+  const context = { 
+    projectPath,
+    // Mensagem opcional do usuário (pode vir como message, userMessage, text, input, ou no final da string)
+    userMessage: args.message || args.userMessage || args.text || args.input || args.query || null
+  };
+
+  try {
+    switch (promptName) {
+      case "git-status": {
+        const status = await git.status(projectPath).catch(() => null);
+        if (status) {
+          context.branch = status.currentBranch || status.current;
+          context.modified = status.modified || [];
+          context.staged = status.staged || [];
+          context.notAdded = status.notAdded || status.not_added || [];
+          context.deleted = status.deleted || [];
+          context.isClean = status.isClean || false;
+        }
+        break;
+      }
+
+      case "git-history": {
+        const branch = await git.getCurrentBranch(projectPath).catch(() => null);
+        const maxCount = parseInt(context.userMessage) || 20; // Se userMessage é número, usa como maxCount
+        const commits = await git.log(projectPath, { ref: "HEAD", maxCount }).catch(() => []);
+        
+        context.branch = branch;
+        context.commits = commits.map(c => ({
+          sha: c.sha,
+          shortSha: c.sha?.substring(0, 7),
+          message: c.message,
+          author: c.author,
+          date: c.date
+        }));
+        context.maxCount = maxCount;
+        // Se userMessage não é número, mantém como mensagem
+        if (isNaN(parseInt(context.userMessage))) {
+          // Mantém userMessage original
+        } else {
+          context.userMessage = null; // Remove se era número
+        }
+        break;
+      }
+
+      case "git-remote": {
+        const remotes = await git.listRemotes(projectPath).catch(() => []);
+        
+        context.remotes = remotes;
+        context.hasGitHub = !!pm.github;
+        context.hasGitea = !!(pm.giteaUrl && pm.giteaToken);
+        break;
+      }
+
+      case "git-commit": {
+        const status = await git.status(projectPath).catch(() => null);
+        const branch = await git.getCurrentBranch(projectPath).catch(() => null);
+        
+        context.branch = branch;
+        context.staged = status?.staged || [];
+        context.modified = status?.modified || [];
+        
+        // Se há arquivos staged, pega diff deles
+        if (context.staged.length > 0) {
+          try {
+            // Tenta usar diff normal (mostra mudanças staged se houver)
+            context.stagedDiff = await git.diff(projectPath).catch(() => "");
+            if (!context.stagedDiff || context.stagedDiff.trim() === "") {
+              context.stagedDiff = `Arquivos staged: ${context.staged.join(", ")}. Use git-diff para ver mudanças detalhadas.`;
+            }
+          } catch {
+            context.stagedDiff = `Arquivos staged: ${context.staged.join(", ")}`;
+          }
+        }
+        
+        // Sugere mensagem baseada nas mudanças
+        if (!context.userMessage && context.staged.length > 0) {
+          const fileNames = context.staged.slice(0, 3).join(", ");
+          context.suggestedMessage = `Update ${fileNames}${context.staged.length > 3 ? " and more" : ""}`;
+        }
+        break;
+      }
+
+      case "git-push": {
+        const branch = await git.getCurrentBranch(projectPath).catch(() => null);
+        const remotes = await git.listRemotes(projectPath).catch(() => []);
+        
+        context.branch = branch;
+        context.remotes = remotes;
+        // Tenta detectar commits não enviados (comparando local com remote)
+        try {
+          const localCommits = await git.log(projectPath, { ref: "HEAD", maxCount: 10 }).catch(() => []);
+          context.unpushedCommits = localCommits.length > 0 ? localCommits.length : "Desconhecido";
+        } catch {
+          context.unpushedCommits = "Desconhecido";
+        }
+        break;
+      }
+
+      case "git-cleanup": {
+        const untracked = await git.cleanUntracked(projectPath).catch(() => ({ cleaned: [] }));
+        context.untrackedFiles = untracked.cleaned || [];
+        break;
+      }
+
+      case "git-review": {
+        const status = await git.status(projectPath).catch(() => null);
+        const diff = await git.diff(projectPath).catch(() => "");
+        
+        context.diff = diff;
+        context.files = status ? [...(status.modified || []), ...(status.created || []), ...(status.deleted || [])] : [];
+        break;
+      }
+
+      case "git-change": {
+        const branch = await git.getCurrentBranch(projectPath).catch(() => null);
+        const tags = await git.listTags(projectPath).catch(() => []);
+        
+        context.branch = branch;
+        context.lastTag = tags.length > 0 ? tags[tags.length - 1] : null; // Última tag (mais recente)
+        
+        // Se userMessage é uma tag, usa ela, senão usa lastTag
+        const sinceTag = context.userMessage || context.lastTag;
+        
+        // Pega commits desde a tag ou todos se não há tag
+        let commits = [];
+        if (sinceTag && context.userMessage) {
+          // Se usuário especificou uma tag/versão
+          try {
+            commits = await git.log(projectPath, { ref: sinceTag + "..HEAD", maxCount: 100 }).catch(() => []);
+          } catch {
+            // Se falhar, pega todos os commits recentes
+            commits = await git.log(projectPath, { ref: "HEAD", maxCount: 50 }).catch(() => []);
+          }
+        } else if (context.lastTag) {
+          // Usa última tag se disponível
+          try {
+            commits = await git.log(projectPath, { ref: context.lastTag + "..HEAD", maxCount: 100 }).catch(() => []);
+          } catch {
+            commits = await git.log(projectPath, { ref: "HEAD", maxCount: 50 }).catch(() => []);
+          }
+        } else {
+          // Sem tag, pega commits recentes
+          commits = await git.log(projectPath, { ref: "HEAD", maxCount: 50 }).catch(() => []);
+        }
+        
+        context.commits = commits.map(c => ({
+          sha: c.sha,
+          shortSha: c.sha?.substring(0, 7),
+          message: c.message
+        }));
+        break;
+      }
+
+      case "git-lint": {
+        const status = await git.status(projectPath).catch(() => null);
+        const modifiedFiles = status ? [...(status.modified || []), ...(status.created || [])] : [];
+        
+        context.modifiedFiles = modifiedFiles;
+        
+        // Tenta ler conteúdo dos arquivos modificados (limitado a 5 para não sobrecarregar)
+        context.fileContents = [];
+        for (const file of modifiedFiles.slice(0, 5)) {
+          try {
+            const content = await git.readFile(projectPath, file, "HEAD").catch(() => null);
+            if (content) {
+              context.fileContents.push({ file, content });
+            }
+          } catch {
+            // Ignora erros ao ler arquivo
+          }
+        }
+        break;
+      }
+
+      case "git-debug": {
+        const branch = await git.getCurrentBranch(projectPath).catch(() => null);
+        const commits = await git.log(projectPath, { ref: "HEAD", maxCount: 20 }).catch(() => []);
+        
+        context.branch = branch;
+        context.totalCommits = commits.length;
+        context.recentCommits = commits.map(c => ({
+          sha: c.sha,
+          shortSha: c.sha?.substring(0, 7),
+          message: c.message,
+          author: typeof c.author === 'object' ? c.author?.name : c.author || "Unknown",
+          date: c.date ? new Date(c.date).toLocaleString('pt-BR') : "N/A"
+        }));
+        break;
+      }
+
+      case "git-release": {
+        const branch = await git.getCurrentBranch(projectPath).catch(() => null);
+        const tags = await git.listTags(projectPath).catch(() => []);
+        const commits = await git.log(projectPath, { ref: "HEAD", maxCount: 50 }).catch(() => []);
+        
+        context.branch = branch;
+        context.lastTag = tags.length > 0 ? tags[tags.length - 1] : null;
+        
+        // Commits desde última tag
+        if (context.lastTag) {
+          try {
+            // Tenta pegar commits desde a última tag usando range
+            const commitsSinceTag = await git.log(projectPath, { ref: context.lastTag + "..HEAD", maxCount: 50 }).catch(() => []);
+            context.commitsSinceTag = commitsSinceTag.length;
+            context.recentCommits = commitsSinceTag.slice(0, 20).map(c => ({
+              sha: c.sha,
+              shortSha: c.sha?.substring(0, 7),
+              message: c.message
+            }));
+          } catch {
+            // Se falhar, usa commits recentes como fallback
+            context.commitsSinceTag = commits.length;
+            context.recentCommits = commits.slice(0, 20).map(c => ({
+              sha: c.sha,
+              shortSha: c.sha?.substring(0, 7),
+              message: c.message
+            }));
+          }
+        } else {
+          // Sem tag, usa commits recentes
+          context.commitsSinceTag = commits.length;
+          context.recentCommits = commits.slice(0, 20).map(c => ({
+            sha: c.sha,
+            shortSha: c.sha?.substring(0, 7),
+            message: c.message
+          }));
+        }
+        break;
+      }
+
+      case "git-update": {
+        const isGitRepo = await git.isRepo(projectPath).catch(() => false);
+        context.isGitRepo = isGitRepo;
+        
+        if (isGitRepo) {
+          const status = await git.status(projectPath).catch(() => ({}));
+          const branch = await git.getCurrentBranch(projectPath).catch(() => null);
+          const remotes = await git.listRemotes(projectPath).catch(() => []);
+          
+          context.branch = branch;
+          context.modified = status.modified || [];
+          context.staged = status.staged || [];
+          context.remotes = remotes.map(r => r.name || r.remote);
+          
+          // Tenta detectar commits não enviados
+          try {
+            const localCommits = await git.log(projectPath, { ref: "HEAD", maxCount: 10 }).catch(() => []);
+            context.unpushedCommits = localCommits.length;
+          } catch {
+            context.unpushedCommits = "Desconhecido";
+          }
+        }
+        break;
+      }
+    }
+  } catch (e) {
+    context.error = e.message;
+    console.error(`[prompts] Error gathering context for ${promptName}:`, e);
+  }
+
+  return context;
+}
+

package/src/tools/git-workflow.js

@@ -14,7 +14,7 @@ export function createGitWorkflowTool(pm, git) {
       },
       action: { 
         type: "string", 
-        enum: ["init", "status", "add", "remove", "commit", "push", "ensure-remotes", "clean"],
+        enum: ["init", "status", "add", "remove", "commit", "push", "ensure-remotes", "clean", "update"],
         description: `Ação a executar:
 - init: Inicializa repositório git local E cria repos no GitHub/Gitea automaticamente
 - status: Retorna arquivos modificados, staged, untracked (use ANTES de commit para ver o que mudou)
@@ -23,7 +23,8 @@ export function createGitWorkflowTool(pm, git) {
 - commit: Cria commit com os arquivos staged (use DEPOIS de add)
 - push: Envia commits para GitHub E Gitea em paralelo (use DEPOIS de commit)
 - ensure-remotes: Configura remotes GitHub e Gitea (use se push falhar por falta de remote)
-- clean: Remove arquivos não rastreados do working directory`
+- clean: Remove arquivos não rastreados do working directory
+- update: Atualiza projeto completo: init (se necessário), add, commit, ensure-remotes e push`
       },
       files: { 
         type: "array", 
@@ -32,7 +33,7 @@ export function createGitWorkflowTool(pm, git) {
       },
       message: { 
         type: "string",
-        description: "Mensagem do commit. Obrigatório para action='commit'. Ex: 'feat: adiciona nova funcionalidade'"
+        description: "Mensagem do commit. Obrigatório para action='commit'. Opcional para action='update' (se não fornecido, usa mensagem padrão). Ex: 'feat: adiciona nova funcionalidade'"
       },
       force: { 
         type: "boolean", 
@@ -71,6 +72,7 @@ QUANDO USAR CADA ACTION:
 - init: Apenas uma vez, para novos projetos (cria .gitignore automaticamente)
 - ensure-remotes: Se push falhar por falta de configuração
 - clean: Limpar arquivos não rastreados
+- update: Para atualizar projeto completo (init + add + commit + push) - mais rápido que fazer cada ação separadamente
 
 EXEMPLOS DE USO:
 • Iniciar projeto: { "projectPath": "/path/to/project", "action": "init" }
@@ -285,8 +287,106 @@ EXEMPLOS DE USO:
         const result = await git.pushParallel(projectPath, branch, force);
         return asToolResult({ success: true, branch, ...result });
       }
+      if (action === "update") {
+        if (args.dryRun) {
+          return asToolResult({ 
+            success: true, 
+            dryRun: true,
+            message: "DRY RUN: Update completo seria executado (init se necessário, add, commit, push)"
+          });
+        }
+
+        const results = {
+          init: null,
+          ensureRemotes: null,
+          add: null,
+          commit: null,
+          push: null
+        };
+
+        const repo = getRepoNameFromPath(projectPath);
+        const isPublic = args.isPublic === true;
+
+        // 1. Verificar se é repo Git, se não for, fazer init
+        const isRepo = await git.isRepo(projectPath).catch(() => false);
+        if (!isRepo) {
+          await git.init(projectPath);
+          
+          // Criar .gitignore baseado no tipo de projeto
+          const shouldCreateGitignore = args.createGitignore !== false;
+          if (shouldCreateGitignore) {
+            const projectType = detectProjectType(projectPath);
+            const patterns = GITIGNORE_TEMPLATES[projectType] || GITIGNORE_TEMPLATES.general;
+            await git.createGitignore(projectPath, patterns);
+          }
+          
+          const ensured = await pm.ensureRepos({ repoName: repo, createIfMissing: true, isPublic });
+          results.init = { success: true, ensured, isPrivate: !isPublic, gitignoreCreated: shouldCreateGitignore };
+        } else {
+          results.init = { success: true, skipped: true, message: "Repositório já existe" };
+        }
+
+        // 2. Garantir remotes configurados (sempre verifica/configura)
+        const ensured = await pm.ensureRepos({ repoName: repo, createIfMissing: true, isPublic });
+        const ghOwner = await pm.getGitHubOwner();
+        const geOwner = await pm.getGiteaOwner();
+        const githubUrl = ghOwner ? `https://github.com/${ghOwner}/${repo}.git` : "";
+        const base = pm.giteaUrl?.replace(/\/$/, "") || "";
+        const giteaUrl = geOwner && base ? `${base}/${geOwner}/${repo}.git` : "";
+        await git.ensureRemotes(projectPath, { githubUrl, giteaUrl });
+        const remotes = await git.listRemotes(projectPath);
+        results.ensureRemotes = { success: true, ensured, remotes };
+
+        // 3. Verificar status e fazer add se necessário
+        const status = await git.status(projectPath);
+        if (!status.isClean || status.modified?.length > 0 || status.created?.length > 0 || status.notAdded?.length > 0) {
+          await git.add(projectPath, ["."]);
+          results.add = { success: true, files: ["."] };
+        } else {
+          results.add = { success: true, skipped: true, message: "Nenhum arquivo para adicionar" };
+        }
+
+        // 4. Verificar se há algo staged e fazer commit
+        const statusAfterAdd = await git.status(projectPath);
+        if (statusAfterAdd.staged?.length > 0) {
+          // Gerar mensagem padrão se não fornecida
+          const commitMessage = args.message || `Update: ${new Date().toISOString().split('T')[0]} - ${statusAfterAdd.staged.length} arquivo(s) modificado(s)`;
+          const sha = await git.commit(projectPath, commitMessage);
+          results.commit = { success: true, sha, message: commitMessage };
+        } else {
+          results.commit = { success: true, skipped: true, message: "Nenhum arquivo staged para commit" };
+        }
+
+        // 5. Fazer push (só se houver commits para enviar)
+        const branch = await git.getCurrentBranch(projectPath);
+        const force = !!args.force;
+        try {
+          const pushResult = await git.pushParallel(projectPath, branch, force);
+          results.push = { success: true, branch, ...pushResult };
+        } catch (pushError) {
+          // Se push falhar mas não houver commits, não é erro crítico
+          if (results.commit?.skipped) {
+            results.push = { success: true, skipped: true, message: "Nenhum commit para enviar" };
+          } else {
+            throw pushError;
+          }
+        }
+
+        // Resumo final
+        const allSuccess = Object.values(results).every(r => r?.success !== false);
+        const stepsExecuted = Object.entries(results)
+          .filter(([_, r]) => r && !r.skipped)
+          .map(([step, _]) => step);
+
+        return asToolResult({ 
+          success: allSuccess, 
+          message: `Update completo executado: ${stepsExecuted.join(" → ")}`,
+          results,
+          stepsExecuted
+        }, { tool: 'workflow', action: 'update' });
+      }
       return asToolError("VALIDATION_ERROR", `Ação '${action}' não suportada`, { 
-        availableActions: ["init", "status", "add", "remove", "commit", "push", "ensure-remotes"],
+        availableActions: ["init", "status", "add", "remove", "commit", "push", "ensure-remotes", "clean", "update"],
         suggestion: "Use uma das actions disponíveis"
       });
     } catch (e) {

package/src/utils/gitAdapter.js

@@ -166,6 +166,15 @@ export class GitAdapter {
         }
     }
 
+    /**
+     * Verifica se o diretório é um repositório git
+     * @param {string} dir - Diretório para verificar
+     * @returns {boolean} - true se é um repo git
+     */
+    async isRepo(dir) {
+        return fs.existsSync(path.join(dir, ".git"));
+    }
+
     /**
      * Verifica integridade do repositório git
      * @param {string} dir - Diretório do repositório
@@ -385,7 +394,7 @@ export class GitAdapter {
         return null;
     }
 
-    async pushOne(dir, remote, branch, force = false) {
+    async pushOne(dir, remote, branch, force = false, setUpstream = false) {
         const remoteUrl = await this._exec(dir, ["remote", "get-url", remote]);
         const header = this._getAuthHeader(remoteUrl);
 
@@ -395,13 +404,32 @@ export class GitAdapter {
         }
         args.push("push");
         if (force) args.push("--force");
-        args.push(remote, branch);
+        if (setUpstream) {
+            args.push("-u", remote, branch);
+        } else {
+            args.push(remote, branch);
+        }
 
         try {
             await this._exec(dir, args);
         } catch (e) {
-            if (e.message.includes("rejected")) {
-                throw createError("PUSH_REJECTED", { message: e.message, remote, branch });
+            const msg = e.message || "";
+            const msgLower = msg.toLowerCase();
+            
+            // Auto-correção: Se branch não existe no remote, tenta com -u (set-upstream)
+            const branchNotExists = msgLower.includes("has no upstream branch") || 
+                                   msgLower.includes("no upstream branch") ||
+                                   msgLower.includes("remote branch") && msgLower.includes("does not exist") ||
+                                   msgLower.includes("ref_not_found") ||
+                                   (msgLower.includes("fatal") && msgLower.includes("current branch") && msgLower.includes("has no upstream"));
+            
+            if (branchNotExists && !setUpstream && !force) {
+                console.error(`[GitAdapter] Auto-fix: branch '${branch}' não existe no remote '${remote}', tentando com --set-upstream (-u)...`);
+                return await this.pushOne(dir, remote, branch, force, true);
+            }
+            
+            if (msg.includes("rejected") || msgLower.includes("non-fast-forward")) {
+                throw createError("PUSH_REJECTED", { message: msg, remote, branch });
             }
             throw mapExternalError(e, { type: "push", remote, branch });
         }
@@ -416,13 +444,24 @@ export class GitAdapter {
             throw createError("REMOTE_NOT_FOUND", { message: "Nenhum remote github/gitea configurado" });
         }
 
-        // Parallel push com Promise.allSettled para melhor controle
+        // Parallel push com Promise.allSettled para melhor controle e auto-correção
         const pushPromises = remotes.map(async (remote) => {
             try {
-                await this.pushOne(dir, remote, branch, force);
-                return { remote, success: true };
+                await this.pushOne(dir, remote, branch, force, false);
+                return { remote, success: true, setUpstream: false };
             } catch (error) {
-                return { remote, success: false, error: error.message };
+                const errorMsg = error.message || String(error);
+                // Auto-correção: Se branch não existe no remote, tenta com --set-upstream
+                if ((errorMsg.includes("REF_NOT_FOUND") || errorMsg.includes("remote branch") || errorMsg.includes("has no upstream")) && !force) {
+                    try {
+                        console.error(`[GitAdapter] Auto-fix: branch '${branch}' não existe no remote '${remote}', tentando com --set-upstream...`);
+                        await this.pushOne(dir, remote, branch, force, true);
+                        return { remote, success: true, setUpstream: true };
+                    } catch (retryError) {
+                        return { remote, success: false, error: retryError.message, triedSetUpstream: true };
+                    }
+                }
+                return { remote, success: false, error: errorMsg };
             }
         });