@andrebuzeli/git-mcp 12.0.0 → 13.6.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@andrebuzeli/git-mcp",
-  "version": "12.0.0",
+  "version": "13.6.0",
   "private": false,
   "description": "MCP server para Git com operações locais e sincronização paralela GitHub/Gitea",
   "license": "MIT",

package/src/index.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
-import { Server } from "@modelcontextprotocol/sdk/dist/server/index.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/dist/server/stdio.js";
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import Ajv from "ajv";
 import { asToolError } from "./utils/errors.js";
 import { ProviderManager } from "./providers/providerManager.js";
@@ -52,13 +52,13 @@ function listToolsResult() {
 
 server.setRequestHandler(
   // list tools
-  (await import("@modelcontextprotocol/sdk/dist/types.js")).ListToolsRequestSchema,
+  (await import("@modelcontextprotocol/sdk/types.js")).ListToolsRequestSchema,
   async () => listToolsResult()
 );
 
 server.setRequestHandler(
   // call tool
-  (await import("@modelcontextprotocol/sdk/dist/types.js")).CallToolRequestSchema,
+  (await import("@modelcontextprotocol/sdk/types.js")).CallToolRequestSchema,
   async (req) => {
     const name = req.params?.name || "";
     const args = req.params?.arguments || {};

package/src/tools/git-branches.js

@@ -1,5 +1,5 @@
 import Ajv from "ajv";
-import { asToolError, asToolResult } from "../utils/errors.js";
+import { asToolError, asToolResult, errorToResponse } from "../utils/errors.js";
 
 const ajv = new Ajv({ allErrors: true });
 
@@ -29,32 +29,46 @@ export function createGitBranchesTool(git) {
       }
       if (action === "create") {
         const ref = args.branch;
-        if (!ref) return asToolError("VALIDATION_ERROR", "branch é obrigatório");
+        if (!ref) return asToolError("MISSING_PARAMETER", "branch é obrigatório", { parameter: "branch" });
+        // Auto-correção: verificar se já existe
+        const existing = await git.listBranches(projectPath, false);
+        if (existing.includes(ref)) {
+          return asToolError("BRANCH_ALREADY_EXISTS", `Branch '${ref}' já existe`, { branch: ref, existingBranches: existing });
+        }
         await git.createBranch(projectPath, ref);
         return asToolResult({ success: true, branch: ref });
       }
       if (action === "delete") {
         const ref = args.branch;
-        if (!ref) return asToolError("VALIDATION_ERROR", "branch é obrigatório");
+        if (!ref) return asToolError("MISSING_PARAMETER", "branch é obrigatório", { parameter: "branch" });
+        // Auto-correção: verificar se existe e não é a atual
+        const existing = await git.listBranches(projectPath, false);
+        if (!existing.includes(ref)) {
+          return asToolError("BRANCH_NOT_FOUND", `Branch '${ref}' não encontrada`, { branch: ref, availableBranches: existing });
+        }
+        const current = await git.getCurrentBranch(projectPath);
+        if (ref === current) {
+          return asToolError("CANNOT_DELETE_CURRENT", `Não pode deletar branch atual '${ref}'`, { branch: ref, suggestion: "Faça checkout para outra branch primeiro" });
+        }
         await git.deleteBranch(projectPath, ref, !!args.force);
         return asToolResult({ success: true, branch: ref });
       }
       if (action === "rename") {
         const oldName = args.branch;
         const newName = args.newBranch;
-        if (!oldName || !newName) return asToolError("VALIDATION_ERROR", "branch e newBranch são obrigatórios");
+        if (!oldName || !newName) return asToolError("MISSING_PARAMETER", "branch e newBranch são obrigatórios", { parameters: ["branch", "newBranch"] });
         await git.renameBranch(projectPath, oldName, newName);
         return asToolResult({ success: true, from: oldName, to: newName });
       }
       if (action === "checkout") {
         const ref = args.branch;
-        if (!ref) return asToolError("VALIDATION_ERROR", "branch é obrigatório");
+        if (!ref) return asToolError("MISSING_PARAMETER", "branch é obrigatório", { parameter: "branch" });
         await git.checkout(projectPath, ref);
         return asToolResult({ success: true, branch: ref });
       }
-      return asToolError("VALIDATION_ERROR", `Ação não suportada: ${action}`);
+      return asToolError("VALIDATION_ERROR", `Ação não suportada: ${action}`, { availableActions: ["list", "create", "delete", "rename", "checkout"] });
     } catch (e) {
-      return asToolError(e.code || "ERROR", e.message || String(e));
+      return errorToResponse(e);
     }
   }
 

package/src/tools/git-config.js

@@ -1,5 +1,5 @@
 import Ajv from "ajv";
-import { asToolError, asToolResult } from "../utils/errors.js";
+import { asToolError, asToolResult, errorToResponse } from "../utils/errors.js";
 
 const ajv = new Ajv({ allErrors: true });
 
@@ -24,30 +24,29 @@ export function createGitConfigTool(git) {
     const scope = args.scope || "local";
     try {
       if (action === "get") {
-        if (!args.key) return asToolError("VALIDATION_ERROR", "key é obrigatório");
+        if (!args.key) return asToolError("MISSING_PARAMETER", "key é obrigatório", { parameter: "key" });
         const val = await git.getConfig(projectPath, args.key, scope);
-        return asToolResult({ key: args.key, value: val });
+        return asToolResult({ key: args.key, value: val, found: val !== undefined });
       }
       if (action === "set") {
-        if (!args.key) return asToolError("VALIDATION_ERROR", "key é obrigatório");
+        if (!args.key) return asToolError("MISSING_PARAMETER", "key é obrigatório", { parameter: "key" });
         await git.setConfig(projectPath, args.key, args.value ?? "", scope);
         return asToolResult({ success: true, key: args.key, value: args.value ?? "" });
       }
       if (action === "unset") {
-        if (!args.key) return asToolError("VALIDATION_ERROR", "key é obrigatório");
+        if (!args.key) return asToolError("MISSING_PARAMETER", "key é obrigatório", { parameter: "key" });
         await git.unsetConfig(projectPath, args.key, scope);
         return asToolResult({ success: true, key: args.key });
       }
       if (action === "list") {
         const items = await git.listConfig(projectPath, scope);
-        return asToolResult({ scope, items });
+        return asToolResult({ scope, items, count: Object.keys(items).length });
       }
-      return asToolError("VALIDATION_ERROR", `Ação não suportada: ${action}`);
+      return asToolError("VALIDATION_ERROR", `Ação não suportada: ${action}`, { availableActions: ["get", "set", "unset", "list"] });
     } catch (e) {
-      return asToolError(e.code || "ERROR", e.message || String(e));
+      return errorToResponse(e);
     }
   }
 
   return { name: "git-config", description: "Gerencia configurações Git (local/global/system)", inputSchema, handle };
 }
