@andre.buzeli/git-mcp 15.12.5

package/src/tools/git-stash.js

@@ -0,0 +1,120 @@
+import Ajv from "ajv";
+import { asToolError, asToolResult, errorToResponse } from "../utils/errors.js";
+import { validateProjectPath } from "../utils/repoHelpers.js";
+
+const ajv = new Ajv({ allErrors: true });
+
+export function createGitStashTool(git) {
+  const inputSchema = {
+    type: "object",
+    properties: {
+      projectPath: { 
+        type: "string",
+        description: "Caminho absoluto do diretório do projeto"
+      },
+      action: { 
+        type: "string", 
+        enum: ["list", "save", "apply", "pop", "drop", "clear"],
+        description: `Ação a executar:
+- list: Lista todos os stashes salvos
+- save: Salva mudanças atuais no stash (limpa working directory)
+- apply: Aplica stash sem removê-lo da lista
+- pop: Aplica stash E remove da lista (mais comum)
+- drop: Remove stash específico da lista
+- clear: Remove TODOS os stashes`
+      },
+      message: { 
+        type: "string",
+        description: "Mensagem descritiva para o stash (action='save'). Ex: 'WIP: implementando feature X'"
+      },
+      ref: { 
+        type: "string",
+        description: "Referência do stash para apply/pop/drop. Ex: 'stash@{0}' (mais recente), 'stash@{1}' (segundo)"
+      },
+      includeUntracked: { 
+        type: "boolean",
+        description: "Incluir arquivos não rastreados no stash (action='save'). Default: false"
+      }
+    },
+    required: ["projectPath", "action"],
+    additionalProperties: false
+  };
+
+  const description = `Gerenciamento de stash Git - salva mudanças temporariamente.
+
+QUANDO USAR STASH:
+- Precisa trocar de branch mas tem mudanças não commitadas
+- Quer salvar trabalho em progresso sem commitar
+- Precisa aplicar hotfix urgente em outra branch
+
+FLUXO TÍPICO:
+1. git-stash save message='WIP: minha feature'  → salva mudanças
+2. (trabalha em outra coisa)
+3. git-stash pop  → restaura mudanças
+
+AÇÕES:
+- save: Salva e limpa working directory
+- pop: Restaura e remove do stash (use este na maioria dos casos)
+- apply: Restaura mas mantém no stash (para aplicar em múltiplas branches)
+- list: Ver stashes salvos
+- drop: Remover stash específico
+- clear: Remover todos os stashes`;
+
+  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 items = await withRetry(() => git.listStash(projectPath), 3, "stash-list");
+        return asToolResult({ 
+          stashes: items.map((s, i) => ({ index: i, ref: `stash@{${i}}`, message: s.message, timestamp: s.timestamp })),
+          count: items.length,
+          message: items.length === 0 ? "Nenhum stash salvo" : undefined
+        });
+      }
+      if (action === "save") {
+        const status = await git.status(projectPath);
+        if (status.isClean && !args.includeUntracked) {
+          return asToolError("NOTHING_TO_STASH", "Working tree limpa, nada para stash", { status });
+        }
+        await withRetry(() => git.saveStash(projectPath, args.message || "WIP", !!args.includeUntracked), 3, "stash-save");
+        return asToolResult({ success: true, message: args.message || "WIP", savedFiles: status.modified.length + status.created.length + status.not_added.length });
+      }
+      if (action === "apply") {
+        const items = await git.listStash(projectPath);
+        if (items.length === 0) {
+          return asToolError("STASH_NOT_FOUND", "Nenhum stash disponível", { availableStashes: [] });
+        }
+        await withRetry(() => git.applyStash(projectPath, args.ref || "stash@{0}"), 3, "stash-apply");
+        return asToolResult({ success: true, ref: args.ref || "stash@{0}", message: "Stash aplicado (ainda está na lista)" });
+      }
+      if (action === "pop") {
+        const items = await git.listStash(projectPath);
+        if (items.length === 0) {
+          return asToolError("STASH_NOT_FOUND", "Nenhum stash disponível", { availableStashes: [] });
+        }
+        await withRetry(() => git.popStash(projectPath, args.ref || "stash@{0}"), 3, "stash-pop");
+        return asToolResult({ success: true, ref: args.ref || "stash@{0}", message: "Stash aplicado e removido da lista" });
+      }
+      if (action === "drop") {
+        const items = await git.listStash(projectPath);
+        if (items.length === 0) {
+          return asToolError("STASH_NOT_FOUND", "Nenhum stash disponível", { availableStashes: [] });
+        }
+        await git.dropStash(projectPath, args.ref || "stash@{0}");
+        return asToolResult({ success: true, ref: args.ref || "stash@{0}", message: "Stash removido" });
+      }
+      if (action === "clear") {
+        await git.clearStash(projectPath);
+        return asToolResult({ success: true, message: "Todos os stashes removidos" });
+      }
+      return asToolError("VALIDATION_ERROR", `Ação '${action}' não suportada`, { availableActions: ["list", "save", "apply", "pop", "drop", "clear"] });
+    } catch (e) {
+      return errorToResponse(e);
+    }
+  }
+
+  return { name: "git-stash", description, inputSchema, handle };
+}

