@andre.buzeli/git-mcp 16.1.2 → 16.1.4

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

package/src/utils/worktreeResolver.js

@@ -0,0 +1,189 @@
+import path from 'node:path';
+import fs from 'node:fs';
+
+const PROTECTED_PATH_PREFIXES = [
+  'C:\\Users',
+  'C:/Users'
+];
+
+/**
+ * Verifica se um caminho é protegido e não deve receber git init/worktree.
+ * Normaliza separadores e compara case-insensitive.
+ * @param {string} p - Caminho absoluto a verificar
+ * @returns {boolean} - True se for protegido
+ */
+export function isProtectedPath(p) {
+  if (!p) return false;
+  
+  const normalized = p.replace(/\\/g, '/').toLowerCase();
+  
+  // Verifica se o caminho é temporário (permitido) APENAS em ambiente de teste
+  // Isso é importante para testes em ambientes onde o temp está dentro de Users
+  if (process.env.NODE_ENV === 'test') {
+      const tempDir = path.resolve(process.env.TEMP || process.env.TMP || '/tmp').replace(/\\/g, '/').toLowerCase();
+      if (normalized.startsWith(tempDir)) {
+          return false;
+      }
+  }
+  
+  for (const prefix of PROTECTED_PATH_PREFIXES) {
+    const normalizedPrefix = prefix.replace(/\\/g, '/').toLowerCase();
+    
+    // Verifica igualdade exata ou se é subdiretório
+    if (normalized === normalizedPrefix || normalized.startsWith(normalizedPrefix + '/')) {
+      return true;
+    }
+  }
+  
+  return false;
+}
+
+/**
+ * Busca ascendente por um diretório ou arquivo .git com limite de profundidade.
+ * @param {string} startPath - Caminho inicial absoluto
+ * @param {number} maxDepth - Número máximo de níveis para subir (default: 2)
+ * @returns {string|null} - Caminho do diretório contendo .git ou null se não encontrar
+ */
+export function findGitRoot(startPath, maxDepth = 2) {
+  let current = path.resolve(startPath);
+  let depth = 0;
+
+  // Verifica o próprio startPath primeiro (depth 0)
+  if (fs.existsSync(path.join(current, '.git'))) {
+    return current;
+  }
+
+  // Sobe na árvore até maxDepth níveis ACIMA do startPath
+  while (depth < maxDepth) {
+    const parent = path.dirname(current);
+    if (parent === current) {
+      return null; // Chegou na raiz do FS
+    }
+    
+    current = parent;
+    depth++;
+
+    if (fs.existsSync(path.join(current, '.git'))) {
+      return current;
+    }
+  }
+  
+  return null;
+}
+
+/**
+ * Resolve o contexto de worktree para um dado caminho de projeto.
+ * Detecta se é worktree, repo principal, ou se precisa de auto-init.
+ * @param {string} projectPath - Caminho do projeto fornecido pelo agente
+ * @param {GitAdapter} gitAdapter - Instância do GitAdapter para executar comandos
+ * @returns {Promise<Object>} - WorktreeContext resolvido
+ */
+export async function resolveWorktreeContext(projectPath, gitAdapter) {
+  const absolutePath = path.resolve(projectPath);
+  
+  // Tenta encontrar .git no path ou acima (max 2 níveis)
+  // Se encontrar .git no próprio projectPath (depth 0), usa ele.
+  // Se encontrar acima, usa o pai como base.
+  let root = findGitRoot(absolutePath, 2);
+  
+  if (!root) {
+    // Caso não encontre .git em até 2 níveis: Auto-init
+    if (isProtectedPath(absolutePath)) {
+      throw new Error(`PROTECTED_PATH: não é permitido criar repositório git em ${absolutePath}`);
+    }
+    
+    // Executa git init
+    await gitAdapter._exec(absolutePath, ['init']);
+    
+    // Após init, obtém a branch (provavelmente master/main)
+    const branch = await getBranchName(absolutePath, gitAdapter);
+    
+    return {
+      repoRoot: absolutePath,
+      worktreePath: absolutePath,
+      branch: branch,
+      isWorktree: false,
+      gitCommonDir: path.join(absolutePath, '.git'),
+      autoInitialized: true
+    };
+  }
+  
+  // Se encontrou raiz (pode ser o próprio projectPath ou um pai)
+  const gitEntry = path.join(root, '.git');
+  const stats = fs.statSync(gitEntry);
+  
+  if (stats.isDirectory()) {
+    const branch = await getBranchName(root, gitAdapter);
+
+    // Req 9.2: valida que gitCommonDir contém objects/
+    if (!fs.existsSync(path.join(gitEntry, 'objects'))) {
+      throw new Error(`WORKTREE_CORRUPT: Diretório objects não encontrado em ${gitEntry}`);
+    }
+
+    return {
+      repoRoot: root,
+      worktreePath: root,
+      branch: branch,
+      isWorktree: false,
+      gitCommonDir: gitEntry
+    };
+  } else if (stats.isFile()) {
+    // Worktree
+    const content = fs.readFileSync(gitEntry, 'utf8');
+    const match = content.match(/^gitdir:\s*(.+)$/m);
+    
+    if (!match) {
+      throw new Error('WORKTREE_CORRUPT: Arquivo .git inválido ou sem formato gitdir');
+    }
+    
+    const gitdirRelative = match[1].trim();
+    const gitdirAbsolute = path.resolve(root, gitdirRelative);
+    
+    if (!fs.existsSync(gitdirAbsolute)) {
+      throw new Error(`WORKTREE_STALE: gitdir ${gitdirAbsolute} não encontrado. Execute 'git worktree prune' no repo principal.`);
+    }
+    
+    // Tenta achar commondir
+    const commondirFile = path.join(gitdirAbsolute, 'commondir');
+    let gitCommonDir;
+    
+    if (fs.existsSync(commondirFile)) {
+      const commondirRelative = fs.readFileSync(commondirFile, 'utf8').trim();
+      gitCommonDir = path.resolve(gitdirAbsolute, commondirRelative);
+    } else {
+      gitCommonDir = gitdirAbsolute;
+    }
+    
+    // Valida objects
+    if (!fs.existsSync(path.join(gitCommonDir, 'objects'))) {
+      throw new Error(`WORKTREE_CORRUPT: Diretório objects não encontrado em ${gitCommonDir}`);
+    }
+    
+    const repoRoot = path.dirname(gitCommonDir);
+    const branch = await getBranchName(root, gitAdapter);
+    
+    return {
+      repoRoot: repoRoot,
+      worktreePath: root,
+      branch: branch,
+      isWorktree: true,
+      gitCommonDir: gitCommonDir
+    };
+  }
+  
+  throw new Error('NOT_A_GIT_REPO: .git entry is neither file nor directory');
+}
+
+/**
+ * Helper para obter o nome da branch atual
+ */
+async function getBranchName(cwd, gitAdapter) {
+  try {
+    const result = await gitAdapter._exec(cwd, ['rev-parse', '--abbrev-ref', 'HEAD']);
+    return result.trim();
+  } catch (error) {
+    // Em repo recém inicializado sem commits, pode falhar ou retornar HEAD.
+    // Mas git init cria branch default.
+    return 'HEAD'; 
+  }
+}