-

package/src/tools/git-files.js

@@ -1,5 +1,5 @@
 import Ajv from "ajv";
-import { asToolError, asToolResult } from "../utils/errors.js";
+import { asToolError, asToolResult, errorToResponse } from "../utils/errors.js";
 
 const ajv = new Ajv({ allErrors: true });
 
@@ -23,19 +23,29 @@ export function createGitFilesTool(git) {
     try {
       if (action === "list") {
         const files = await git.listFiles(projectPath, args.ref || "HEAD");
-        return asToolResult({ files });
+        return asToolResult({ files, count: files.length });
       }
       if (action === "read") {
-        if (!args.filepath) return asToolError("VALIDATION_ERROR", "filepath é obrigatório");
-        const text = await git.readFile(projectPath, args.filepath, args.ref || "HEAD");
-        return { content: [{ type: "text", text }], isError: false };
+        if (!args.filepath) return asToolError("MISSING_PARAMETER", "filepath é obrigatório", { parameter: "filepath" });
+        try {
+          const text = await git.readFile(projectPath, args.filepath, args.ref || "HEAD");
+          return { content: [{ type: "text", text }], isError: false };
+        } catch (e) {
+          // Auto-diagnóstico: listar arquivos disponíveis se não encontrar
+          const files = await git.listFiles(projectPath, args.ref || "HEAD").catch(() => []);
+          return asToolError("FILE_NOT_FOUND", `Arquivo '${args.filepath}' não encontrado`, { 
+            filepath: args.filepath, 
+            ref: args.ref || "HEAD",
+            availableFiles: files.slice(0, 20),
+            totalFiles: files.length
+          });
+        }
       }
-      return asToolError("VALIDATION_ERROR", `Ação não suportada: ${action}`);
+      return asToolError("VALIDATION_ERROR", `Ação não suportada: ${action}`, { availableActions: ["list", "read"] });
     } catch (e) {
-      return asToolError(e.code || "ERROR", e.message || String(e));
+      return errorToResponse(e);
     }
   }
 
   return { name: "git-files", description: "Lista e lê arquivos do repo", inputSchema, handle };
 }
