@andre.buzeli/git-mcp 16.1.3 → 16.1.6

package/src/tools/git-worktree.js

@@ -1,8 +1,9 @@
 import Ajv from "ajv";
 import fs from "fs";
 import path from "path";
-import { asToolError, asToolResult, errorToResponse } from "../utils/errors.js";
+import { asToolError, asToolResult, errorToResponse, handleEmptyCall } from "../utils/errors.js";
 import { validateProjectPath, withRetry } from "../utils/repoHelpers.js";
+import { resolveWorktreeContext, isProtectedPath } from "../utils/worktreeResolver.js";
 
 const ajv = new Ajv({ allErrors: true });
 
@@ -72,65 +73,65 @@ AÇÕES:
 - set-channel: Configurar canal de deploy (prod/beta/alpha)`;
 
   async function handle(args) {
+    const emptyHelp = handleEmptyCall(args, inputSchema, "git-worktree", { projectPath: "/path/to/project", action: "list" });
+    if (emptyHelp) return emptyHelp;
+
     const validate = ajv.compile(inputSchema);
-    if (!validate(args || {})) return asToolError("VALIDATION_ERROR", "Parâmetros inválidos", validate.errors);
+    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.
+          : path.join(projectPath, args.branch);
         
-        const wtPath = args.path || 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 +142,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"] });

package/src/utils/errors.js

@@ -432,3 +432,24 @@ export function errorToResponse(error) {
   const mapped = mapExternalError(error);
   return asToolError(mapped.code, mapped.message, mapped.data);
 }
+
+/**
+ * Detecta call vazia (sem projectPath/action) e retorna help em vez de erro seco.
+ * Isso evita que modelos façam "tool probing" — uma call vazia para descobrir o schema.
+ * @param {object} args - Argumentos recebidos
+ * @param {object} inputSchema - Schema da tool
+ * @param {string} toolName - Nome da tool
+ * @param {object} example - Exemplo de uso mínimo
+ * @returns {object|null} - Resposta de help, ou null se args não estão vazios
+ */
+export function handleEmptyCall(args, inputSchema, toolName, example) {
+  if (args && Object.keys(args).length > 0) return null;
+  return asToolResult({
+    help: true,
+    tool: toolName,
+    requiredParams: (inputSchema.required || []).join(", "),
+    example,
+    actions: inputSchema.properties?.action?.enum || [],
+    hint: `Sempre inclua ${(inputSchema.required || []).join(" e ")} na chamada.`
+  });
+}

package/src/utils/gitAdapter.js

@@ -315,10 +315,28 @@ export class GitAdapter {
                 suggestion: "Use git-workflow init para criar um repositório"
             });
         }
+        // Worktrees têm .git como arquivo, repos normais como diretório.
+        // Ambos são válidos e fs.existsSync retorna true para ambos.
     }
 
     /**
-     * Verifica se o diretório é um repositório git
+     * Verifica se o diretório é um worktree (possui arquivo .git)
+     * @param {string} dir - Diretório para verificar
+     * @returns {boolean} - true se é um worktree
+     */
+    async isWorktree(dir) {
+        const gitPath = path.join(dir, ".git");
+        if (!fs.existsSync(gitPath)) return false;
+        try {
+            const stats = fs.statSync(gitPath);
+            return stats.isFile();
+        } catch {
+            return false;
+        }
+    }
+
+    /**
+     * Verifica se o diretório é um repositório git (repo principal ou worktree)
      * @param {string} dir - Diretório para verificar
      * @returns {boolean} - true se é um repo git
      */
@@ -842,8 +860,12 @@ export class GitAdapter {
         try { await this._exec(dir, args); } catch { }
     }
 
-    async listConfig(dir) {
-        const out = await this._exec(dir, ["config", "--list"]);
+    async listConfig(dir, scope) {
+        const args = ["config", "--list"];
+        if (scope === "global") args.push("--global");
+        else if (scope === "system") args.push("--system");
+        else if (scope === "local") args.push("--local");
+        const out = await this._exec(dir, args);
         const items = {};
         out.split("\n").filter(Boolean).forEach(line => {
             const [k, ...v] = line.split("=");
@@ -959,16 +981,26 @@ export class GitAdapter {
     }
 
     // ============ DIFF/CLONE ============
-    async diff(dir, options = {}) { return await this._exec(dir, ["diff"]); }
+    async diff(dir, options = {}) {
+        const args = ["diff"];
+        if (options.staged) {
+            args.push("--cached");
+        } else if (options.target) {
+            if (options.source) args.push(options.source);
+            args.push(options.target);
+        }
+        return await this._exec(dir, args);
+    }
     async diffCommits(dir, from, to) { return await this._exec(dir, ["diff", from, to]); }
 
-    async clone(url, dir, options = {}) {
-        const { branch, depth, singleBranch } = options;
+    async clone(dir, url, options = {}) {
+        const { name, branch, depth, singleBranch } = options;
         const args = ["clone"];
         if (branch) args.push("-b", branch);
         if (depth) args.push("--depth", depth.toString());
         if (singleBranch) args.push("--single-branch");
-        args.push(url, ".");
+        args.push(url);
+        if (name) args.push(name);
 
         const header = this._getAuthHeader(url);
         const cmdArgs = [];
@@ -998,9 +1030,10 @@ export class GitAdapter {
     async removeFromGitignore(dir, patterns) {
         const p = path.join(dir, ".gitignore");
         if (!fs.existsSync(p)) return;
-        let c = fs.readFileSync(p, "utf8");
-        patterns.forEach(pat => c = c.replace(pat, ""));
-        fs.writeFileSync(p, c);
+        const lines = fs.readFileSync(p, "utf8").split("\n");
+        const patternSet = new Set(patterns);
+        const filtered = lines.filter(line => !patternSet.has(line.trim()));
+        fs.writeFileSync(p, filtered.join("\n"));
     }
 
     async listRemotesRaw(dir) {
@@ -1029,121 +1062,128 @@ export class GitAdapter {
         return Array.from(map.values());
     }
 
-    // ============ WORKTREE ============
-
-    async addWorktree(dir, branch, worktreePath) {
-        // Verifica se branch já existe
-        const branches = await this.listBranches(dir);
-        const branchExists = branches.includes(branch);
-
-        const args = ["worktree", "add"];
-        // Se branch não existe, cria com -b. Se existe, usa checkout normal (sem flag)
-        if (!branchExists) {
-            args.push("-b", branch);
-        }
-        args.push(worktreePath, branch);
-
-        await this._exec(dir, args);
-    }
-
-    async listWorktrees(dir) {
-        try {
-            const out = await this._exec(dir, ["worktree", "list", "--porcelain"]);
-            const worktrees = [];
-            let current = {};
-
-            const lines = out.split("\n");
-            for (const line of lines) {
-                if (!line.trim()) {
-                    if (current.worktree) {
-                        worktrees.push(current);
-                        current = {};
-                    }
-                    continue;
-                }
-
-                const [key, ...rest] = line.split(" ");
-                const value = rest.join(" ");
-
-                if (key === "worktree") {
-                    if (current.worktree) worktrees.push(current);
-                    current = { worktree: value };
-                } else if (key === "branch") {
-                    current.branch = value.replace("refs/heads/", "");
-                } else if (key === "HEAD") {
-                    current.head = value;
-                }
-            }
-            if (current.worktree) worktrees.push(current);
-
-            return worktrees.map(w => ({
-                path: w.worktree,
-                branch: w.branch,
-                head: w.head
-            }));
-        } catch (e) {
-            // Fallback para versão antiga do git se --porcelain falhar
-            const out = await this._exec(dir, ["worktree", "list"]);
-            return out.split("\n").filter(Boolean).map(line => {
-                const parts = line.split(/\s+/);
-                const path = parts.slice(0, -2).join(" "); // Path pode ter espaços
-                const head = parts[parts.length - 2];
-                const branchRaw = parts[parts.length - 1];
-                const branch = branchRaw.replace("[", "").replace("]", "");
-                return { path, head, branch };
-            });
-        }
-    }
-
-    async removeWorktree(dir, worktreePath) {
-        await this._exec(dir, ["worktree", "remove", worktreePath, "--force"]);
-    }
-
-    async pushRefspec(dir, remote, localBranch, remoteBranch, force = false) {
-        const remoteUrl = await this._exec(dir, ["remote", "get-url", remote]);
-        const header = this._getAuthHeader(remoteUrl);
-        const args = [];
-        if (header) args.push("-c", `http.extraHeader=${header}`);
-        args.push("push");
-        if (force) args.push("--force");
-        args.push(remote, `${localBranch}:${remoteBranch}`);
-        await this._exec(dir, args);
-    }
-
-    async getWorktreeConfigs(dir) {
-        try {
-            const configPath = path.join(dir, ".git", "config");
-            if (!fs.existsSync(configPath)) return [];
-
-            const content = fs.readFileSync(configPath, "utf8");
-            const results = [];
-            const sectionRegex = /\[worktree-branch "([^"]+)"\]([\s\S]*?)(?=\[|$)/g;
-
-            let match;
-            while ((match = sectionRegex.exec(content)) !== null) {
-                const branchName = match[1];
-                const body = match[2];
-                const wtPath = body.match(/path\s*=\s*(.+)/)?.[1]?.trim();
-                const channel = body.match(/channel\s*=\s*(.+)/)?.[1]?.trim() || "production";
-                if (branchName && wtPath) {
-                    results.push({ branch: branchName, path: wtPath, channel });
-                }
-            }
-            return results;
-        } catch (e) {
-            console.error("[GitAdapter] Error reading worktree configs:", e);
-            return [];
-        }
-    }
-
-    async setWorktreeConfig(dir, branchName, config) {
-        // Normalizar path para usar forward slashes (compatível com git config em windows)
-        const normalizedPath = config.path.replace(/\\/g, "/");
-        
-        await this._exec(dir, ["config", `worktree-branch.${branchName}.path`, normalizedPath]);
-        await this._exec(dir, ["config", `worktree-branch.${branchName}.channel`, config.channel || "production"]);
-    }
-
+    // ============ WORKTREE ============
+
+    async addWorktree(dir, branch, worktreePath, force = false) {
+        const branches = await this.listBranches(dir);
+        const branchExists = branches.includes(branch);
+
+        const args = ["worktree", "add"];
+        if (force) args.push("--force");
+
+        if (branchExists) {
+            // Branch já existe: checkout dela no novo worktree
+            args.push(worktreePath, branch);
+        } else {
+            // Branch nova: cria a partir do HEAD atual
+            args.push("-b", branch, worktreePath);
+        }
+
+        await this._exec(dir, args);
+    }
+
+    async listWorktrees(dir) {
+        try {
+            const out = await this._exec(dir, ["worktree", "list", "--porcelain"]);
+            const worktrees = [];
+            let current = {};
+
+            const lines = out.split("\n");
+            for (const line of lines) {
+                if (!line.trim()) {
+                    if (current.worktree) {
+                        worktrees.push(current);
+                        current = {};
+                    }
+                    continue;
+                }
+
+                const [key, ...rest] = line.split(" ");
+                const value = rest.join(" ");
+
+                if (key === "worktree") {
+                    if (current.worktree) worktrees.push(current);
+                    current = { worktree: value };
+                } else if (key === "branch") {
+                    current.branch = value.replace("refs/heads/", "");
+                } else if (key === "HEAD") {
+                    current.head = value;
+                }
+            }
+            if (current.worktree) worktrees.push(current);
+
+            return worktrees.map(w => ({
+                path: w.worktree,
+                branch: w.branch,
+                head: w.head
+            }));
+        } catch (e) {
+            // Fallback para versão antiga do git se --porcelain falhar
+            const out = await this._exec(dir, ["worktree", "list"]);
+            return out.split("\n").filter(Boolean).map(line => {
+                const parts = line.split(/\s+/);
+                const path = parts.slice(0, -2).join(" "); // Path pode ter espaços
+                const head = parts[parts.length - 2];
+                const branchRaw = parts[parts.length - 1];
+                const branch = branchRaw.replace("[", "").replace("]", "");
+                return { path, head, branch };
+            });
+        }
+    }
+
+    async removeWorktree(dir, worktreePath) {
+        await this._exec(dir, ["worktree", "remove", worktreePath, "--force"]);
+    }
+
+    async pruneWorktrees(dir) {
+        await this._exec(dir, ["worktree", "prune"]);
+    }
+
+    async pushRefspec(dir, remote, localBranch, remoteBranch, force = false) {
+        const remoteUrl = await this._exec(dir, ["remote", "get-url", remote]);
+        const header = this._getAuthHeader(remoteUrl);
+        const args = [];
+        if (header) args.push("-c", `http.extraHeader=${header}`);
+        args.push("push");
+        if (force) args.push("--force");
+        args.push(remote, `${localBranch}:${remoteBranch}`);
+        await this._exec(dir, args);
+    }
+
+    async getWorktreeConfigs(dir) {
+        try {
+            const configPath = path.join(dir, ".git", "config");
+            if (!fs.existsSync(configPath)) return [];
+
+            const content = fs.readFileSync(configPath, "utf8");
+            const results = [];
+            const sectionRegex = /\[worktree-branch "([^"]+)"\]([\s\S]*?)(?=\[|$)/g;
+
+            let match;
+            while ((match = sectionRegex.exec(content)) !== null) {
+                const branchName = match[1];
+                const body = match[2];
+                const wtPath = body.match(/path\s*=\s*(.+)/)?.[1]?.trim();
+                const channel = body.match(/channel\s*=\s*(.+)/)?.[1]?.trim() || "production";
+                if (branchName && wtPath) {
+                    results.push({ branch: branchName, path: wtPath, channel });
+                }
+            }
+            return results;
+        } catch (e) {
+            console.error("[GitAdapter] Error reading worktree configs:", e);
+            return [];
+        }
+    }
+
+    async setWorktreeConfig(dir, branchName, config) {
+        if (config.path !== undefined) {
+            const normalizedPath = config.path.replace(/\\/g, "/");
+            await this._exec(dir, ["config", `worktree-branch.${branchName}.path`, normalizedPath]);
+        }
+        await this._exec(dir, ["config", `worktree-branch.${branchName}.channel`, config.channel || "production"]);
+    }
+
     // ============ GIT LFS SUPPORT ============
 
     /**

package/src/utils/retry.js

@@ -19,7 +19,7 @@ const DEFAULT_OPTIONS = {
 
 function shouldRetry(error, options) {
   const msg = (error?.message || String(error)).toLowerCase();
-  const code = error?.code?.toLowerCase() || "";
+  const code = String(error?.code ?? "").toLowerCase();
   
   return options.retryableErrors.some(e => 
     msg.includes(e.toLowerCase()) || code.includes(e.toLowerCase())