@andre.buzeli/git-mcp 16.0.8 → 16.1.3

package/src/tools/git-worktree.js

@@ -0,0 +1,180 @@
+import Ajv from "ajv";
+import fs from "fs";
+import path from "path";
+import { asToolError, asToolResult, errorToResponse } from "../utils/errors.js";
+import { validateProjectPath, withRetry } from "../utils/repoHelpers.js";
+
+const ajv = new Ajv({ allErrors: true });
+
+export function createGitWorktreeTool(git) {
+  const inputSchema = {
+    type: "object",
+    properties: {
+      projectPath: { 
+        type: "string",
+        description: "Caminho absoluto do diretório do projeto no IDE (ex: '/home/user/meu-projeto' ou 'C:/Users/user/meu-projeto'). IMPORTANTE: este valor não pode ser inferido automaticamente pelo servidor — o agente deve fornecer o path real do projeto sendo trabalhado, não o diretório home do usuário."
+      },
+      action: { 
+        type: "string", 
+        enum: ["add", "list", "remove", "prune", "setup", "set-channel"],
+        description: `Ação a executar:
+- add: Cria novo worktree (branch em diretório separado)
+- list: Lista worktrees existentes
+- remove: Remove um worktree
+- prune: Limpa informações de worktrees deletados manualmente
+- setup: Configura estrutura de pastas recomendada (main, mac, win)
+- set-channel: Define o canal de deploy (production/beta/alpha) para uma branch`
+      },
+      branch: { 
+        type: "string",
+        description: "Nome da branch para o worktree. Ex: 'mac', 'win', 'feature-x'"
+      },
+      path: { 
+        type: "string",
+        description: "Caminho onde criar o worktree (opcional para action='add', default: ../branch-name)"
+      },
+      force: { 
+        type: "boolean",
+        description: "Forçar operação. Default: false"
+      },
+      channel: {
+        type: "string",
+        enum: ["production", "beta", "alpha"],
+        description: "Canal de deploy (para action='set-channel' ou 'add')"
+      }
+    },
+    required: ["projectPath", "action"],
+    additionalProperties: false
+  };
+
+  const description = `IMPORTANTE — projectPath:
+Informe o caminho absoluto do projeto aberto no IDE. O servidor MCP não tem acesso ao
+contexto do IDE e não consegue detectar automaticamente qual projeto está sendo trabalhado.
+
+Gerenciamento de Git Worktrees (Múltiplos diretórios de trabalho).
+
+QUANDO USAR:
+- Trabalhar em múltiplas branches simultaneamente
+- Testar em diferentes ambientes (ex: Windows vs Mac)
+- Separar builds de produção e desenvolvimento
+
+ESTRUTURA RECOMENDADA:
+/projeto-root/
+  /main (repo principal)
+  /feature-x (worktree)
+  /hotfix (worktree)
+
+AÇÕES:
+- add: Criar novo worktree
+- list: Ver worktrees ativos
+- remove: Deletar worktree
+- setup: Criar estrutura padrão (opcional)
+- set-channel: Configurar canal de deploy (prod/beta/alpha)`;
+
+  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 {
+      validateProjectPath(projectPath);
+      
+      if (action === "list") {
+        const worktrees = await git.listWorktrees(projectPath);
+        
+        // Enrich with channel info if available
+        const enriched = [];
+        for (const wt of worktrees) {
+            const channel = await git.getConfig(projectPath, `worktree-branch.${wt.branch}.channel`);
+            enriched.push({ ...wt, channel: channel || "production" }); // Default to production
+        }
+        
+        return asToolResult({ worktrees: enriched, count: enriched.length });
+      }
+      
+      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 
+          ? 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; 
+        
+        await withRetry(() => git.addWorktree(projectPath, args.branch, wtPath, args.force), 3, "worktree-add");
+        
+        // Set channel if provided
+        if (args.channel) {
+            await git.setWorktreeConfig(projectPath, args.branch, { channel: args.channel });
+        }
+        
+        return asToolResult({ 
+          success: true, 
+          branch: args.branch, 
+          path: path.resolve(projectPath, wtPath),
+          channel: args.channel || "production"
+        });
+      }
+      
+      if (action === "remove") {
+        if (!args.branch && !args.path) return asToolError("MISSING_PARAMETER", "branch ou path é obrigatório para remove");
+        
+        // Git remove worktree by path
+        // Precisamos encontrar o path se só branch for fornecida
+        let targetPath = args.path;
+        if (!targetPath && args.branch) {
+            const wts = await git.listWorktrees(projectPath);
+            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 });
+      }
+      
+      if (action === "prune") {
+        await git.pruneWorktrees(projectPath);
+        return asToolResult({ success: true, message: "Worktrees podados" });
+      }
+
+      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 });
+      }
+      
+      return asToolError("VALIDATION_ERROR", `Ação '${action}' não suportada`, { availableActions: ["add", "list", "remove", "prune", "set-channel"] });
+    } catch (e) {
+      return errorToResponse(e);
+    }
+  }
+
+  return { 
+    name: "git-worktree", 
+    description, 
+    inputSchema, 
+    handle,
+    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false }
+  };
+}