@andre.buzeli/git-mcp 16.1.2 → 16.1.4

package/src/tools/git-workflow.js

@@ -3,6 +3,7 @@ import fs from "fs";
 import path from "path";
 import { asToolError, asToolResult, errorToResponse, createError } from "../utils/errors.js";
 import { getRepoNameFromPath, detectProjectType, GITIGNORE_TEMPLATES, validateProjectPath, withRetry } from "../utils/repoHelpers.js";
+import { resolveWorktreeContext, isProtectedPath } from "../utils/worktreeResolver.js";
 import { sendLog } from "../utils/mcpNotify.js";
 
 const ajv = new Ajv({ allErrors: true });
@@ -40,7 +41,8 @@ export function createGitWorkflowTool(pm, git, server) {
       files: {
         type: "array",
         items: { type: "string" },
-        description: "Lista de arquivos para add/remove. Use ['.'] para todos os arquivos. Ex: ['src/index.js', 'package.json']"
+        default: ["."],
+        description: "Lista de arquivos para add/remove. Default: ['.'] (todos). Ex: ['src/index.js', 'package.json']"
       },
       message: {
         type: "string",
@@ -61,22 +63,27 @@ export function createGitWorkflowTool(pm, git, server) {
       },
       force: {
         type: "boolean",
+        default: false,
         description: "Force push (use apenas se push normal falhar com erro de histórico divergente). Default: false"
       },
       createGitignore: {
         type: "boolean",
+        default: true,
         description: "Se true, cria .gitignore padrão baseado no tipo de projeto (action='init'). Default: true"
       },
       isPublic: {
         type: "boolean",
+        default: false,
         description: "Se true, repositório será PÚBLICO. Default: false (privado). Aplica-se a action='init' e 'ensure-remotes'"
       },
       dryRun: {
         type: "boolean",
+        default: false,
         description: "Se true, simula a operação sem executar (útil para testes). Default: false"
       },
       skipIfClean: {
         type: "boolean",
+        default: false,
         description: "Para action='update': se true, pula silenciosamente se não houver mudanças. Default: false"
       },
       gitignore: {
@@ -132,8 +139,32 @@ EXEMPLOS DE USO:
       return asToolError("VALIDATION_ERROR", "Parâmetros inválidos", validate.errors);
     }
     const { projectPath, action } = args;
+    let effectivePath = projectPath;
+    let worktreeCtx = null;
+
     try {
       validateProjectPath(projectPath);
+
+      if (action === "init") {
+          if (isProtectedPath(projectPath)) {
+              return asToolError("PROTECTED_PATH", `Não é permitido criar repositório git em ${projectPath}`);
+          }
+      } else {
+          worktreeCtx = await resolveWorktreeContext(projectPath, git);
+          effectivePath = worktreeCtx.worktreePath;
+
+          // Ajustar paths relativos se estivermos rodando da raiz
+          if (effectivePath !== projectPath && Array.isArray(args.files)) {
+              const rel = path.relative(effectivePath, projectPath);
+              args.files = args.files.map(f => {
+                  if (path.isAbsolute(f)) return f;
+                  // Se for ".", vira o próprio diretório relativo
+                  if (f === ".") return rel.replace(/\\/g, '/');
+                  return path.join(rel, f).replace(/\\/g, '/');
+              });
+          }
+      }
+
       if (action === "init") {
         const shouldCreateGitignore = args.createGitignore !== false;
 
@@ -142,37 +173,37 @@ EXEMPLOS DE USO:
             success: true,
             dryRun: true,
             message: "DRY RUN: Repositório seria inicializado localmente e nos providers",
-            repoName: getRepoNameFromPath(projectPath),
+            repoName: getRepoNameFromPath(effectivePath),
             gitignoreCreated: shouldCreateGitignore
           });
         }
 
-        const isRepo = await git.isRepo(projectPath);
+        const isRepo = await git.isRepo(effectivePath);
         if (!isRepo) {
-          await git.init(projectPath);
+          await git.init(effectivePath);
         }
 
         // Criar .gitignore baseado no tipo de projeto (apenas se não existir ou se for novo repo)
         let gitignoreCreated = false;
 
         if (shouldCreateGitignore) {
-          const hasGitignore = fs.existsSync(path.join(projectPath, ".gitignore"));
+          const hasGitignore = fs.existsSync(path.join(effectivePath, ".gitignore"));
           if (!hasGitignore) {
-            const projectType = detectProjectType(projectPath);
+            const projectType = detectProjectType(effectivePath);
             const patterns = GITIGNORE_TEMPLATES[projectType] || GITIGNORE_TEMPLATES.general;
-            await git.createGitignore(projectPath, patterns);
+            await git.createGitignore(effectivePath, patterns);
             gitignoreCreated = true;
           }
         }
 
-        const repo = getRepoNameFromPath(projectPath);
+        const repo = getRepoNameFromPath(effectivePath);
         const isPublic = args.isPublic === true; // Default: privado
         const organization = args.organization || undefined;
         const ensured = await pm.ensureRepos({ repoName: repo, createIfMissing: true, isPublic, organization });
 
         // Configurar remotes com org se fornecida
         const urls = await pm.getRemoteUrls(repo, organization);
-        await git.ensureRemotes(projectPath, { githubUrl: urls.github || "", giteaUrl: urls.gitea || "" });
+        await git.ensureRemotes(effectivePath, { githubUrl: urls.github || "", giteaUrl: urls.gitea || "" });
 
         return asToolResult({
           success: true,
@@ -184,7 +215,7 @@ EXEMPLOS DE USO:
         });
       }
       if (action === "status") {
-        const st = await git.status(projectPath);
+        const st = await git.status(effectivePath);
 
         if (args.dryRun) {
           return asToolResult({
@@ -218,7 +249,15 @@ EXEMPLOS DE USO:
           _aiContext.suggestedAction = "Working tree limpa. Modifique arquivos ou use action='push' se há commits pendentes";
         }
 
-        return asToolResult({ ...st, _aiContext }, { tool: 'workflow', action: 'status' });
+        const result = { ...st, _aiContext };
+        if (worktreeCtx?.isWorktree) {
+            result._worktreeContext = {
+                detected: true,
+                repoRoot: worktreeCtx.repoRoot,
+                branch: worktreeCtx.branch
+            };
+        }
+        return asToolResult(result, { tool: 'workflow', action: 'status' });
       }
       if (action === "add") {
         const files = Array.isArray(args.files) && args.files.length ? args.files : ["."];
@@ -232,12 +271,12 @@ EXEMPLOS DE USO:
           });
         }
 
