@andre.buzeli/git-mcp 15.12.5

package/src/tools/git-merge.js

@@ -0,0 +1,152 @@
+import Ajv from "ajv";
+import { asToolError, asToolResult, errorToResponse, createError } from "../utils/errors.js";
+import { validateProjectPath } from "../utils/repoHelpers.js";
+
+const ajv = new Ajv({ allErrors: true });
+
+export function createGitMergeTool(git) {
+  const inputSchema = {
+    type: "object",
+    properties: {
+      projectPath: { 
+        type: "string",
+        description: "Caminho absoluto do diretório do projeto"
+      },
+      action: { 
+        type: "string", 
+        enum: ["merge", "abort", "status"],
+        description: `Ação a executar:
+- merge: Faz merge de uma branch na branch atual
+- abort: Aborta um merge em andamento (se houver conflitos)
+- status: Verifica se há merge em andamento`
+      },
+      branch: { 
+        type: "string",
+        description: "Branch para fazer merge na branch atual. Ex: 'feature/nova-funcionalidade'"
+      },
+      message: { 
+        type: "string",
+        description: "Mensagem do commit de merge. Se não fornecida, usa mensagem padrão"
+      },
+      noCommit: { 
+        type: "boolean",
+        description: "Se true, faz merge mas não cria commit automaticamente. Default: false"
+      },
+      squash: {
+        type: "boolean",
+        description: "Se true, squash all commits into one. Default: false"
+      }
+    },
+    required: ["projectPath", "action"],
+    additionalProperties: false
+  };
+
+  const description = `Merge de branches Git.
+
+QUANDO USAR:
+- Integrar mudanças de uma feature branch na main
+- Combinar trabalho de diferentes branches
+- Finalizar uma feature/bugfix
+
+FLUXO TÍPICO:
+1. git-branches checkout branch='main' → ir para branch destino
+2. git-merge merge branch='feature/x' → fazer merge
+3. git-workflow push → enviar resultado
+
+CONFLITOS:
+- Se houver conflitos, o merge será interrompido
+- Resolva os conflitos manualmente
+- Use git-workflow add e commit para finalizar
+- Ou use git-merge abort para cancelar
+
+SQUASH:
+- Use squash=true para combinar todos os commits em um só
+- Útil para manter histórico limpo`;
+
+  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 === "status") {
+        const mergeStatus = await git.getMergeStatus(projectPath);
+        return asToolResult(mergeStatus);
+      }
+      
+      if (action === "abort") {
+        await git.abortMerge(projectPath);
+        return asToolResult({ 
+          success: true, 
+          message: "Merge abortado com sucesso" 
+        });
+      }
+      
+      if (action === "merge") {
+        if (!args.branch) {
+          return asToolError("MISSING_PARAMETER", "branch é obrigatório para merge", { 
+            parameter: "branch",
+            example: "feature/nova-funcionalidade"
+          });
+        }
+        
+        // Pre-merge check: working tree status
+        const status = await git.status(projectPath);
+        if (!status.isClean) {
+          // We could warn or fail. Standard git refuses merge if changes would be overwritten.
+          // Let's just warn in logs or return error if critical?
+          // Git will fail anyway if conflicts with local changes.
+          // Let's inform the user.
+          console.warn("[GitMerge] Working tree not clean. Merge might fail.");
+        }
+
+        const currentBranch = await git.getCurrentBranch(projectPath);
+        if (currentBranch === args.branch) {
+          return asToolError("VALIDATION_ERROR", "Não pode fazer merge de uma branch nela mesma", {
+            branch: args.branch,
+            suggestion: "Faça checkout para a branch destino primeiro"
+          });
+        }
+        
+        try {
+          const result = await git.merge(projectPath, args.branch, {
+            message: args.message,
+            noCommit: args.noCommit,
+            squash: args.squash
+          });
+          
+          return asToolResult({
+            success: true,
+            from: args.branch,
+            into: currentBranch,
+            ...result,
+            message: result.conflicts?.length > 0 
+              ? `Merge com conflitos. Resolva os conflitos e faça commit.`
+              : `Merge de '${args.branch}' em '${currentBranch}' concluído`
+          });
+        } catch (e) {
+          const msg = e.message || "";
+          if (msg.includes("conflict") || msg.includes("CONFLICT")) {
+             return asToolResult({
+               success: false,
+               conflict: true,
+               message: "Merge resultou em conflitos. Resolva manualmente e faça commit.",
+               files: [], // If we could parse files from error, great. 
+               nextStep: "Edite os arquivos conflitantes, use git add e git commit."
+             });
+          }
+          throw e;
+        }
+      }
+      
+      return asToolError("VALIDATION_ERROR", `Ação '${action}' não suportada`, { 
+        availableActions: ["merge", "abort", "status"] 
+      });
+    } catch (e) {
+      return errorToResponse(e);
+    }
+  }
+
+  return { name: "git-merge", description, inputSchema, handle };
+}

package/src/tools/git-pulls.js

