@andrebuzeli/git-mcp 15.8.4 → 15.8.6

package/src/tools/git-workflow.js

@@ -1,403 +1,403 @@
-import Ajv from "ajv";
-import { MCPError, asToolError, asToolResult, errorToResponse, createError } from "../utils/errors.js";
-import { getRepoNameFromPath, detectProjectType, GITIGNORE_TEMPLATES, validateProjectPath } from "../utils/repoHelpers.js";
-
-const ajv = new Ajv({ allErrors: true });
-
-export function createGitWorkflowTool(pm, git) {
-  const inputSchema = {
-    type: "object",
-    properties: {
-      projectPath: { 
-        type: "string", 
-        description: "Caminho absoluto do diretório do projeto (ex: 'C:/Users/user/projeto' ou '/home/user/projeto')" 
-      },
-      action: { 
-        type: "string", 
-        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)
-- add: Adiciona arquivos ao staging (use ANTES de commit)
-- remove: Remove arquivos do staging
-- 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
-- update: Atualiza projeto completo: init (se necessário), add, commit, ensure-remotes e push`
-      },
-      files: { 
-        type: "array", 
-        items: { type: "string" },
-        description: "Lista de arquivos para add/remove. Use ['.'] para todos os arquivos. Ex: ['src/index.js', 'package.json']"
-      },
-      message: { 
-        type: "string",
-        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", 
-        description: "Force push (use apenas se push normal falhar com erro de histórico divergente). Default: false"
-      },
-      createGitignore: {
-        type: "boolean",
-        description: "Se true, cria .gitignore padrão baseado no tipo de projeto (action='init'). Default: true"
-      },
-      isPublic: {
-        type: "boolean",
-        description: "Se true, repositório será PÚBLICO. Default: false (privado). Aplica-se a action='init' e 'ensure-remotes'"
-      },
-      dryRun: {
-        type: "boolean", 
-        description: "Se true, simula a operação sem executar (útil para testes). Default: false"
-      }
-    },
-    required: ["projectPath", "action"],
-    additionalProperties: false
-  };
-
-  const description = `Operações Git essenciais com sincronização automática GitHub + Gitea.
-
-FLUXO TÍPICO DE TRABALHO:
-1. git-workflow status → ver arquivos modificados
-2. git-workflow add → adicionar arquivos ao staging  
-3. git-workflow commit → criar commit
-4. git-workflow push → enviar para GitHub e Gitea
-
-QUANDO USAR CADA ACTION:
-- status: Para verificar estado atual do repositório
-- add: Quando há arquivos modificados para commitar
-- commit: Após add, para salvar as mudanças
-- push: Após commit, para sincronizar com remotes
-- 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" }
-• Ver mudanças: { "projectPath": "/path/to/project", "action": "status" }
-• Adicionar tudo: { "projectPath": "/path/to/project", "action": "add", "files": ["."] }
-• Commit: { "projectPath": "/path/to/project", "action": "commit", "message": "feat: add new feature" }
-• Push: { "projectPath": "/path/to/project", "action": "push" }`;
-
-  async function handle(args) {
-    const validate = ajv.compile(inputSchema);
-    if (!validate(args || {})) {
-      return asToolError("VALIDATION_ERROR", "Parâmetros inválidos", validate.errors);
-    }
-    const { projectPath, action } = args;
-    try {
-      // #region agent log
-      if (process.env.DEBUG_AGENT_LOG) {
-        fetch('http://127.0.0.1:8243/ingest/a7114eec-653b-43b0-9f09-7073baee17bf',{method:'POST',headers:{'Content-Type':'application/json'},body:JSON.stringify({sessionId:'debug-session',runId:'run1',hypothesisId:'H1',location:'git-workflow.js:handle-entry',message:'handle start',data:{action,projectPath},timestamp:Date.now()})}).catch(()=>{});
-      }
-      // #endregion
-
-      validateProjectPath(projectPath);
-      // #region agent log
-      if (process.env.DEBUG_AGENT_LOG) {
-        fetch('http://127.0.0.1:8243/ingest/a7114eec-653b-43b0-9f09-7073baee17bf',{method:'POST',headers:{'Content-Type':'application/json'},body:JSON.stringify({sessionId:'debug-session',runId:'run1',hypothesisId:'H1',location:'git-workflow.js:handle-validated',message:'projectPath validated',data:{action},timestamp:Date.now()})}).catch(()=>{});
-      }
-      // #endregion
-      if (action === "init") {
-        if (args.dryRun) {
-          return asToolResult({ 
-            success: true, 
-            dryRun: true,
-            message: "DRY RUN: Repositório seria inicializado localmente e nos providers",
-            repoName: getRepoNameFromPath(projectPath),
-            gitignoreCreated: shouldCreateGitignore
-          });
-        }
-        
-        await git.init(projectPath);
-        
-        // Criar .gitignore baseado no tipo de projeto
-        const shouldCreateGitignore = args.createGitignore !== false;
-        let gitignoreCreated = false;
-        if (shouldCreateGitignore) {
-          const projectType = detectProjectType(projectPath);
-          const patterns = GITIGNORE_TEMPLATES[projectType] || GITIGNORE_TEMPLATES.general;
-          await git.createGitignore(projectPath, patterns);
-          gitignoreCreated = true;
-        }
-        
-        const repo = getRepoNameFromPath(projectPath);
-        const isPublic = args.isPublic === true; // Default: privado
-        const ensured = await pm.ensureRepos({ repoName: repo, createIfMissing: true, isPublic });
-        return asToolResult({ 
-          success: true, 
-          ensured,
-          isPrivate: !isPublic,
-          gitignoreCreated,
-          message: "Repositório inicializado localmente e nos providers" + (gitignoreCreated ? " (.gitignore criado)" : "") + (!isPublic ? " [PRIVADO]" : " [PÚBLICO]")
-        });
-      }
-      if (action === "status") {
-        const st = await git.status(projectPath);
-        // #region agent log
-        if (process.env.DEBUG_AGENT_LOG) {
-          fetch('http://127.0.0.1:8243/ingest/a7114eec-653b-43b0-9f09-7073baee17bf',{method:'POST',headers:{'Content-Type':'application/json'},body:JSON.stringify({sessionId:'debug-session',runId:'run1',hypothesisId:'H2',location:'git-workflow.js:status',message:'status result',data:{modified:st.modified.length,created:st.created.length,deleted:st.deleted.length,notAdded:st.not_added.length,isClean:st.isClean},timestamp:Date.now()})}).catch(()=>{});
-        }
-        // #endregion
-        
-        if (args.dryRun) {
-          return asToolResult({ 
-            success: true, 
-            dryRun: true,
-            message: "DRY RUN: Status seria verificado",
-            ...st
-          });
-        }
-        
-        // Adicionar contexto para AI Agent decidir próximo passo
-        const hasUnstaged = st.not_added?.length > 0 || st.modified?.length > 0 || st.created?.length > 0;
-        const hasStaged = st.staged?.length > 0;
-        const hasConflicts = st.conflicted?.length > 0;
-        
-        let _aiContext = {
-          needsAdd: hasUnstaged && !hasStaged,
-          readyToCommit: hasStaged && !hasConflicts,
-          hasConflicts: hasConflicts,
-          isClean: st.isClean,
-          suggestedAction: null
-        };
-        
-        if (hasConflicts) {
-          _aiContext.suggestedAction = "Resolva os conflitos manualmente antes de continuar";
-        } else if (hasStaged) {
-          _aiContext.suggestedAction = "Use action='commit' com uma mensagem descritiva";
-        } else if (hasUnstaged) {
-          _aiContext.suggestedAction = "Use action='add' com files=['.'] para adicionar todas as mudanças";
-        } else {
-          _aiContext.suggestedAction = "Working tree limpa. Modifique arquivos ou use action='push' se há commits pendentes";
-        }
-        
-        return asToolResult({ ...st, _aiContext }, { tool: 'workflow', action: 'status' });
-      }
-      if (action === "add") {
-        const files = Array.isArray(args.files) && args.files.length ? args.files : ["."];
-        
-        if (args.dryRun) {
-          return asToolResult({ 
-            success: true, 
-            dryRun: true,
-            message: `DRY RUN: Arquivos seriam adicionados: ${files.join(", ")}`,
-            files
-          });
-        }
-        
-        await git.add(projectPath, files);
-        return asToolResult({ success: true, files }, { tool: 'workflow', action: 'add' });
-      }
-      if (action === "remove") {
-        const files = Array.isArray(args.files) ? args.files : [];
-        await git.remove(projectPath, files);
-        return asToolResult({ success: true, files });
-      }
-      if (action === "commit") {
-        if (!args.message) {
-          return asToolError("MISSING_PARAMETER", "message é obrigatório para commit", { parameter: "message" });
-        }
-        
-        if (args.dryRun) {
-          return asToolResult({ 
-            success: true, 
-            dryRun: true,
-            message: `DRY RUN: Commit seria criado com mensagem: "${args.message}"`
-          });
-        }
-        
-        const sha = await git.commit(projectPath, args.message);
-        // #region agent log
-        if (process.env.DEBUG_AGENT_LOG) {
-          fetch('http://127.0.0.1:8243/ingest/a7114eec-653b-43b0-9f09-7073baee17bf',{method:'POST',headers:{'Content-Type':'application/json'},body:JSON.stringify({sessionId:'debug-session',runId:'run1',hypothesisId:'H3',location:'git-workflow.js:commit',message:'commit created',data:{sha,message:args.message},timestamp:Date.now()})}).catch(()=>{});
-        }
-        // #endregion
-        return asToolResult({ success: true, sha, message: args.message }, { tool: 'workflow', action: 'commit' });
-      }
-      if (action === "clean") {
-        if (args.dryRun) {
-          const result = await git.cleanUntracked(projectPath);
-          return asToolResult({ 
-            success: true, 
-            dryRun: true,
-            message: `DRY RUN: ${result.cleaned.length} arquivo(s) seriam removidos`,
-            wouldClean: result.cleaned
-          });
-        }
-        
-        const result = await git.cleanUntracked(projectPath);
-        return asToolResult({ 
-          success: true, 
-          ...result,
-          message: result.cleaned.length > 0 
-            ? `${result.cleaned.length} arquivo(s) não rastreados removidos`
-            : "Nenhum arquivo para limpar"
-        });
-      }
-      if (action === "ensure-remotes") {
-        const repo = getRepoNameFromPath(projectPath);
-        const isPublic = args.isPublic === true; // Default: privado
-        
-        if (args.dryRun) {
-          const ensured = await pm.ensureRepos({ repoName: repo, createIfMissing: false, isPublic }); // Don't create for dry run
-          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` : "";
-          
-          return asToolResult({ 
-            success: true, 
-            dryRun: true,
-            message: "DRY RUN: Remotes seriam configurados",
-            repo,
-            githubUrl,
-            giteaUrl,
-            ensured
-          });
-        }
-        
-        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);
-        return asToolResult({ success: true, ensured, remotes, isPrivate: !isPublic }, { tool: 'workflow', action: 'ensure-remotes' });
-      }
-      if (action === "push") {
-        const branch = await git.getCurrentBranch(projectPath);
-        const force = !!args.force;
-        
-        if (args.dryRun) {
-          return asToolResult({ 
-            success: true, 
-            dryRun: true,
-            message: `DRY RUN: Push seria executado na branch '${branch}'${force ? ' (force)' : ''}`,
-            branch,
-            force
-          });
-        }
-        
-        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", "clean", "update"],
-        suggestion: "Use uma das actions disponíveis"
-      });
-    } catch (e) {
-      return errorToResponse(e);
-    }
-  }
-
-  return {
-    name: "git-workflow",
-    description,
-    inputSchema,
-    handle
-  };
-}
+import Ajv from "ajv";
+import { MCPError, asToolError, asToolResult, errorToResponse, createError } from "../utils/errors.js";
+import { getRepoNameFromPath, detectProjectType, GITIGNORE_TEMPLATES, validateProjectPath } from "../utils/repoHelpers.js";
+
+const ajv = new Ajv({ allErrors: true });
+
+export function createGitWorkflowTool(pm, git) {
+  const inputSchema = {
+    type: "object",
+    properties: {
+      projectPath: { 
+        type: "string", 
+        description: "Caminho absoluto do diretório do projeto (ex: 'C:/Users/user/projeto' ou '/home/user/projeto')" 
+      },
+      action: { 
+        type: "string", 
+        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)
+- add: Adiciona arquivos ao staging (use ANTES de commit)
+- remove: Remove arquivos do staging
+- 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
+- update: Atualiza projeto completo: init (se necessário), add, commit, ensure-remotes e push`
+      },
+      files: { 
+        type: "array", 
+        items: { type: "string" },
+        description: "Lista de arquivos para add/remove. Use ['.'] para todos os arquivos. Ex: ['src/index.js', 'package.json']"
+      },
+      message: { 
+        type: "string",
+        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", 
+        description: "Force push (use apenas se push normal falhar com erro de histórico divergente). Default: false"
+      },
+      createGitignore: {
+        type: "boolean",
+        description: "Se true, cria .gitignore padrão baseado no tipo de projeto (action='init'). Default: true"
+      },
+      isPublic: {
+        type: "boolean",
+        description: "Se true, repositório será PÚBLICO. Default: false (privado). Aplica-se a action='init' e 'ensure-remotes'"
+      },
+      dryRun: {
+        type: "boolean", 
+        description: "Se true, simula a operação sem executar (útil para testes). Default: false"
+      }
+    },
+    required: ["projectPath", "action"],
+    additionalProperties: false
+  };
+
+  const description = `Operações Git essenciais com sincronização automática GitHub + Gitea.
+
+FLUXO TÍPICO DE TRABALHO:
+1. git-workflow status → ver arquivos modificados
+2. git-workflow add → adicionar arquivos ao staging  
+3. git-workflow commit → criar commit
+4. git-workflow push → enviar para GitHub e Gitea
+
+QUANDO USAR CADA ACTION:
+- status: Para verificar estado atual do repositório
+- add: Quando há arquivos modificados para commitar
+- commit: Após add, para salvar as mudanças
+- push: Após commit, para sincronizar com remotes
+- 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" }
+• Ver mudanças: { "projectPath": "/path/to/project", "action": "status" }
+• Adicionar tudo: { "projectPath": "/path/to/project", "action": "add", "files": ["."] }
+• Commit: { "projectPath": "/path/to/project", "action": "commit", "message": "feat: add new feature" }
+• Push: { "projectPath": "/path/to/project", "action": "push" }`;
+
+  async function handle(args) {
+    const validate = ajv.compile(inputSchema);
+    if (!validate(args || {})) {
+      return asToolError("VALIDATION_ERROR", "Parâmetros inválidos", validate.errors);
+    }
+    const { projectPath, action } = args;
+    try {
+      // #region agent log
+      if (process.env.DEBUG_AGENT_LOG) {
+        fetch('http://127.0.0.1:8243/ingest/a7114eec-653b-43b0-9f09-7073baee17bf',{method:'POST',headers:{'Content-Type':'application/json'},body:JSON.stringify({sessionId:'debug-session',runId:'run1',hypothesisId:'H1',location:'git-workflow.js:handle-entry',message:'handle start',data:{action,projectPath},timestamp:Date.now()})}).catch(()=>{});
+      }
+      // #endregion
+
+      validateProjectPath(projectPath);
+      // #region agent log
+      if (process.env.DEBUG_AGENT_LOG) {
+        fetch('http://127.0.0.1:8243/ingest/a7114eec-653b-43b0-9f09-7073baee17bf',{method:'POST',headers:{'Content-Type':'application/json'},body:JSON.stringify({sessionId:'debug-session',runId:'run1',hypothesisId:'H1',location:'git-workflow.js:handle-validated',message:'projectPath validated',data:{action},timestamp:Date.now()})}).catch(()=>{});
+      }
+      // #endregion
+      if (action === "init") {
+        if (args.dryRun) {
+          return asToolResult({ 
+            success: true, 
+            dryRun: true,
+            message: "DRY RUN: Repositório seria inicializado localmente e nos providers",
+            repoName: getRepoNameFromPath(projectPath),
+            gitignoreCreated: shouldCreateGitignore
+          });
+        }
+        
+        await git.init(projectPath);
+        
+        // Criar .gitignore baseado no tipo de projeto
+        const shouldCreateGitignore = args.createGitignore !== false;
+        let gitignoreCreated = false;
+        if (shouldCreateGitignore) {
+          const projectType = detectProjectType(projectPath);
+          const patterns = GITIGNORE_TEMPLATES[projectType] || GITIGNORE_TEMPLATES.general;
+          await git.createGitignore(projectPath, patterns);
+          gitignoreCreated = true;
+        }
+        
+        const repo = getRepoNameFromPath(projectPath);
+        const isPublic = args.isPublic === true; // Default: privado
+        const ensured = await pm.ensureRepos({ repoName: repo, createIfMissing: true, isPublic });
+        return asToolResult({ 
+          success: true, 
+          ensured,
+          isPrivate: !isPublic,
+          gitignoreCreated,
+          message: "Repositório inicializado localmente e nos providers" + (gitignoreCreated ? " (.gitignore criado)" : "") + (!isPublic ? " [PRIVADO]" : " [PÚBLICO]")
+        });
+      }
+      if (action === "status") {
+        const st = await git.status(projectPath);
+        // #region agent log
+        if (process.env.DEBUG_AGENT_LOG) {
+          fetch('http://127.0.0.1:8243/ingest/a7114eec-653b-43b0-9f09-7073baee17bf',{method:'POST',headers:{'Content-Type':'application/json'},body:JSON.stringify({sessionId:'debug-session',runId:'run1',hypothesisId:'H2',location:'git-workflow.js:status',message:'status result',data:{modified:st.modified.length,created:st.created.length,deleted:st.deleted.length,notAdded:st.not_added.length,isClean:st.isClean},timestamp:Date.now()})}).catch(()=>{});
+        }
+        // #endregion
+        
+        if (args.dryRun) {
+          return asToolResult({ 
+            success: true, 
+            dryRun: true,
+            message: "DRY RUN: Status seria verificado",
+            ...st
+          });
+        }
+        
+        // Adicionar contexto para AI Agent decidir próximo passo
+        const hasUnstaged = st.not_added?.length > 0 || st.modified?.length > 0 || st.created?.length > 0;
+        const hasStaged = st.staged?.length > 0;
+        const hasConflicts = st.conflicted?.length > 0;
+        
+        let _aiContext = {
+          needsAdd: hasUnstaged && !hasStaged,
+          readyToCommit: hasStaged && !hasConflicts,
+          hasConflicts: hasConflicts,
+          isClean: st.isClean,
+          suggestedAction: null
+        };
+        
+        if (hasConflicts) {
+          _aiContext.suggestedAction = "Resolva os conflitos manualmente antes de continuar";
+        } else if (hasStaged) {
+          _aiContext.suggestedAction = "Use action='commit' com uma mensagem descritiva";
+        } else if (hasUnstaged) {
+          _aiContext.suggestedAction = "Use action='add' com files=['.'] para adicionar todas as mudanças";
+        } else {
+          _aiContext.suggestedAction = "Working tree limpa. Modifique arquivos ou use action='push' se há commits pendentes";
+        }
+        
+        return asToolResult({ ...st, _aiContext }, { tool: 'workflow', action: 'status' });
+      }
+      if (action === "add") {
+        const files = Array.isArray(args.files) && args.files.length ? args.files : ["."];
+        
+        if (args.dryRun) {
+          return asToolResult({ 
+            success: true, 
+            dryRun: true,
+            message: `DRY RUN: Arquivos seriam adicionados: ${files.join(", ")}`,
+            files
+          });
+        }
+        
+        await git.add(projectPath, files);
+        return asToolResult({ success: true, files }, { tool: 'workflow', action: 'add' });
+      }
+      if (action === "remove") {
+        const files = Array.isArray(args.files) ? args.files : [];
+        await git.remove(projectPath, files);
+        return asToolResult({ success: true, files });
+      }
+      if (action === "commit") {
+        if (!args.message) {
+          return asToolError("MISSING_PARAMETER", "message é obrigatório para commit", { parameter: "message" });
+        }
+        
+        if (args.dryRun) {
+          return asToolResult({ 
+            success: true, 
+            dryRun: true,
+            message: `DRY RUN: Commit seria criado com mensagem: "${args.message}"`
+          });
+        }
+        
+        const sha = await git.commit(projectPath, args.message);
+        // #region agent log
+        if (process.env.DEBUG_AGENT_LOG) {
+          fetch('http://127.0.0.1:8243/ingest/a7114eec-653b-43b0-9f09-7073baee17bf',{method:'POST',headers:{'Content-Type':'application/json'},body:JSON.stringify({sessionId:'debug-session',runId:'run1',hypothesisId:'H3',location:'git-workflow.js:commit',message:'commit created',data:{sha,message:args.message},timestamp:Date.now()})}).catch(()=>{});
+        }
+        // #endregion
+        return asToolResult({ success: true, sha, message: args.message }, { tool: 'workflow', action: 'commit' });
+      }
+      if (action === "clean") {
+        if (args.dryRun) {
+          const result = await git.cleanUntracked(projectPath);
+          return asToolResult({ 
+            success: true, 
+            dryRun: true,
+            message: `DRY RUN: ${result.cleaned.length} arquivo(s) seriam removidos`,
+            wouldClean: result.cleaned
+          });
+        }
+        
+        const result = await git.cleanUntracked(projectPath);
+        return asToolResult({ 
+          success: true, 
+          ...result,
+          message: result.cleaned.length > 0 
+            ? `${result.cleaned.length} arquivo(s) não rastreados removidos`
+            : "Nenhum arquivo para limpar"
+        });
+      }
+      if (action === "ensure-remotes") {
+        const repo = getRepoNameFromPath(projectPath);
+        const isPublic = args.isPublic === true; // Default: privado
+        
+        if (args.dryRun) {
+          const ensured = await pm.ensureRepos({ repoName: repo, createIfMissing: false, isPublic }); // Don't create for dry run
+          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` : "";
+          
+          return asToolResult({ 
+            success: true, 
+            dryRun: true,
+            message: "DRY RUN: Remotes seriam configurados",
+            repo,
+            githubUrl,
+            giteaUrl,
+            ensured
+          });
+        }
+        
+        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);
+        return asToolResult({ success: true, ensured, remotes, isPrivate: !isPublic }, { tool: 'workflow', action: 'ensure-remotes' });
+      }
+      if (action === "push") {
+        const branch = await git.getCurrentBranch(projectPath);
+        const force = !!args.force;
+        
+        if (args.dryRun) {
+          return asToolResult({ 
+            success: true, 
+            dryRun: true,
+            message: `DRY RUN: Push seria executado na branch '${branch}'${force ? ' (force)' : ''}`,
+            branch,
+            force
+          });
+        }
+        
+        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", "clean", "update"],
+        suggestion: "Use uma das actions disponíveis"
+      });
+    } catch (e) {
+      return errorToResponse(e);
+    }
+  }
+
+  return {
+    name: "git-workflow",
+    description,
+    inputSchema,
+    handle
+  };
+}