-

package/src/tools/git-history.js

@@ -1,5 +1,5 @@
 import Ajv from "ajv";
-import { asToolError, asToolResult } from "../utils/errors.js";
+import { asToolError, asToolResult, errorToResponse } from "../utils/errors.js";
 
 const ajv = new Ajv({ allErrors: true });
 
@@ -23,14 +23,31 @@ export function createGitHistoryTool(git) {
     try {
       if (action === "log") {
         const items = await git.log(projectPath, { ref: args.ref || "HEAD", maxCount: args.maxCount || 50 });
-        return asToolResult({ commits: items });
+        if (items.length === 0) {
+          return asToolResult({ 
+            commits: [], 
+            count: 0, 
+            message: "Nenhum commit encontrado. Use action='commit' para criar o primeiro commit." 
+          });
+        }
+        return asToolResult({ 
+          commits: items.map(c => ({
+            sha: c.sha,
+            shortSha: c.sha.substring(0, 7),
+            message: c.message.split("\n")[0],
+            fullMessage: c.message,
+            author: c.author.name,
+            email: c.author.email,
+            date: c.date
+          })), 
+          count: items.length 
+        });
       }
-      return asToolError("VALIDATION_ERROR", `Ação não suportada: ${action}`);
+      return asToolError("VALIDATION_ERROR", `Ação não suportada: ${action}`, { availableActions: ["log"] });
     } catch (e) {
-      return asToolError(e.code || "ERROR", e.message || String(e));
+      return errorToResponse(e);
     }
   }
 
   return { name: "git-history", description: "Histórico de commits", inputSchema, handle };
 }
-

package/src/tools/git-ignore.js

@@ -1,5 +1,5 @@
 import Ajv from "ajv";
-import { asToolError, asToolResult } from "../utils/errors.js";
+import { asToolError, asToolResult, errorToResponse } from "../utils/errors.js";
 
 const ajv = new Ajv({ allErrors: true });
 
@@ -23,26 +23,37 @@ export function createGitIgnoreTool(git) {
     try {
       if (action === "list") {
         const items = await git.listGitignore(projectPath);
-        return asToolResult({ items });
+        return asToolResult({ items, count: items.length });
       }
       if (action === "create") {
+        if (patterns.length === 0) {
+          return asToolError("MISSING_PARAMETER", "patterns é obrigatório para criar .gitignore", { 
+            parameter: "patterns",
+            suggestion: "Forneça um array de padrões, ex: ['node_modules/', '*.log', '.env']"
+          });
+        }
         await git.createGitignore(projectPath, patterns);
-        return asToolResult({ success: true });
+        return asToolResult({ success: true, patterns });
       }
       if (action === "add") {
+        if (patterns.length === 0) {
+          return asToolError("MISSING_PARAMETER", "patterns é obrigatório para adicionar ao .gitignore", { parameter: "patterns" });
+        }
         await git.addToGitignore(projectPath, patterns);
-        return asToolResult({ success: true });
+        return asToolResult({ success: true, added: patterns });
       }
       if (action === "remove") {
+        if (patterns.length === 0) {
+          return asToolError("MISSING_PARAMETER", "patterns é obrigatório para remover do .gitignore", { parameter: "patterns" });
+        }
         await git.removeFromGitignore(projectPath, patterns);
-        return asToolResult({ success: true });
+        return asToolResult({ success: true, removed: patterns });
       }
-      return asToolError("VALIDATION_ERROR", `Ação não suportada: ${action}`);
+      return asToolError("VALIDATION_ERROR", `Ação não suportada: ${action}`, { availableActions: ["list", "create", "add", "remove"] });
     } catch (e) {
-      return asToolError(e.code || "ERROR", e.message || String(e));
+      return errorToResponse(e);
     }
   }
 
   return { name: "git-ignore", description: "Gerencia .gitignore", inputSchema, handle };
 }