@@ -0,0 +1,115 @@
+import Ajv from "ajv";
+import axios from "axios";
+import { asToolError, asToolResult, errorToResponse } from "../utils/errors.js";
+import { getRepoNameFromPath, validateProjectPath } from "../utils/repoHelpers.js";
+import { runBoth } from "../utils/providerExec.js";
+
+const ajv = new Ajv({ allErrors: true });
+
+export function createGitPullsTool(pm) {
+  const inputSchema = {
+    type: "object",
+    properties: {
+      projectPath: {
+        type: "string",
+        description: "Caminho absoluto do diretório do projeto"
+      },
+      action: {
+        type: "string",
+        enum: ["create", "list", "files"],
+        description: `Ação a executar:
+- create: Cria Pull Request no GitHub E Gitea
+- list: Lista Pull Requests existentes
+- files: Lista arquivos modificados em um PR`
+      },
+      title: {
+        type: "string",
+        description: "Título do PR. Ex: 'feat: adiciona autenticação OAuth'"
+      },
+      head: {
+        type: "string",
+        description: "Branch de origem (com as mudanças). Ex: 'feature/oauth'"
+      },
+      base: {
+        type: "string",
+        description: "Branch de destino (onde será mergeado). Ex: 'main', 'develop'"
+      },
+      number: {
+        type: "number",
+        description: "Número do PR para action='files'"
+      },
+      body: {
+        type: "string",
+        description: "Descrição do PR com detalhes das mudanças"
+      },
+      organization: {
+        type: "string",
+        description: "Opcional. Nome da organização no GitHub/Gitea. Se informado, operações são feitas na org em vez da conta pessoal."
+      }
+    },
+    required: ["projectPath", "action"],
+    additionalProperties: false
+  };
+
+  const description = `Gerenciamento de Pull Requests no GitHub e Gitea.
+
+QUANDO USAR:
+- Propor mudanças de uma branch para outra
+- Code review antes de merge
+- Documentar mudanças significativas
+
+FLUXO TÍPICO:
+1. Cria branch: git-branches create branch='feature/nova'
+2. Faz mudanças e commits
+3. Push: git-workflow push
+4. Cria PR: git-pulls create head='feature/nova' base='main' title='Nova feature'
+
+AÇÕES:
+- create: Criar novo PR
+- list: Ver PRs existentes
+- files: Ver arquivos modificados em um PR
+
+NOTA: O PR é criado em AMBOS os providers simultaneamente.`;
+
+  async function handle(args) {
+    const validate = ajv.compile(inputSchema);
+    if (!validate(args || {})) return asToolError("VALIDATION_ERROR", "Parâmetros inválidos", validate.errors);
+    validateProjectPath(args.projectPath);
+    const repo = getRepoNameFromPath(args.projectPath);
+    try {
+      if (args.action === "create") {
+        if (!args.head) return asToolError("MISSING_PARAMETER", "head (branch de origem) é obrigatório", { parameter: "head", example: "feature/nova-funcionalidade" });
+        if (!args.base) return asToolError("MISSING_PARAMETER", "base (branch de destino) é obrigatório", { parameter: "base", example: "main" });
+        const head = args.head;
+        const base = args.base;
+        const title = args.title || `${head} -> ${base}`;
+        const body = args.body || "";
+        const out = await withRetry(() => runBoth(pm, {
+          github: async (owner) => { const r = await pm.github.rest.pulls.create({ owner, repo, title, head, base, body }); return { ok: true, number: r.data.number, url: r.data.html_url }; },
+          gitea: async (owner) => { const baseUrl = pm.giteaUrl.replace(/\/$/, ""); const r = await axios.post(`${baseUrl}/api/v1/repos/${owner}/${repo}/pulls`, { title, head, base, body }, { headers: { Authorization: `token ${pm.giteaToken}` } }); return { ok: true, number: r.data?.number }; }
+        }, { organization: args.organization }), 3, "pulls-create");
+        return asToolResult({ success: !!(out.github?.ok || out.gitea?.ok), title, head, base, providers: out });
+      }
+      if (args.action === "list") {
+        const out = await withRetry(() => runBoth(pm, {
+          github: async (owner) => { const r = await pm.github.rest.pulls.list({ owner, repo, state: "all", per_page: 30 }); return { ok: true, count: r.data.length, pulls: r.data.slice(0, 10).map(p => ({ number: p.number, title: p.title, state: p.state, head: p.head.ref, base: p.base.ref })) }; },
+          gitea: async (owner) => { const baseUrl = pm.giteaUrl.replace(/\/$/, ""); const r = await axios.get(`${baseUrl}/api/v1/repos/${owner}/${repo}/pulls?state=all`, { headers: { Authorization: `token ${pm.giteaToken}` } }); return { ok: true, count: (r.data || []).length, pulls: (r.data || []).slice(0, 10).map(p => ({ number: p.number, title: p.title, state: p.state, head: p.head?.ref, base: p.base?.ref })) }; }
+        }, { organization: args.organization }), 3, "pulls-list");
+        return asToolResult({ providers: out });
+      }
+      if (args.action === "files") {
+        if (!args.number) return asToolError("MISSING_PARAMETER", "number é obrigatório para ver arquivos do PR", { parameter: "number" });
+        const out = await withRetry(() => runBoth(pm, {
+          github: async (owner) => { const r = await pm.github.rest.pulls.listFiles({ owner, repo, pull_number: args.number }); return { ok: true, count: r.data.length, files: r.data.map(f => ({ filename: f.filename, status: f.status, additions: f.additions, deletions: f.deletions })) }; },
+          gitea: async (owner) => { const baseUrl = pm.giteaUrl.replace(/\/$/, ""); const r = await axios.get(`${baseUrl}/api/v1/repos/${owner}/${repo}/pulls/${args.number}/files`, { headers: { Authorization: `token ${pm.giteaToken}` } }); return { ok: true, count: (r.data || []).length, files: (r.data || []).map(f => ({ filename: f.filename, status: f.status })) }; }
+        }, { organization: args.organization }), 3, "pulls-files");
+        return asToolResult({ success: true, providers: out });
+      }
+      return asToolError("VALIDATION_ERROR", `Ação '${args.action}' não suportada`, { availableActions: ["create", "list", "files"] });
+    } catch (e) {
+      return errorToResponse(e);
+    }
+  }
+
+  return { name: "git-pulls", description, inputSchema, handle };
+}