package/src/tools/git-sync.js

@@ -0,0 +1,129 @@
+import Ajv from "ajv";
+import { asToolError, asToolResult, errorToResponse } from "../utils/errors.js";
+import { validateProjectPath, withRetry } from "../utils/repoHelpers.js";
+
+const ajv = new Ajv({ allErrors: true });
+
+export function createGitSyncTool(git) {
+  const inputSchema = {
+    type: "object",
+    properties: {
+      projectPath: { 
+        type: "string",
+        description: "Caminho absoluto do diretório do projeto"
+      },
+      action: { 
+        type: "string", 
+        enum: ["pull", "fetch"],
+        description: `Ação a executar:
+- fetch: Baixa commits do remote sem aplicar (seguro, apenas atualiza refs remotas)
+- pull: Baixa E aplica commits do remote (pode gerar conflitos)`
+      },
+      remote: { 
+        type: "string",
+        description: "Nome do remote específico (github, gitea, origin). Se não especificado, tenta todos"
+      },
+      branch: { 
+        type: "string",
+        description: "Branch para sincronizar. Default: branch atual"
+      }
+    },
+    required: ["projectPath", "action"],
+    additionalProperties: false
+  };
+
+  const description = `Sincronização com repositórios remotos (GitHub/Gitea).
+
+DIFERENÇA FETCH vs PULL:
+- fetch: Seguro - apenas baixa, não modifica working directory
+- pull: Baixa E aplica - pode gerar conflitos se houver mudanças locais
+
+QUANDO USAR:
+- fetch: Para ver se há atualizações sem aplicar
+- pull: Para atualizar seu código local com as mudanças do remote
+
+FLUXO RECOMENDADO:
+1. git-workflow status → verificar se tem mudanças locais
+2. git-sync fetch → baixar atualizações
+3. git-sync pull → aplicar atualizações (se não tiver conflitos)
+
+NOTA: Se pull falhar com conflito, resolva manualmente e faça commit.`;
+
+  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);
+      const branch = args.branch || await git.getCurrentBranch(projectPath);
+      if (action === "fetch") {
+        const remotes = args.remote ? [args.remote] : ["origin", "github", "gitea"];
+        const promises = remotes.map(r => withRetry(
+          () => git.fetch(projectPath, r, branch), 
+          3, 
+          `fetch-${r}`
+        ).then(() => ({ remote: r, ok: true })).catch(e => ({ remote: r, ok: false, error: String(e?.message || e) })));
+        const results = await Promise.all(promises);
+        const successful = results.filter(x => x.ok);
+        const failed = results.filter(x => !x.ok);
+        return asToolResult({ 
+          success: successful.length > 0, 
+          branch, 
+          fetched: successful.map(x => x.remote),
+          failed: failed.map(x => ({ remote: x.remote, error: x.error })),
+          message: successful.length === 0 ? "Nenhum remote alcançado. Use git-remote ensure para configurar." : `Fetch de ${successful.length} remote(s) concluído`
+        });
+      }
+      if (action === "pull") {
+        // Auto-stash logic
+        const status = await git.status(projectPath);
+        let stashed = false;
+        if (!status.isClean) {
+          console.log("[GitSync] Working directory dirty, creating auto-stash...");
+          try {
+            await git.saveStash(projectPath, `Auto-stash before pull ${new Date().toISOString()}`, true);
+            stashed = true;
+          } catch (stashError) {
+            return asToolError("STASH_FAILED", "Falha ao criar stash automático antes do pull", { error: stashError.message });
+          }
+        }
+
+        const remotes = args.remote ? [args.remote] : ["origin", "github", "gitea"];
+        const promises = remotes.map(r => withRetry(
+          () => git.pull(projectPath, r, branch),
+          3,
+          `pull-${r}`
+        ).then(() => ({ remote: r, ok: true })).catch(e => ({ remote: r, ok: false, error: String(e?.message || e) })));
+        
+        const results = await Promise.all(promises);
+        const successful = results.filter(x => x.ok);
+        const failed = results.filter(x => !x.ok);
+
+        let stashMessage = "";
+        if (stashed) {
+          try {
+            console.log("[GitSync] Restoring auto-stash...");
+            await git.popStash(projectPath);
+            stashMessage = " (mudanças locais restauradas)";
+          } catch (popError) {
+            stashMessage = " (ATENÇÃO: mudanças salvas no stash, mas houve conflito ao restaurar. Use 'git-stash pop' manualmente)";
+          }
+        }
+
+        return asToolResult({ 
+          success: successful.length > 0, 
+          branch, 
+          pulled: successful.map(x => x.remote),
+          failed: failed.map(x => ({ remote: x.remote, error: x.error })),
+          message: (successful.length === 0 ? "Nenhum remote alcançado." : `Pull de ${successful.length} remote(s) concluído`) + stashMessage,
+          stashed
+        });
+      }
+      return asToolError("VALIDATION_ERROR", `Ação '${action}' não suportada`, { availableActions: ["pull", "fetch"] });
+    } catch (e) {
+      return errorToResponse(e);
+    }
+  }
+
+  return { name: "git-sync", description, inputSchema, handle };
+}