-

package/src/tools/git-issues.js

@@ -1,6 +1,6 @@
 import Ajv from "ajv";
 import axios from "axios";
-import { asToolError, asToolResult } from "../utils/errors.js";
+import { asToolError, asToolResult, errorToResponse } from "../utils/errors.js";
 import { getRepoNameFromPath } from "../utils/repoHelpers.js";
 import { runBoth } from "../utils/providerExec.js";
 
@@ -48,9 +48,9 @@ export function createGitIssuesTool(pm) {
         });
         return asToolResult({ success: !!(out.github?.ok || out.gitea?.ok), providers: out });
       }
-      return asToolError("VALIDATION_ERROR", `Ação não suportada: ${args.action}`);
+      return asToolError("VALIDATION_ERROR", `Ação não suportada: ${args.action}`, { availableActions: ["create", "list", "comment"] });
     } catch (e) {
-      return asToolError(e.code || "ERROR", e.message || String(e));
+      return errorToResponse(e);
     }
   }
 

package/src/tools/git-pulls.js

@@ -1,6 +1,6 @@
 import Ajv from "ajv";
 import axios from "axios";
-import { asToolError, asToolResult } from "../utils/errors.js";
+import { asToolError, asToolResult, errorToResponse } from "../utils/errors.js";
 import { getRepoNameFromPath } from "../utils/repoHelpers.js";
 import { runBoth } from "../utils/providerExec.js";
 
@@ -51,9 +51,9 @@ export function createGitPullsTool(pm) {
         });
         return asToolResult({ providers: out });
       }
-      return asToolError("VALIDATION_ERROR", `Ação não suportada: ${args.action}`);
+      return asToolError("VALIDATION_ERROR", `Ação não suportada: ${args.action}`, { availableActions: ["create", "list", "files"] });
     } catch (e) {
-      return asToolError(e.code || "ERROR", e.message || String(e));
+      return errorToResponse(e);
     }
   }
 

package/src/tools/git-remote.js

@@ -1,6 +1,6 @@
 import Ajv from "ajv";
 import axios from "axios";
-import { asToolError, asToolResult } from "../utils/errors.js";
+import { asToolError, asToolResult, errorToResponse, mapExternalError } from "../utils/errors.js";
 import { getRepoNameFromPath } from "../utils/repoHelpers.js";
 import { runBoth } from "../utils/providerExec.js";
 
@@ -167,9 +167,11 @@ export function createGitRemoteTool(pm, git) {
         });
         return asToolResult({ success: !!(out.github?.ok || out.gitea?.ok), path: filePath, providers: out });
       }
-      return asToolError("VALIDATION_ERROR", `Ação não suportada: ${action}`);
+      return asToolError("VALIDATION_ERROR", `Ação não suportada: ${action}`, { 
+        availableActions: ["list", "ensure", "set-url", "repo-delete", "release-create", "topics-set", "milestone-create", "label-create", "fork-create", "fork-list", "star-set", "star-unset", "star-check", "subscription-set", "subscription-unset", "contents-create"] 
+      });
     } catch (e) {
-      return asToolError(e.code || "ERROR", e.message || String(e));
+      return errorToResponse(e);
     }
   }
 

package/src/tools/git-reset.js

@@ -1,5 +1,5 @@
 import Ajv from "ajv";
-import { asToolError, asToolResult } from "../utils/errors.js";
+import { asToolError, asToolResult, errorToResponse } from "../utils/errors.js";
 
 const ajv = new Ajv({ allErrors: true });
 
