@andrebuzeli/git-mcp 15.6.0 → 15.8.0

package/package.json

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

package/src/index.js

@@ -47,7 +47,7 @@ if (!hasGitHub && !hasGitea) {
 
 const transport = new StdioServerTransport();
 const server = new Server(
-  { name: "git-mcpv2", version: "15.6.0" },
+  { name: "git-mcpv2", version: "15.8.0" },
   { capabilities: { tools: {}, resources: {}, prompts: {} } }
 );
 server.connect(transport);

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) {