package/src/tools/git-tags.js

@@ -0,0 +1,113 @@
+import Ajv from "ajv";
+import { asToolError, asToolResult, errorToResponse } from "../utils/errors.js";
+import { validateProjectPath, withRetry } from "../utils/repoHelpers.js";
+
+const ajv = new Ajv({ allErrors: true });
+
+export function createGitTagsTool(git) {
+  const inputSchema = {
+    type: "object",
+    properties: {
+      projectPath: { 
+        type: "string",
+        description: "Caminho absoluto do diretório do projeto"
+      },
+      action: { 
+        type: "string", 
+        enum: ["list", "create", "delete", "push"],
+        description: `Ação a executar:
+- list: Lista todas as tags existentes
+- create: Cria nova tag no commit atual ou especificado
+- delete: Remove uma tag local
+- push: Envia tag para GitHub e Gitea`
+      },
+      tag: { 
+        type: "string",
+        description: "Nome da tag. Use versionamento semântico: v1.0.0, v1.1.0, v2.0.0"
+      },
+      ref: { 
+        type: "string",
+        description: "Commit/branch para criar tag (opcional, default: HEAD)"
+      },
+      message: { 
+        type: "string",
+        description: "Mensagem da tag anotada (opcional). Se fornecido, cria tag anotada"
+      }
+    },
+    required: ["projectPath", "action"],
+    additionalProperties: false
+  };
+
+  const description = `Gerenciamento de tags Git para versionamento.
+
+AÇÕES DISPONÍVEIS:
+- list: Ver todas as tags existentes
+- create: Criar nova tag de versão
+- delete: Remover tag local
+- push: Enviar tag para GitHub e Gitea
+
+VERSIONAMENTO SEMÂNTICO:
+- v1.0.0: Versão inicial
+- v1.1.0: Nova funcionalidade (minor)
+- v1.0.1: Correção de bug (patch)
+- v2.0.0: Breaking change (major)
+
+FLUXO TÍPICO:
+1. git-tags create tag='v1.0.0' message='Release inicial'
+2. git-tags push tag='v1.0.0'`;
+
+  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 tags = await git.listTags(projectPath);
+        return asToolResult({ tags, count: tags.length });
+      }
+      if (action === "create") {
+        if (!args.tag) return asToolError("MISSING_PARAMETER", "tag é obrigatório", { parameter: "tag" });
+        const existing = await git.listTags(projectPath);
+        if (existing.includes(args.tag)) {
+          return asToolError("TAG_ALREADY_EXISTS", `Tag '${args.tag}' já existe`, { tag: args.tag, existingTags: existing });
+        }
+        await withRetry(() => git.createTag(projectPath, args.tag, args.ref || "HEAD", args.message), 3, "create-tag");
+        return asToolResult({ success: true, tag: args.tag, ref: args.ref || "HEAD", message: `Tag '${args.tag}' criada. Use action='push' para enviar ao GitHub/Gitea.` });
+      }
+      if (action === "delete") {
+        if (!args.tag) return asToolError("MISSING_PARAMETER", "tag é obrigatório", { parameter: "tag" });
+        const existing = await git.listTags(projectPath);
+        if (!existing.includes(args.tag)) {
+          return asToolError("TAG_NOT_FOUND", `Tag '${args.tag}' não encontrada`, { tag: args.tag, existingTags: existing });
+        }
+        await withRetry(() => git.deleteTag(projectPath, args.tag), 3, "delete-tag");
+        return asToolResult({ success: true, tag: args.tag, deleted: true });
+      }
+      if (action === "push") {
+        if (!args.tag) return asToolError("MISSING_PARAMETER", "tag é obrigatório", { parameter: "tag" });
+        const existing = await git.listTags(projectPath);
+        if (!existing.includes(args.tag)) {
+          return asToolError("TAG_NOT_FOUND", `Tag '${args.tag}' não existe localmente. Crie primeiro com action='create'`, { tag: args.tag, existingTags: existing });
+        }
+        const results = await Promise.allSettled([
+          withRetry(() => git.pushTag(projectPath, "github", args.tag), 3, "push-tag-github"),
+          withRetry(() => git.pushTag(projectPath, "gitea", args.tag), 3, "push-tag-gitea")
+        ]);
+        const pushed = [];
+        const failed = [];
+        if (results[0].status === "fulfilled") pushed.push("github");
+        else failed.push({ remote: "github", error: results[0].reason?.message });
+        if (results[1].status === "fulfilled") pushed.push("gitea");
+        else failed.push({ remote: "gitea", error: results[1].reason?.message });
+        
+        return asToolResult({ success: pushed.length > 0, tag: args.tag, pushed, failed });
+      }
+      return asToolError("VALIDATION_ERROR", `Ação '${action}' não suportada`, { availableActions: ["list", "create", "delete", "push"] });
+    } catch (e) {
+      return errorToResponse(e);
+    }
+  }
+
+  return { name: "git-tags", description, inputSchema, handle };
+}