@@ -20,16 +20,31 @@ export function createGitResetTool(git) {
     if (!validate(args || {})) return asToolError("VALIDATION_ERROR", "Parâmetros inválidos", validate.errors);
     const { projectPath, action, ref } = args;
     try {
+      // Auto-verificação: checar se há commits suficientes para HEAD~N
+      if (ref.match(/HEAD~(\d+)/)) {
+        const match = ref.match(/HEAD~(\d+)/);
+        const steps = parseInt(match[1], 10);
+        const log = await git.log(projectPath, { maxCount: steps + 2 });
+        if (log.length <= steps) {
+          return asToolError("INSUFFICIENT_HISTORY", `Histórico insuficiente para ${ref}`, {
+            requestedSteps: steps,
+            availableCommits: log.length,
+            suggestion: `Use HEAD~${log.length - 1} no máximo, ou um SHA específico`,
+            recentCommits: log.slice(0, 5).map(c => ({ sha: c.sha.substring(0, 7), message: c.message.split("\n")[0] }))
+          });
+        }
+      }
+      
       if (action === "soft") await git.resetSoft(projectPath, ref);
       else if (action === "mixed") await git.resetMixed(projectPath, ref);
       else if (action === "hard") await git.resetHard(projectPath, ref);
-      else return asToolError("VALIDATION_ERROR", `Ação não suportada: ${action}`);
-      return asToolResult({ success: true, action, ref });
+      else return asToolError("VALIDATION_ERROR", `Ação não suportada: ${action}`, { availableActions: ["soft", "mixed", "hard"] });
+      
+      return asToolResult({ success: true, action, ref, message: `Reset ${action} para ${ref} realizado` });
     } catch (e) {
-      return asToolError(e.code || "ERROR", e.message || String(e));
+      return errorToResponse(e);
     }
   }
 
   return { name: "git-reset", description: "Reset soft/mixed/hard", inputSchema, handle };
 }
-

package/src/tools/git-stash.js

@@ -1,5 +1,5 @@
 import Ajv from "ajv";
-import { asToolError, asToolResult } from "../utils/errors.js";
+import { asToolError, asToolResult, errorToResponse } from "../utils/errors.js";
 
 const ajv = new Ajv({ allErrors: true });
 
@@ -24,34 +24,55 @@ export function createGitStashTool(git) {
     try {
       if (action === "list") {
         const items = await git.listStash(projectPath);
-        return asToolResult({ items });
+        return asToolResult({ 
+          items: items.map((s, i) => ({ index: i, ref: `stash@{${i}}`, message: s.message, timestamp: s.timestamp })),
+          count: items.length 
+        });
       }
       if (action === "save") {
+        // Auto-verificação: checar se há mudanças
+        const status = await git.status(projectPath);
+        if (status.isClean && !args.includeUntracked) {
+          return asToolError("NOTHING_TO_STASH", "Working tree limpa, nada para stash", { status });
+        }
         await git.saveStash(projectPath, args.message || "WIP", !!args.includeUntracked);
-        return asToolResult({ success: true });
+        return asToolResult({ success: true, message: args.message || "WIP" });
       }
       if (action === "apply") {
+        // Auto-verificação: checar se stash existe
+        const items = await git.listStash(projectPath);
+        if (items.length === 0) {
+          return asToolError("STASH_NOT_FOUND", "Nenhum stash disponível", { availableStashes: [] });
+        }
         await git.applyStash(projectPath, args.ref);
-        return asToolResult({ success: true });
+        return asToolResult({ success: true, ref: args.ref || "stash@{0}" });
       }
       if (action === "pop") {
+        // Auto-verificação: checar se stash existe
+        const items = await git.listStash(projectPath);
+        if (items.length === 0) {
+          return asToolError("STASH_NOT_FOUND", "Nenhum stash disponível", { availableStashes: [] });
+        }
         await git.popStash(projectPath, args.ref);
-        return asToolResult({ success: true });
+        return asToolResult({ success: true, ref: args.ref || "stash@{0}" });
       }
       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);
-        return asToolResult({ success: true });
+        return asToolResult({ success: true, ref: args.ref || "stash@{0}" });
       }
       if (action === "clear") {
         await git.clearStash(projectPath);
-        return asToolResult({ success: true });
+        return asToolResult({ success: true, message: "Todos os stashes removidos" });
       }