-        await git.add(projectPath, files);
+        await git.add(effectivePath, 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);
+        await git.remove(effectivePath, files);
         return asToolResult({ success: true, files });
       }
       if (action === "commit") {
@@ -253,12 +292,20 @@ EXEMPLOS DE USO:
           });
         }
 
-        const sha = await git.commit(projectPath, args.message);
+        const st = await git.status(effectivePath);
+        if (!st.staged || st.staged.length === 0) {
+            return asToolError("NOTHING_TO_COMMIT", "Nenhum arquivo staged para commitar", {
+                suggestion: "Use action='add' com files=['.'] para adicionar arquivos ao staging antes de commitar",
+                status: { modified: st.modified, notAdded: st.not_added }
+            });
+        }
+
+        const sha = await git.commit(effectivePath, args.message);
         return asToolResult({ success: true, sha, message: args.message }, { tool: 'workflow', action: 'commit' });
       }
       if (action === "clean") {
         if (args.dryRun) {
-          const result = await git.cleanUntracked(projectPath);
+          const result = await git.cleanUntracked(effectivePath);
           return asToolResult({
             success: true,
             dryRun: true,
@@ -267,7 +314,7 @@ EXEMPLOS DE USO:
           });
         }
 
-        const result = await git.cleanUntracked(projectPath);
+        const result = await git.cleanUntracked(effectivePath);
         return asToolResult({
           success: true,
           ...result,
@@ -277,7 +324,7 @@ EXEMPLOS DE USO:
         });
       }
       if (action === "ensure-remotes") {
-        const repo = getRepoNameFromPath(projectPath);
+        const repo = getRepoNameFromPath(effectivePath);
         const isPublic = args.isPublic === true; // Default: privado
         const organization = args.organization || undefined;
 
@@ -304,12 +351,12 @@ EXEMPLOS DE USO:
         const giteaBase = pm.giteaUrl?.replace(/\/$/, "");
         const giteaUrl = ensured.gitea?.ok && ensured.gitea.repo && giteaBase
           ? `${giteaBase}/${ensured.gitea.repo}.git` : "";
-        await git.ensureRemotes(projectPath, { githubUrl, giteaUrl, organization });
-        const remotes = await git.listRemotes(projectPath);
+        await git.ensureRemotes(effectivePath, { githubUrl, giteaUrl, organization });
+        const remotes = await git.listRemotes(effectivePath);
         return asToolResult({ success: true, ensured, remotes, isPrivate: !isPublic, organization: organization || undefined }, { tool: 'workflow', action: 'ensure-remotes' });
       }
       if (action === "push") {
-        const branch = await git.getCurrentBranch(projectPath);
+        const branch = await git.getCurrentBranch(effectivePath);
         const force = !!args.force;
 
         if (args.dryRun) {
@@ -329,7 +376,7 @@ EXEMPLOS DE USO:
 
         // Retry logic for push (often fails due to network or concurrent updates)
         const result = await withRetry(
-          () => git.pushParallel(projectPath, branch, force, organization),
+          () => git.pushParallel(effectivePath, branch, force, organization),
           3,
           "push"
         );
@@ -344,15 +391,15 @@ EXEMPLOS DE USO:
         }
         
         const channel = args.channel || "production";
-        const wtPath = path.join(projectPath, branch);
+        const wtPath = path.join(projectPath, branch); // Cria relativo ao path original solicitado
 
         if (fs.existsSync(wtPath)) {
             return asToolError("WORKTREE_PATH_EXISTS", `Diretório '${wtPath}' já existe.`, { suggestion: "Use git-worktree add se quiser configurar path customizado" });
         }
 
         try {
-            await git.addWorktree(projectPath, branch, wtPath);
-            await git.setWorktreeConfig(projectPath, branch, { path: wtPath, channel });
+            await git.addWorktree(effectivePath, branch, wtPath);
+            await git.setWorktreeConfig(effectivePath, branch, { path: wtPath, channel });
             
             return asToolResult({
                 success: true,
@@ -384,13 +431,13 @@ EXEMPLOS DE USO:
           if (args.dryRun) {
             gitignored = gitignorePatterns;
           } else {
-            await git.addToGitignore(projectPath, gitignorePatterns);
+            await git.addToGitignore(effectivePath, gitignorePatterns);
             gitignored = gitignorePatterns;
           }
         }
 
         // 1. Status para ver o que mudou
-        const status = await git.status(projectPath);
+        const status = await git.status(effectivePath);
 
         const hasChanges = !status.isClean ||
           (status.not_added?.length > 0) ||
@@ -432,15 +479,15 @@ EXEMPLOS DE USO:
         }
 
         // 2. Add
-        await git.add(projectPath, files);
+        await git.add(effectivePath, files);
 
         // 3. Commit  
-        const sha = await git.commit(projectPath, args.message);
+        const sha = await git.commit(effectivePath, args.message);
 
         // 3.5. Garantir remotes com organization (se fornecida)
         const organization = args.organization || undefined;
         if (organization) {
-          const repo = getRepoNameFromPath(projectPath);
+          const repo = getRepoNameFromPath(effectivePath);
           const isPublic = args.isPublic === true;
           const ensured = await pm.ensureRepos({ repoName: repo, createIfMissing: true, isPublic, organization });
           // Build URLs from actual ensureRepos results (handles GitHub fallback to personal account)
@@ -449,11 +496,11 @@ EXEMPLOS DE USO:
           const giteaBase = pm.giteaUrl?.replace(/\/$/, "");
           const giteaUrl = ensured.gitea?.ok && ensured.gitea.repo && giteaBase
             ? `${giteaBase}/${ensured.gitea.repo}.git` : "";
-          await git.ensureRemotes(projectPath, { githubUrl, giteaUrl, organization });
+          await git.ensureRemotes(effectivePath, { githubUrl, giteaUrl, organization });
         }
 
         // 4. Push Strategy
-        const branch = await git.getCurrentBranch(projectPath);
+        const branch = await git.getCurrentBranch(effectivePath);
         let pushResult = {};
         let synced = [];
         let errors = [];
@@ -461,7 +508,7 @@ EXEMPLOS DE USO:
         // Determine Channel
         let channel = args.channel;
         if (!channel) {
-             const storedChannel = await git.getConfig(projectPath, `worktree-branch.${branch}.channel`);
+             const storedChannel = await git.getConfig(effectivePath, `worktree-branch.${branch}.channel`);
              if (storedChannel) channel = storedChannel;
         }
         
@@ -471,13 +518,13 @@ EXEMPLOS DE USO:
         // SYNC BRANCHES
         if (syncBranches) {
             // Só permitido no principal (onde .git é diretório)
-            if (fs.existsSync(path.join(projectPath, ".git")) && fs.statSync(path.join(projectPath, ".git")).isFile()) {
+            if (fs.existsSync(path.join(effectivePath, ".git")) && fs.statSync(path.join(effectivePath, ".git")).isFile()) {
                 return asToolError("INVALID_OPERATION", "syncBranches=true só pode ser executado a partir do repositório principal, não de um worktree.");
             }
 
             // 1. Push do principal (current)
             const remoteBranch = resolveRemoteBranch(branch, channel);
-            const remotes = await git.listRemotes(projectPath);
+            const remotes = await git.listRemotes(effectivePath);
             
             await sendLog(server, "info", "update: push iniciado (sync)", { branch, remoteBranch, force });
 
@@ -485,7 +532,7 @@ EXEMPLOS DE USO:
             const mainFailed = [];
             for (const r of remotes) {
                 try {
-                    await git.pushRefspec(projectPath, r.remote, branch, remoteBranch, force);
+                    await git.pushRefspec(effectivePath, r.remote, branch, remoteBranch, force);
                     mainPushed.push(r.remote);
                 } catch(e) {
                     mainFailed.push({ remote: r.remote, error: e.message });
@@ -495,7 +542,7 @@ EXEMPLOS DE USO:
             // 2. Propagar para worktrees
             // Req 8.3: synced.length + errors.length === N (número de worktrees registrados)
             // O principal NÃO entra no contador — só os worktrees registrados
-            const configs = await git.getWorktreeConfigs(projectPath);
+            const configs = await git.getWorktreeConfigs(effectivePath);
             
             for (const wt of configs) {
                 // Pula se for a própria branch principal (caso esteja registrada)
@@ -532,13 +579,13 @@ EXEMPLOS DE USO:
                 // Comportamento padrão (production)
                 await sendLog(server, "info", "update: push iniciado", { branch, force });
                 pushResult = await withRetry(
-                  () => git.pushParallel(projectPath, branch, force, organization),
+                  () => git.pushParallel(effectivePath, branch, force, organization),
                   3,
                   "push"
                 );
             } else {
                 // Comportamento customizado (beta/alpha) -> pushRefspec
-                const remotes = await git.listRemotes(projectPath);
+                const remotes = await git.listRemotes(effectivePath);
                 
                 const pushed = [];
                 const failed = [];
@@ -547,7 +594,7 @@ EXEMPLOS DE USO:
 
                 for (const r of remotes) {
                     try {
-                        await git.pushRefspec(projectPath, r.remote, branch, remoteBranch, force);
+                        await git.pushRefspec(effectivePath, r.remote, branch, remoteBranch, force);
                         pushed.push(r.remote);
                     } catch (e) {
                         failed.push({ remote: r.remote, error: e.message });
@@ -562,7 +609,7 @@ EXEMPLOS DE USO:
             }
         }
 
-        return asToolResult({
+        const result = {
           success: true,
           action: "update",
           steps: ["status", "add", "commit", "push"],
@@ -577,7 +624,17 @@ EXEMPLOS DE USO:
             completed: true,
             message: "Ciclo completo: arquivos adicionados, commit criado e push realizado" + (organization ? ` [org: ${organization}]` : "")
           }
-        }, { tool: 'workflow', action: 'update' });
+        };
+
+        if (worktreeCtx?.isWorktree) {
+             result._worktreeContext = {
+                 detected: true,
+                 repoRoot: worktreeCtx.repoRoot,
+                 branch: worktreeCtx.branch
+             };
+        }
+
+        return asToolResult(result, { tool: 'workflow', action: 'update' });
       }
 
       return asToolError("VALIDATION_ERROR", `Ação '${action}' não suportada`, {

package/src/tools/git-worktree.js

@@ -3,6 +3,7 @@ import fs from "fs";
 import path from "path";
 import { asToolError, asToolResult, errorToResponse } from "../utils/errors.js";
 import { validateProjectPath, withRetry } from "../utils/repoHelpers.js";
+import { resolveWorktreeContext, isProtectedPath } from "../utils/worktreeResolver.js";
 
 const ajv = new Ajv({ allErrors: true });
 
@@ -75,62 +76,59 @@ AÇÕES:
     const validate = ajv.compile(inputSchema);
     if (!validate(args || {})) return asToolError("VALIDATION_ERROR", "Parâmetros inválidos", validate.errors);
     const { projectPath, action } = args;
+    let effectivePath = projectPath;
+    let worktreeCtx = null;
     
     try {
       validateProjectPath(projectPath);
       
+      worktreeCtx = await resolveWorktreeContext(projectPath, git);
+      effectivePath = worktreeCtx.worktreePath;
+
+      const _worktreeContext = worktreeCtx.isWorktree ? {
+          detected: true,
+          repoRoot: worktreeCtx.repoRoot,
+          branch: worktreeCtx.branch
+      } : undefined;
+      
       if (action === "list") {
-        const worktrees = await git.listWorktrees(projectPath);
+        const worktrees = await git.listWorktrees(effectivePath);
         
         // Enrich with channel info if available
         const enriched = [];
         for (const wt of worktrees) {
-            const channel = await git.getConfig(projectPath, `worktree-branch.${wt.branch}.channel`);
+            const channel = await git.getConfig(effectivePath, `worktree-branch.${wt.branch}.channel`);
             enriched.push({ ...wt, channel: channel || "production" }); // Default to production
         }
         
-        return asToolResult({ worktrees: enriched, count: enriched.length });
+        return asToolResult({ worktrees: enriched, count: enriched.length, _worktreeContext });
       }
       
       if (action === "add") {
         if (!args.branch) return asToolError("MISSING_PARAMETER", "branch é obrigatório para add", { parameter: "branch" });
         
-        // Default path: sibling directory with branch name
-        // Se projectPath é .../repo/main, e branch é 'feature', cria .../repo/feature
-        // Mas git worktree add path branch.
-        
-        // Se path não fornecido, assumir irmão do diretório atual se estivermos em um repo.
-        // Mas projectPath é a raiz do repo.
-        // Vamos usar path relativo ou absoluto fornecido, ou default: join(projectPath, "..", branch)
-        
-        const targetPath = args.path 
+        // Cria relativo ao projectPath original se path não for absoluto
+        const wtPath = args.path 
           ? path.resolve(projectPath, args.path)
-          : path.join(projectPath, args.branch); // Cria DENTRO do projeto? Não, worktrees geralmente ficam ao lado ou fora.
-          
-        // Melhor prática: criar dentro se for estrutura monorepo-style, ou fora.
-        // O git-mcp v16 parece usar estrutura plana ou aninhada.
-        // Vamos usar o comportamento padrão do git: path relativo à raiz.
-        // Se o usuário passar apenas o nome da branch como path, o git cria ./branch-name.
-        
-        // Se path não informado, usa o nome da branch (cria pasta ./branch-name dentro do repo atual)
-        // Isso pode sujar o repo principal se não estiver no gitignore.
-        // Vamos sugerir ou usar ../branch-name se estivermos na raiz?
-        // Simplicidade: user define path ou usa ./branch-name.
-        
-        const wtPath = args.path || args.branch; 
+          : path.join(projectPath, args.branch);
         
-        await withRetry(() => git.addWorktree(projectPath, args.branch, wtPath, args.force), 3, "worktree-add");
+        if (isProtectedPath(wtPath)) {
+            return asToolError("PROTECTED_PATH", `Não é permitido criar worktree em ${wtPath}`);
+        }
+
+        await withRetry(() => git.addWorktree(effectivePath, args.branch, wtPath, args.force), 3, "worktree-add");
         
         // Set channel if provided
         if (args.channel) {
-            await git.setWorktreeConfig(projectPath, args.branch, { channel: args.channel });
+            await git.setWorktreeConfig(effectivePath, args.branch, { channel: args.channel });
         }
         
         return asToolResult({ 
           success: true, 
           branch: args.branch, 
-          path: path.resolve(projectPath, wtPath),
-          channel: args.channel || "production"
+          path: wtPath,
+          channel: args.channel || "production",
+          _worktreeContext
         });
       }
       
@@ -141,27 +139,54 @@ AÇÕES:
         // Precisamos encontrar o path se só branch for fornecida
         let targetPath = args.path;
         if (!targetPath && args.branch) {
-            const wts = await git.listWorktrees(projectPath);
+            const wts = await git.listWorktrees(effectivePath);
             const found = wts.find(w => w.branch === args.branch);
             if (!found) return asToolError("WORKTREE_NOT_FOUND", `Worktree para branch '${args.branch}' não encontrado`);
             targetPath = found.path;
         }
         
-        await withRetry(() => git.removeWorktree(projectPath, targetPath, args.force), 3, "worktree-remove");
-        return asToolResult({ success: true, removed: targetPath });
+        await withRetry(() => git.removeWorktree(effectivePath, targetPath, args.force), 3, "worktree-remove");
+        return asToolResult({ success: true, removed: targetPath, _worktreeContext });
       }
       
       if (action === "prune") {
-        await git.pruneWorktrees(projectPath);
-        return asToolResult({ success: true, message: "Worktrees podados" });
+        await git.pruneWorktrees(effectivePath);
+        return asToolResult({ success: true, message: "Worktrees podados", _worktreeContext });
       }
 
       if (action === "set-channel") {
           if (!args.branch) return asToolError("MISSING_PARAMETER", "branch é obrigatório");
           if (!args.channel) return asToolError("MISSING_PARAMETER", "channel é obrigatório");
           
-          await git.setWorktreeConfig(projectPath, args.branch, { channel: args.channel });
-          return asToolResult({ success: true, branch: args.branch, channel: args.channel });
+          await git.setWorktreeConfig(effectivePath, args.branch, { channel: args.channel });
+          return asToolResult({ success: true, branch: args.branch, channel: args.channel, _worktreeContext });
+      }
+      
+      if (action === "setup") {
+          // Setup action logic - Estrutura recomendada
+          // 1. Verifica se está num repo
+          // 2. Se não estiver, init
+          // 3. Move master para subpasta 'main' se estiver na raiz?
+          // Simplificação: Apenas cria as pastas se não existirem
+          
+          const mainPath = path.join(effectivePath, 'main');
+          const worktreesPath = path.join(effectivePath, 'worktrees');
+          
+          if (!fs.existsSync(mainPath)) {
+              // Se estamos na raiz de um repo normal, setup é meio redundante se não formos mover arquivos.
+              // Mas se o usuário quer estruturar do zero:
+              // git init bare? Não, o spec não diz bare.
+              
+              // Vamos apenas retornar uma mensagem informativa por enquanto, pois a migração automática é arriscada.
+              return asToolResult({ 
+                  success: true, 
+                  message: "Para configurar worktrees, recomenda-se mover o branch principal para uma pasta 'main' e criar novos worktrees em pastas irmãs.",
+                  structure: {
+                      root: projectPath,
+                      recommended: ["main/", "feature-branch/", "hotfix/"]
+                  }
+              });
+          }
       }
       
       return asToolError("VALIDATION_ERROR", `Ação '${action}' não suportada`, { availableActions: ["add", "list", "remove", "prune", "set-channel"] });