-      return asToolError("VALIDATION_ERROR", `Ação não suportada: ${action}`);
+      return asToolError("VALIDATION_ERROR", `Ação não suportada: ${action}`, { availableActions: ["list", "save", "apply", "pop", "drop", "clear"] });
     } catch (e) {
-      return asToolError(e.code || "ERROR", e.message || String(e));
+      return errorToResponse(e);
     }
   }
 
   return { name: "git-stash", description: "Gerencia stash", inputSchema, handle };
 }
-

package/src/tools/git-sync.js

@@ -1,5 +1,5 @@
 import Ajv from "ajv";
-import { asToolError, asToolResult } from "../utils/errors.js";
+import { asToolError, asToolResult, errorToResponse } from "../utils/errors.js";
 
 const ajv = new Ajv({ allErrors: true });
 
@@ -26,17 +26,33 @@ export function createGitSyncTool(git) {
         const remotes = args.remote ? [args.remote] : ["origin", "github", "gitea"];
         const promises = remotes.map(r => git.fetch(projectPath, r, branch).then(() => ({ remote: r, ok: true })).catch(e => ({ remote: r, ok: false, error: String(e?.message || e) })));
         const results = await Promise.all(promises);
-        return asToolResult({ success: results.some(x => x.ok), branch, results });
+        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. Verifique conexão e configuração." : undefined
+        });
       }
       if (action === "pull") {
         const remotes = args.remote ? [args.remote] : ["origin", "github", "gitea"];
         const promises = remotes.map(r => git.pull(projectPath, r, branch).then(() => ({ remote: r, ok: true })).catch(e => ({ remote: r, ok: false, error: String(e?.message || e) })));
         const results = await Promise.all(promises);
-        return asToolResult({ success: results.some(x => x.ok), branch, results });
+        const successful = results.filter(x => x.ok);
+        const failed = results.filter(x => !x.ok);
+        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. Verifique conexão e configuração." : undefined
+        });
       }
-      return asToolError("VALIDATION_ERROR", `Ação não suportada: ${action}`);
+      return asToolError("VALIDATION_ERROR", `Ação não suportada: ${action}`, { availableActions: ["pull", "fetch"] });
     } catch (e) {
-      return asToolError(e.code || "ERROR", e.message || String(e));
+      return errorToResponse(e);
     }
   }
 

package/src/tools/git-tags.js

@@ -1,5 +1,5 @@
 import Ajv from "ajv";
-import { asToolError, asToolResult } from "../utils/errors.js";
+import { asToolError, asToolResult, errorToResponse } from "../utils/errors.js";
 
 const ajv = new Ajv({ allErrors: true });
 
@@ -24,35 +24,56 @@ export function createGitTagsTool(git) {
     try {
       if (action === "list") {
         const tags = await git.listTags(projectPath);
-        return asToolResult({ tags });
+        return asToolResult({ tags, count: tags.length });
       }
       if (action === "create") {
         const tag = args.tag;
-        if (!tag) return asToolError("VALIDATION_ERROR", "tag é obrigatório");
+        if (!tag) return asToolError("MISSING_PARAMETER", "tag é obrigatório", { parameter: "tag" });
+        // Auto-verificação: checar se já existe
+        const existing = await git.listTags(projectPath);
+        if (existing.includes(tag)) {
+          return asToolError("TAG_ALREADY_EXISTS", `Tag '${tag}' já existe`, { tag, existingTags: existing });
+        }
         await git.createTag(projectPath, tag, args.ref || "HEAD", args.message);
-        return asToolResult({ success: true, tag });
+        return asToolResult({ success: true, tag, ref: args.ref || "HEAD" });
       }
       if (action === "delete") {
         const tag = args.tag;
-        if (!tag) return asToolError("VALIDATION_ERROR", "tag é obrigatório");
+        if (!tag) return asToolError("MISSING_PARAMETER", "tag é obrigatório", { parameter: "tag" });
+        // Auto-verificação: checar se existe
+        const existing = await git.listTags(projectPath);
+        if (!existing.includes(tag)) {
+          return asToolError("TAG_NOT_FOUND", `Tag '${tag}' não encontrada`, { tag, existingTags: existing });
+        }
         await git.deleteTag(projectPath, tag);
         return asToolResult({ success: true, tag });
       }
       if (action === "push") {
         const tag = args.tag;
-        if (!tag) return asToolError("VALIDATION_ERROR", "tag é obrigatório");
-        await Promise.all([
-          git.pushTag(projectPath, "github", tag).catch(() => {}),
-          git.pushTag(projectPath, "gitea", tag).catch(() => {})
+        if (!tag) return asToolError("MISSING_PARAMETER", "tag é obrigatório", { parameter: "tag" });
+        // Auto-verificação: checar se existe
+        const existing = await git.listTags(projectPath);
+        if (!existing.includes(tag)) {
+          return asToolError("TAG_NOT_FOUND", `Tag '${tag}' não existe localmente. Crie primeiro com action='create'`, { tag, existingTags: existing });
+        }
+        const results = await Promise.allSettled([
+          git.pushTag(projectPath, "github", tag),
+          git.pushTag(projectPath, "gitea", tag)
         ]);
-        return asToolResult({ success: true, tag, remotes: ["github", "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, pushed, failed });
       }
-      return asToolError("VALIDATION_ERROR", `Ação não suportada: ${action}`);
+      return asToolError("VALIDATION_ERROR", `Ação não suportada: ${action}`, { availableActions: ["list", "create", "delete", "push"] });
     } catch (e) {
-      return asToolError(e.code || "ERROR", e.message || String(e));
+      return errorToResponse(e);
     }
   }
 
   return { name: "git-tags", description: "Gerencia tags e push paralelo", inputSchema, handle };
 }
-

package/src/tools/git-workflow.js

@@ -1,5 +1,5 @@
 import Ajv from "ajv";
-import { MCPError, asToolError, asToolResult } from "../utils/errors.js";
+import { MCPError, asToolError, asToolResult, errorToResponse, createError } from "../utils/errors.js";
 import { getRepoNameFromPath } from "../utils/repoHelpers.js";
 
 const ajv = new Ajv({ allErrors: true });
@@ -11,7 +11,8 @@ export function createGitWorkflowTool(pm, git) {
       projectPath: { type: "string", description: "Caminho absoluto do projeto" },
       action: { type: "string", enum: ["init", "status", "add", "remove", "commit", "push", "pull", "sync", "ensure-remotes"], description: "Ação" },
       files: { type: "array", items: { type: "string" } },
-      message: { type: "string" }
+      message: { type: "string" },
+      force: { type: "boolean", description: "Force push (para resolver divergências de histórico)" }
     },
     required: ["projectPath", "action"],
     additionalProperties: true
@@ -62,16 +63,19 @@ export function createGitWorkflowTool(pm, git) {
       }
       if (action === "push") {
         const branch = await git.getCurrentBranch(projectPath);
-        await git.pushParallel(projectPath, branch);
-        return asToolResult({ success: true, branch, remotes: ["github", "gitea"] });
+        const force = !!args.force;
+        await git.pushParallel(projectPath, branch, force);
+        return asToolResult({ success: true, branch, remotes: ["github", "gitea"], force });
       }
       if (action === "sync" || action === "pull") {
         // Basic implementation: fetch + status; full merge/pull can be added
         return asToolResult({ success: true, message: "Operação de pull/sync não-op realizada" });
       }
-      return asToolError("VALIDATION_ERROR", `Ação não suportada: ${action}`);
+      return asToolError("VALIDATION_ERROR", `Ação não suportada: ${action}`, { 
+        availableActions: ["init", "status", "add", "remove", "commit", "push", "pull", "sync", "ensure-remotes"] 
+      });
     } catch (e) {
-      return asToolError(e.code || "ERROR", e.message || String(e));
+      return errorToResponse(e);
     }
   }