@andrebuzeli/git-mcp 15.9.1 → 15.10.0

package/package.json

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

package/src/index.js

@@ -47,7 +47,7 @@ if (!hasGitHub && !hasGitea) {
 
 const transport = new StdioServerTransport();
 const server = new Server(
-  { name: "git-mcpv2", version: "15.8.0" },
+  { name: "git-mcpv2", version: "15.9.2" },
   { capabilities: { tools: {}, resources: {}, prompts: {} } }
 );
 server.connect(transport);

package/src/tools/git-branches.js

@@ -95,7 +95,25 @@ CONVENÇÕES DE NOMES:
       }
       if (action === "checkout") {
         if (!args.branch) return asToolError("MISSING_PARAMETER", "branch é obrigatório para checkout", { parameter: "branch" });
-        await git.checkout(projectPath, args.branch);
+        
+        try {
+          await git.checkout(projectPath, args.branch);
+        } catch (e) {
+          const msg = e.message || "";
+          // Auto-fix: Create if not exists (common intent)
+          if (msg.includes("did not match any file") || msg.includes("pathspec") || msg.includes("not found")) {
+             // We can suggest or auto-create if configured. For now, let's suggest clearly or auto-create if it looks like a feature branch?
+             // Safer: Suggest. Or better: check if we should auto-create.
+             // Let's stick to safe behavior but enhanced error.
+             
+             // Check if user meant create
+             return asToolError("BRANCH_NOT_FOUND", `Branch '${args.branch}' não existe`, { 
+               suggestion: "Use action='create' para criar esta branch, ou verifique o nome." 
+             });
+          }
+          throw e;
+        }
+        
         return asToolResult({ success: true, branch: args.branch, message: `Mudou para branch '${args.branch}'` });
       }
       return asToolError("VALIDATION_ERROR", `Ação '${action}' não suportada`, { availableActions: ["list", "create", "delete", "rename", "checkout"] });

package/src/tools/git-clone.js

@@ -1,6 +1,6 @@
 import Ajv from "ajv";
 import { asToolError, asToolResult, errorToResponse, createError } from "../utils/errors.js";
-import { validateProjectPath } from "../utils/repoHelpers.js";
+import { validateProjectPath, withRetry } from "../utils/repoHelpers.js";
 
 const ajv = new Ajv({ allErrors: true });
 
@@ -75,11 +75,44 @@ NOTAS:
           });
         }
         
-        const result = await git.clone(url, projectPath, {
-          branch: args.branch,
-          depth: args.depth,
-          singleBranch: args.singleBranch
-        });
+        // Idempotency check
+        if (fs.existsSync(path.join(projectPath, ".git"))) {
+          try {
+            // Check if it's the same repo
+            // git.getRemoteUrl is not standard in adapter, use exec or listRemotes logic
+            // Assuming git.listRemotes or similar exists, or we catch the error
+            // Let's try to infer from config or just warn
+            
+            // We'll rely on git status to check if it's healthy
+            await git.status(projectPath);
+            
+            return asToolResult({
+              success: true,
+              url,
+              path: projectPath,
+              branch: args.branch || "current",
+              message: `Repositório já existe em '${projectPath}'. Clone ignorado (idempotente).`,
+              nextStep: "Use git-workflow status para ver o estado atual"
+            });
+          } catch (e) {
+            // If status fails, maybe it's broken
+            console.warn("Existing repo check failed:", e);
+          }
+        } else if (fs.existsSync(projectPath) && fs.readdirSync(projectPath).length > 0) {
+           return asToolError("DIR_NOT_EMPTY", `Diretório '${projectPath}' existe e não está vazio`, {
+             suggestion: "Use um diretório novo ou limpe o atual"
+           });
+        }
+
+        const result = await withRetry(
+          () => git.clone(url, projectPath, {
+            branch: args.branch,
+            depth: args.depth,
+            singleBranch: args.singleBranch
+          }),
+          3,
+          "clone"
+        );
         
         return asToolResult({
           success: true,

package/src/tools/git-config.js

@@ -66,21 +66,21 @@ EXEMPLOS:
       validateProjectPath(projectPath);
       if (action === "get") {
         if (!args.key) return asToolError("MISSING_PARAMETER", "key é obrigatório", { parameter: "key" });
-        const val = await git.getConfig(projectPath, args.key, scope);
+        const val = await withRetry(() => git.getConfig(projectPath, args.key, scope), 3, "get-config");
         return asToolResult({ key: args.key, value: val, found: val !== undefined, scope });
       }
       if (action === "set") {
         if (!args.key) return asToolError("MISSING_PARAMETER", "key é obrigatório", { parameter: "key" });
-        await git.setConfig(projectPath, args.key, args.value ?? "", scope);
+        await withRetry(() => git.setConfig(projectPath, args.key, args.value ?? "", scope), 3, "set-config");
         return asToolResult({ success: true, key: args.key, value: args.value ?? "", scope });
       }
       if (action === "unset") {
         if (!args.key) return asToolError("MISSING_PARAMETER", "key é obrigatório", { parameter: "key" });
-        await git.unsetConfig(projectPath, args.key, scope);
+        await withRetry(() => git.unsetConfig(projectPath, args.key, scope), 3, "unset-config");
         return asToolResult({ success: true, key: args.key, removed: true, scope });
       }
       if (action === "list") {
-        const items = await git.listConfig(projectPath, scope);
+        const items = await withRetry(() => git.listConfig(projectPath, scope), 3, "list-config");
         return asToolResult({ scope, configs: items, count: Object.keys(items).length });
       }
       return asToolError("VALIDATION_ERROR", `Ação '${action}' não suportada`, { availableActions: ["get", "set", "unset", "list"] });

package/src/tools/git-diff.js

@@ -1,6 +1,6 @@
 import Ajv from "ajv";
 import { asToolError, asToolResult, errorToResponse } from "../utils/errors.js";
-import { validateProjectPath } from "../utils/repoHelpers.js";
+import { validateProjectPath, withRetry } from "../utils/repoHelpers.js";
 
 const ajv = new Ajv({ allErrors: true });
 
@@ -80,10 +80,10 @@ EXEMPLOS:
     try {
       validateProjectPath(projectPath);
       if (action === "show") {
-        const diff = await git.diff(projectPath, {
+        const diff = await withRetry(() => git.diff(projectPath, {
           file: fileParam,
           context: args.context || 3
-        });
+        }), 3, "diff-show");
 
         if (!diff || diff.length === 0) {
           return asToolResult({
@@ -100,10 +100,10 @@ EXEMPLOS:
       }
 
       if (action === "compare") {
-        const diff = await git.diffCommits(projectPath, fromParam, toParam, {
+        const diff = await withRetry(() => git.diffCommits(projectPath, fromParam, toParam, {
           file: fileParam,
           context: args.context || 3
-        });
+        }), 3, "diff-compare");
 
         return asToolResult({
           from: fromParam,
@@ -115,7 +115,7 @@ EXEMPLOS:
       }
 
       if (action === "stat") {
-        const stats = await git.diffStats(projectPath, fromParam, toParam);
+        const stats = await withRetry(() => git.diffStats(projectPath, fromParam, toParam), 3, "diff-stat");
 
         return asToolResult({
           from: fromParam,

package/src/tools/git-files.js

@@ -1,6 +1,6 @@
 import Ajv from "ajv";
 import { asToolError, asToolResult, errorToResponse } from "../utils/errors.js";
-import { validateProjectPath } from "../utils/repoHelpers.js";
+import { validateProjectPath, withRetry } from "../utils/repoHelpers.js";
 
 const ajv = new Ajv({ allErrors: true });
 

package/src/tools/git-history.js

@@ -1,6 +1,6 @@
 import Ajv from "ajv";
 import { asToolError, asToolResult, errorToResponse } from "../utils/errors.js";
-import { validateProjectPath } from "../utils/repoHelpers.js";
+import { validateProjectPath, withRetry } from "../utils/repoHelpers.js";
 
 const ajv = new Ajv({ allErrors: true });
 
@@ -58,7 +58,7 @@ EXEMPLOS:
     try {
       validateProjectPath(projectPath);
       if (action === "log") {
-        const items = await git.log(projectPath, { ref: args.ref || "HEAD", maxCount: args.maxCount || 50 });
+        const items = await withRetry(() => git.log(projectPath, { ref: args.ref || "HEAD", maxCount: args.maxCount || 50 }), 3, "history-log");
         if (items.length === 0) {
           return asToolResult({ 
             commits: [], 

package/src/tools/git-ignore.js

@@ -61,7 +61,7 @@ EXEMPLOS:
     try {
       validateProjectPath(projectPath);
       if (action === "list") {
-        const items = await git.listGitignore(projectPath);
+        const items = await withRetry(() => git.listGitignore(projectPath), 3, "ignore-list");
         return asToolResult({ patterns: items, count: items.length, hasGitignore: items.length > 0 || true });
       }
       if (action === "create") {
@@ -71,21 +71,21 @@ EXEMPLOS:
             suggestion: "Forneça um array de padrões. Ex: ['node_modules/', '*.log', '.env']"
           });
         }
-        await git.createGitignore(projectPath, patterns);
+        await withRetry(() => git.createGitignore(projectPath, patterns), 3, "ignore-create");
         return asToolResult({ success: true, patterns, message: ".gitignore criado" });
       }
       if (action === "add") {
         if (patterns.length === 0) {
           return asToolError("MISSING_PARAMETER", "patterns é obrigatório", { parameter: "patterns" });
         }
-        await git.addToGitignore(projectPath, patterns);
+        await withRetry(() => git.addToGitignore(projectPath, patterns), 3, "ignore-add");
         return asToolResult({ success: true, added: patterns });
       }
       if (action === "remove") {
         if (patterns.length === 0) {
           return asToolError("MISSING_PARAMETER", "patterns é obrigatório", { parameter: "patterns" });
         }
-        await git.removeFromGitignore(projectPath, patterns);
+        await withRetry(() => git.removeFromGitignore(projectPath, patterns), 3, "ignore-remove");
         return asToolResult({ success: true, removed: patterns });
       }
       return asToolError("VALIDATION_ERROR", `Ação '${action}' não suportada`, { availableActions: ["list", "create", "add", "remove"] });

package/src/tools/git-issues.js

@@ -1,7 +1,7 @@
 import Ajv from "ajv";
 import axios from "axios";
 import { asToolError, asToolResult, errorToResponse } from "../utils/errors.js";
-import { getRepoNameFromPath, validateProjectPath } from "../utils/repoHelpers.js";
+import { getRepoNameFromPath, validateProjectPath, withRetry } from "../utils/repoHelpers.js";
 import { runBoth } from "../utils/providerExec.js";
 
 const ajv = new Ajv({ allErrors: true });
@@ -65,26 +65,26 @@ BOAS PRÁTICAS:
     try {
       if (args.action === "create") {
         if (!args.title) return asToolError("MISSING_PARAMETER", "title é obrigatório para criar issue", { parameter: "title" });
-        const out = await runBoth(pm, {
+        const out = await withRetry(() => runBoth(pm, {
           github: async (owner) => { const r = await pm.github.rest.issues.create({ owner, repo, title: args.title, body: args.body || "" }); return { ok: true, number: r.data.number, url: r.data.html_url }; },
           gitea: async (owner) => { const base = pm.giteaUrl.replace(/\/$/, ""); const r = await axios.post(`${base}/api/v1/repos/${owner}/${repo}/issues`, { title: args.title, body: args.body || "" }, { headers: { Authorization: `token ${pm.giteaToken}` } }); return { ok: true, number: r.data?.number }; }
-        });
+        }), 3, "issues-create");
         return asToolResult({ success: !!(out.github?.ok || out.gitea?.ok), title: args.title, providers: out });
       }
       if (args.action === "list") {
-        const out = await runBoth(pm, {
+        const out = await withRetry(() => runBoth(pm, {
           github: async (owner) => { const r = await pm.github.rest.issues.listForRepo({ owner, repo, state: "all", per_page: 30 }); return { ok: true, count: r.data.length, issues: r.data.slice(0, 10).map(i => ({ number: i.number, title: i.title, state: i.state })) }; },
           gitea: async (owner) => { const base = pm.giteaUrl.replace(/\/$/, ""); const r = await axios.get(`${base}/api/v1/repos/${owner}/${repo}/issues?state=all`, { headers: { Authorization: `token ${pm.giteaToken}` } }); return { ok: true, count: (r.data||[]).length, issues: (r.data||[]).slice(0, 10).map(i => ({ number: i.number, title: i.title, state: i.state })) }; }
-        });
+        }), 3, "issues-list");
         return asToolResult({ providers: out });
       }
       if (args.action === "comment") {
         if (!args.number) return asToolError("MISSING_PARAMETER", "number é obrigatório para comentar", { parameter: "number" });
         if (!args.body) return asToolError("MISSING_PARAMETER", "body é obrigatório para comentar", { parameter: "body" });
-        const out = await runBoth(pm, {
+        const out = await withRetry(() => runBoth(pm, {
           github: async (owner) => { await pm.github.rest.issues.createComment({ owner, repo, issue_number: args.number, body: args.body }); return { ok: true }; },
           gitea: async (owner) => { const base = pm.giteaUrl.replace(/\/$/, ""); await axios.post(`${base}/api/v1/repos/${owner}/${repo}/issues/${args.number}/comments`, { body: args.body }, { headers: { Authorization: `token ${pm.giteaToken}` } }); return { ok: true }; }
-        });
+        }), 3, "issues-comment");
         return asToolResult({ success: !!(out.github?.ok || out.gitea?.ok), issueNumber: args.number, providers: out });
       }
       return asToolError("VALIDATION_ERROR", `Ação '${args.action}' não suportada`, { availableActions: ["create", "list", "comment"] });

package/src/tools/git-merge.js

@@ -91,6 +91,16 @@ SQUASH:
           });
         }
         
+        // 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", {
@@ -99,21 +109,35 @@ SQUASH:
           });
         }
         
-        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`
-        });
+        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`, { 

package/src/tools/git-pulls.js

@@ -80,26 +80,26 @@ NOTA: O PR é criado em AMBOS os providers simultaneamente.`;
         const base = args.base;
         const title = args.title || `${head} -> ${base}`;
         const body = args.body || "";
-        const out = await runBoth(pm, {
+        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 }; }
-        });
+        }), 3, "pulls-create");
         return asToolResult({ success: !!(out.github?.ok || out.gitea?.ok), title, head, base, providers: out });
       }
       if (args.action === "list") {
-        const out = await runBoth(pm, {
+        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 })) }; }
-        });
+        }), 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 runBoth(pm, {
+        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 })) }; }
-        });
-        return asToolResult({ prNumber: args.number, providers: out });
+        }), 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) {

package/src/tools/git-remote.js

@@ -4,7 +4,7 @@ import fs from "node:fs";
 import path from "node:path";
 import archiver from "archiver";
 import { asToolError, asToolResult, errorToResponse, mapExternalError } from "../utils/errors.js";
-import { getRepoNameFromPath, validateProjectPath } from "../utils/repoHelpers.js";
+import { getRepoNameFromPath, validateProjectPath, withRetry } from "../utils/repoHelpers.js";
 import { runBoth } from "../utils/providerExec.js";
 
 /**

package/src/tools/git-reset.js

@@ -1,6 +1,6 @@
 import Ajv from "ajv";
 import { asToolError, asToolResult, errorToResponse } from "../utils/errors.js";
-import { validateProjectPath } from "../utils/repoHelpers.js";
+import { validateProjectPath, withRetry } from "../utils/repoHelpers.js";
 
 const ajv = new Ajv({ allErrors: true });
 
@@ -73,19 +73,19 @@ REFERÊNCIAS:
       }
       
       if (action === "soft") {
-        await git.resetSoft(projectPath, ref);
+        await withRetry(() => git.resetSoft(projectPath, ref), 3, "reset-soft");
         return asToolResult({ success: true, action: "soft", ref, message: "Commits desfeitos, mudanças mantidas staged" });
       }
       if (action === "mixed") {
-        await git.resetMixed(projectPath, ref);
+        await withRetry(() => git.resetMixed(projectPath, ref), 3, "reset-mixed");
         return asToolResult({ success: true, action: "mixed", ref, message: "Commits desfeitos, mudanças mantidas no working directory" });
       }
       if (action === "hard") {
-        await git.resetHard(projectPath, ref);
+        await withRetry(() => git.resetHard(projectPath, ref), 3, "reset-hard");
         return asToolResult({ success: true, action: "hard", ref, message: "⚠️ Reset hard executado - mudanças descartadas" });
       }
       if (action === "hard-clean") {
-        const result = await git.resetHardClean(projectPath, ref);
+        const result = await withRetry(() => git.resetHardClean(projectPath, ref), 3, "reset-hard-clean");
         return asToolResult({ 
           success: true, 
           action: "hard-clean", 

package/src/tools/git-stash.js

@@ -67,7 +67,7 @@ AÇÕES:
     try {
       validateProjectPath(projectPath);
       if (action === "list") {
-        const items = await git.listStash(projectPath);
+        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,
@@ -79,7 +79,7 @@ AÇÕES:
         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);
+        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") {
@@ -87,7 +87,7 @@ AÇÕES:
         if (items.length === 0) {
           return asToolError("STASH_NOT_FOUND", "Nenhum stash disponível", { availableStashes: [] });
         }
-        await git.applyStash(projectPath, args.ref || "stash@{0}");
+        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") {
@@ -95,7 +95,7 @@ AÇÕES:
         if (items.length === 0) {
           return asToolError("STASH_NOT_FOUND", "Nenhum stash disponível", { availableStashes: [] });
         }
-        await git.popStash(projectPath, args.ref || "stash@{0}");
+        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") {

package/src/tools/git-sync.js

@@ -1,6 +1,6 @@
 import Ajv from "ajv";
 import { asToolError, asToolResult, errorToResponse } from "../utils/errors.js";
-import { validateProjectPath } from "../utils/repoHelpers.js";
+import { validateProjectPath, withRetry } from "../utils/repoHelpers.js";
 
 const ajv = new Ajv({ allErrors: true });
 
@@ -58,7 +58,11 @@ NOTA: Se pull falhar com conflito, resolva manualmente e faça commit.`;
       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 => git.fetch(projectPath, r, branch).then(() => ({ remote: r, ok: true })).catch(e => ({ remote: r, ok: false, error: String(e?.message || e) })));
+        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);
@@ -71,17 +75,48 @@ NOTA: Se pull falhar com conflito, resolva manualmente e faça commit.`;
         });
       }
       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 => git.pull(projectPath, r, branch).then(() => ({ remote: r, ok: true })).catch(e => ({ remote: r, ok: false, error: String(e?.message || e) })));
+        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. Use git-remote ensure para configurar." : `Pull de ${successful.length} remote(s) concluído`
+          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"] });

package/src/tools/git-tags.js

@@ -1,6 +1,6 @@
 import Ajv from "ajv";
 import { asToolError, asToolResult, errorToResponse } from "../utils/errors.js";
-import { validateProjectPath } from "../utils/repoHelpers.js";
+import { validateProjectPath, withRetry } from "../utils/repoHelpers.js";
 
 const ajv = new Ajv({ allErrors: true });
 
@@ -72,7 +72,7 @@ FLUXO TÍPICO:
         if (existing.includes(args.tag)) {
           return asToolError("TAG_ALREADY_EXISTS", `Tag '${args.tag}' já existe`, { tag: args.tag, existingTags: existing });
         }
-        await git.createTag(projectPath, args.tag, args.ref || "HEAD", args.message);
+        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") {
@@ -81,7 +81,7 @@ FLUXO TÍPICO:
         if (!existing.includes(args.tag)) {
           return asToolError("TAG_NOT_FOUND", `Tag '${args.tag}' não encontrada`, { tag: args.tag, existingTags: existing });
         }
-        await git.deleteTag(projectPath, args.tag);
+        await withRetry(() => git.deleteTag(projectPath, args.tag), 3, "delete-tag");
         return asToolResult({ success: true, tag: args.tag, deleted: true });
       }
       if (action === "push") {
@@ -91,8 +91,8 @@ FLUXO TÍPICO:
           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([
-          git.pushTag(projectPath, "github", args.tag),
-          git.pushTag(projectPath, "gitea", args.tag)
+          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 = [];

package/src/tools/git-workflow.js

@@ -1,6 +1,8 @@
 import Ajv from "ajv";
+import fs from "fs";
+import path from "path";
 import { MCPError, asToolError, asToolResult, errorToResponse, createError } from "../utils/errors.js";
-import { getRepoNameFromPath, detectProjectType, GITIGNORE_TEMPLATES, validateProjectPath } from "../utils/repoHelpers.js";
+import { getRepoNameFromPath, detectProjectType, GITIGNORE_TEMPLATES, validateProjectPath, withRetry } from "../utils/repoHelpers.js";
 
 const ajv = new Ajv({ allErrors: true });
 
@@ -8,13 +10,13 @@ export function createGitWorkflowTool(pm, git) {
   const inputSchema = {
     type: "object",
     properties: {
-      projectPath: { 
-        type: "string", 
-        description: "Caminho absoluto do diretório do projeto (ex: 'C:/Users/user/projeto' ou '/home/user/projeto')" 
+      projectPath: {
+        type: "string",
+        description: "Caminho absoluto do diretório do projeto (ex: 'C:/Users/user/projeto' ou '/home/user/projeto')"
       },
-      action: { 
-        type: "string", 
-        enum: ["init", "status", "add", "remove", "commit", "push", "ensure-remotes", "clean", "update"],
+      action: {
+        type: "string",
+        enum: ["init", "status", "add", "remove", "commit", "push", "ensure-remotes", "clean"],
         description: `Ação a executar:
 - init: Inicializa repositório git local E cria repos no GitHub/Gitea automaticamente
 - status: Retorna arquivos modificados, staged, untracked (use ANTES de commit para ver o que mudou)
@@ -23,20 +25,19 @@ export function createGitWorkflowTool(pm, git) {
 - commit: Cria commit com os arquivos staged (use DEPOIS de add)
 - push: Envia commits para GitHub E Gitea em paralelo (use DEPOIS de commit)
 - ensure-remotes: Configura remotes GitHub e Gitea (use se push falhar por falta de remote)
-- clean: Remove arquivos não rastreados do working directory
-- update: Atualiza projeto completo: init (se necessário), add, commit, ensure-remotes e push`
+- clean: Remove arquivos não rastreados do working directory`
       },
-      files: { 
-        type: "array", 
+      files: {
+        type: "array",
         items: { type: "string" },
         description: "Lista de arquivos para add/remove. Use ['.'] para todos os arquivos. Ex: ['src/index.js', 'package.json']"
       },
-      message: { 
+      message: {
         type: "string",
-        description: "Mensagem do commit. Obrigatório para action='commit'. Opcional para action='update' (se não fornecido, usa mensagem padrão). Ex: 'feat: adiciona nova funcionalidade'"
+        description: "Mensagem do commit. Obrigatório para action='commit'. Ex: 'feat: adiciona nova funcionalidade'"
       },
-      force: { 
-        type: "boolean", 
+      force: {
+        type: "boolean",
         description: "Force push (use apenas se push normal falhar com erro de histórico divergente). Default: false"
       },
       createGitignore: {
@@ -48,7 +49,7 @@ export function createGitWorkflowTool(pm, git) {
         description: "Se true, repositório será PÚBLICO. Default: false (privado). Aplica-se a action='init' e 'ensure-remotes'"
       },
       dryRun: {
-        type: "boolean", 
+        type: "boolean",
         description: "Se true, simula a operação sem executar (útil para testes). Default: false"
       }
     },
@@ -72,7 +73,6 @@ QUANDO USAR CADA ACTION:
 - init: Apenas uma vez, para novos projetos (cria .gitignore automaticamente)
 - ensure-remotes: Se push falhar por falta de configuração
 - clean: Limpar arquivos não rastreados
-- update: Para atualizar projeto completo (init + add + commit + push) - mais rápido que fazer cada ação separadamente
 
 EXEMPLOS DE USO:
 • Iniciar projeto: { "projectPath": "/path/to/project", "action": "init" }
@@ -90,29 +90,29 @@ EXEMPLOS DE USO:
     try {
       // #region agent log
       if (process.env.DEBUG_AGENT_LOG) {
-        fetch('http://127.0.0.1:8243/ingest/a7114eec-653b-43b0-9f09-7073baee17bf',{method:'POST',headers:{'Content-Type':'application/json'},body:JSON.stringify({sessionId:'debug-session',runId:'run1',hypothesisId:'H1',location:'git-workflow.js:handle-entry',message:'handle start',data:{action,projectPath},timestamp:Date.now()})}).catch(()=>{});
+        fetch('http://127.0.0.1:8243/ingest/a7114eec-653b-43b0-9f09-7073baee17bf', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ sessionId: 'debug-session', runId: 'run1', hypothesisId: 'H1', location: 'git-workflow.js:handle-entry', message: 'handle start', data: { action, projectPath }, timestamp: Date.now() }) }).catch(() => { });
       }
       // #endregion
 
       validateProjectPath(projectPath);
       // #region agent log
       if (process.env.DEBUG_AGENT_LOG) {
-        fetch('http://127.0.0.1:8243/ingest/a7114eec-653b-43b0-9f09-7073baee17bf',{method:'POST',headers:{'Content-Type':'application/json'},body:JSON.stringify({sessionId:'debug-session',runId:'run1',hypothesisId:'H1',location:'git-workflow.js:handle-validated',message:'projectPath validated',data:{action},timestamp:Date.now()})}).catch(()=>{});
+        fetch('http://127.0.0.1:8243/ingest/a7114eec-653b-43b0-9f09-7073baee17bf', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ sessionId: 'debug-session', runId: 'run1', hypothesisId: 'H1', location: 'git-workflow.js:handle-validated', message: 'projectPath validated', data: { action }, timestamp: Date.now() }) }).catch(() => { });
       }
       // #endregion
       if (action === "init") {
         if (args.dryRun) {
-          return asToolResult({ 
-            success: true, 
+          return asToolResult({
+            success: true,
             dryRun: true,
             message: "DRY RUN: Repositório seria inicializado localmente e nos providers",
             repoName: getRepoNameFromPath(projectPath),
             gitignoreCreated: shouldCreateGitignore
           });
         }
-        
+
         await git.init(projectPath);
-        
+
         // Criar .gitignore baseado no tipo de projeto
         const shouldCreateGitignore = args.createGitignore !== false;
         let gitignoreCreated = false;
@@ -122,12 +122,12 @@ EXEMPLOS DE USO:
           await git.createGitignore(projectPath, patterns);
           gitignoreCreated = true;
         }
-        
+
         const repo = getRepoNameFromPath(projectPath);
         const isPublic = args.isPublic === true; // Default: privado
         const ensured = await pm.ensureRepos({ repoName: repo, createIfMissing: true, isPublic });
-        return asToolResult({ 
-          success: true, 
+        return asToolResult({
+          success: true,
           ensured,
           isPrivate: !isPublic,
           gitignoreCreated,
@@ -138,24 +138,24 @@ EXEMPLOS DE USO:
         const st = await git.status(projectPath);
         // #region agent log
         if (process.env.DEBUG_AGENT_LOG) {
-          fetch('http://127.0.0.1:8243/ingest/a7114eec-653b-43b0-9f09-7073baee17bf',{method:'POST',headers:{'Content-Type':'application/json'},body:JSON.stringify({sessionId:'debug-session',runId:'run1',hypothesisId:'H2',location:'git-workflow.js:status',message:'status result',data:{modified:st.modified.length,created:st.created.length,deleted:st.deleted.length,notAdded:st.not_added.length,isClean:st.isClean},timestamp:Date.now()})}).catch(()=>{});
+          fetch('http://127.0.0.1:8243/ingest/a7114eec-653b-43b0-9f09-7073baee17bf', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ sessionId: 'debug-session', runId: 'run1', hypothesisId: 'H2', location: 'git-workflow.js:status', message: 'status result', data: { modified: st.modified.length, created: st.created.length, deleted: st.deleted.length, notAdded: st.not_added.length, isClean: st.isClean }, timestamp: Date.now() }) }).catch(() => { });
         }
         // #endregion
-        
+
         if (args.dryRun) {
-          return asToolResult({ 
-            success: true, 
+          return asToolResult({
+            success: true,
             dryRun: true,
             message: "DRY RUN: Status seria verificado",
             ...st
           });
         }
-        
+
         // Adicionar contexto para AI Agent decidir próximo passo
         const hasUnstaged = st.not_added?.length > 0 || st.modified?.length > 0 || st.created?.length > 0;
         const hasStaged = st.staged?.length > 0;
         const hasConflicts = st.conflicted?.length > 0;
-        
+
         let _aiContext = {
           needsAdd: hasUnstaged && !hasStaged,
           readyToCommit: hasStaged && !hasConflicts,
@@ -163,7 +163,7 @@ EXEMPLOS DE USO:
           isClean: st.isClean,
           suggestedAction: null
         };
-        
+
         if (hasConflicts) {
           _aiContext.suggestedAction = "Resolva os conflitos manualmente antes de continuar";
         } else if (hasStaged) {
@@ -173,21 +173,21 @@ EXEMPLOS DE USO:
         } else {
           _aiContext.suggestedAction = "Working tree limpa. Modifique arquivos ou use action='push' se há commits pendentes";
         }
-        
+
         return asToolResult({ ...st, _aiContext }, { tool: 'workflow', action: 'status' });
       }
       if (action === "add") {
         const files = Array.isArray(args.files) && args.files.length ? args.files : ["."];
-        
+
         if (args.dryRun) {
-          return asToolResult({ 
-            success: true, 
+          return asToolResult({
+            success: true,
             dryRun: true,
             message: `DRY RUN: Arquivos seriam adicionados: ${files.join(", ")}`,
             files
           });
         }
-        
+
         await git.add(projectPath, files);
         return asToolResult({ success: true, files }, { tool: 'workflow', action: 'add' });
       }
@@ -200,19 +200,19 @@ EXEMPLOS DE USO:
         if (!args.message) {
           return asToolError("MISSING_PARAMETER", "message é obrigatório para commit", { parameter: "message" });
         }
-        
+
         if (args.dryRun) {
-          return asToolResult({ 
-            success: true, 
+          return asToolResult({
+            success: true,
             dryRun: true,
             message: `DRY RUN: Commit seria criado com mensagem: "${args.message}"`
           });
         }
-        
+
         const sha = await git.commit(projectPath, args.message);
         // #region agent log
         if (process.env.DEBUG_AGENT_LOG) {
-          fetch('http://127.0.0.1:8243/ingest/a7114eec-653b-43b0-9f09-7073baee17bf',{method:'POST',headers:{'Content-Type':'application/json'},body:JSON.stringify({sessionId:'debug-session',runId:'run1',hypothesisId:'H3',location:'git-workflow.js:commit',message:'commit created',data:{sha,message:args.message},timestamp:Date.now()})}).catch(()=>{});
+          fetch('http://127.0.0.1:8243/ingest/a7114eec-653b-43b0-9f09-7073baee17bf', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ sessionId: 'debug-session', runId: 'run1', hypothesisId: 'H3', location: 'git-workflow.js:commit', message: 'commit created', data: { sha, message: args.message }, timestamp: Date.now() }) }).catch(() => { });
         }
         // #endregion
         return asToolResult({ success: true, sha, message: args.message }, { tool: 'workflow', action: 'commit' });
@@ -220,19 +220,19 @@ EXEMPLOS DE USO:
       if (action === "clean") {
         if (args.dryRun) {
           const result = await git.cleanUntracked(projectPath);
-          return asToolResult({ 
-            success: true, 
+          return asToolResult({
+            success: true,
             dryRun: true,
             message: `DRY RUN: ${result.cleaned.length} arquivo(s) seriam removidos`,
             wouldClean: result.cleaned
           });
         }
-        
+
         const result = await git.cleanUntracked(projectPath);
-        return asToolResult({ 
-          success: true, 
+        return asToolResult({
+          success: true,
           ...result,
-          message: result.cleaned.length > 0 
+          message: result.cleaned.length > 0
             ? `${result.cleaned.length} arquivo(s) não rastreados removidos`
             : "Nenhum arquivo para limpar"
         });
@@ -240,7 +240,7 @@ EXEMPLOS DE USO:
       if (action === "ensure-remotes") {
         const repo = getRepoNameFromPath(projectPath);
         const isPublic = args.isPublic === true; // Default: privado
-        
+
         if (args.dryRun) {
           const ensured = await pm.ensureRepos({ repoName: repo, createIfMissing: false, isPublic }); // Don't create for dry run
           const ghOwner = await pm.getGitHubOwner();
@@ -248,9 +248,9 @@ EXEMPLOS DE USO:
           const githubUrl = ghOwner ? `https://github.com/${ghOwner}/${repo}.git` : "";
           const base = pm.giteaUrl?.replace(/\/$/, "") || "";
           const giteaUrl = geOwner && base ? `${base}/${geOwner}/${repo}.git` : "";
-          
-          return asToolResult({ 
-            success: true, 
+
+          return asToolResult({
+            success: true,
             dryRun: true,
             message: "DRY RUN: Remotes seriam configurados",
             repo,
@@ -259,7 +259,7 @@ EXEMPLOS DE USO:
             ensured
           });
         }
-        
+
         const ensured = await pm.ensureRepos({ repoName: repo, createIfMissing: true, isPublic });
         const ghOwner = await pm.getGitHubOwner();
         const geOwner = await pm.getGiteaOwner();
@@ -273,120 +273,28 @@ EXEMPLOS DE USO:
       if (action === "push") {
         const branch = await git.getCurrentBranch(projectPath);
         const force = !!args.force;
-        
+
         if (args.dryRun) {
-          return asToolResult({ 
-            success: true, 
+          return asToolResult({
+            success: true,
             dryRun: true,
             message: `DRY RUN: Push seria executado na branch '${branch}'${force ? ' (force)' : ''}`,
             branch,
             force
           });
         }
+
+        // Retry logic for push (often fails due to network or concurrent updates)
+        const result = await withRetry(
+          () => git.pushParallel(projectPath, branch, force),
+          3,
+          "push"
+        );
         
-        const result = await git.pushParallel(projectPath, branch, force);
         return asToolResult({ success: true, branch, ...result });
       }
-      if (action === "update") {
-        if (args.dryRun) {
-          return asToolResult({ 
-            success: true, 
-            dryRun: true,
-            message: "DRY RUN: Update completo seria executado (init se necessário, add, commit, push)"
-          });
-        }
-
-        const results = {
-          init: null,
-          ensureRemotes: null,
-          add: null,
-          commit: null,
-          push: null
-        };
-
-        const repo = getRepoNameFromPath(projectPath);
-        const isPublic = args.isPublic === true;
-
-        // 1. Verificar se é repo Git, se não for, fazer init
-        const isRepo = await git.isRepo(projectPath).catch(() => false);
-        if (!isRepo) {
-          await git.init(projectPath);
-          
-          // Criar .gitignore baseado no tipo de projeto
-          const shouldCreateGitignore = args.createGitignore !== false;
-          if (shouldCreateGitignore) {
-            const projectType = detectProjectType(projectPath);
-            const patterns = GITIGNORE_TEMPLATES[projectType] || GITIGNORE_TEMPLATES.general;
-            await git.createGitignore(projectPath, patterns);
-          }
-          
-          const ensured = await pm.ensureRepos({ repoName: repo, createIfMissing: true, isPublic });
-          results.init = { success: true, ensured, isPrivate: !isPublic, gitignoreCreated: shouldCreateGitignore };
-        } else {
-          results.init = { success: true, skipped: true, message: "Repositório já existe" };
-        }
-
-        // 2. Garantir remotes configurados (sempre verifica/configura)
-        const ensured = await pm.ensureRepos({ repoName: repo, createIfMissing: true, isPublic });
-        const ghOwner = await pm.getGitHubOwner();
-        const geOwner = await pm.getGiteaOwner();
-        const githubUrl = ghOwner ? `https://github.com/${ghOwner}/${repo}.git` : "";
-        const base = pm.giteaUrl?.replace(/\/$/, "") || "";
-        const giteaUrl = geOwner && base ? `${base}/${geOwner}/${repo}.git` : "";
-        await git.ensureRemotes(projectPath, { githubUrl, giteaUrl });
-        const remotes = await git.listRemotes(projectPath);
-        results.ensureRemotes = { success: true, ensured, remotes };
-
-        // 3. Verificar status e fazer add se necessário
-        const status = await git.status(projectPath);
-        if (!status.isClean || status.modified?.length > 0 || status.created?.length > 0 || status.notAdded?.length > 0) {
-          await git.add(projectPath, ["."]);
-          results.add = { success: true, files: ["."] };
-        } else {
-          results.add = { success: true, skipped: true, message: "Nenhum arquivo para adicionar" };
-        }
-
-        // 4. Verificar se há algo staged e fazer commit
-        const statusAfterAdd = await git.status(projectPath);
-        if (statusAfterAdd.staged?.length > 0) {
-          // Gerar mensagem padrão se não fornecida
-          const commitMessage = args.message || `Update: ${new Date().toISOString().split('T')[0]} - ${statusAfterAdd.staged.length} arquivo(s) modificado(s)`;
-          const sha = await git.commit(projectPath, commitMessage);
-          results.commit = { success: true, sha, message: commitMessage };
-        } else {
-          results.commit = { success: true, skipped: true, message: "Nenhum arquivo staged para commit" };
-        }
-
-        // 5. Fazer push (só se houver commits para enviar)
-        const branch = await git.getCurrentBranch(projectPath);
-        const force = !!args.force;
-        try {
-          const pushResult = await git.pushParallel(projectPath, branch, force);
-          results.push = { success: true, branch, ...pushResult };
-        } catch (pushError) {
-          // Se push falhar mas não houver commits, não é erro crítico
-          if (results.commit?.skipped) {
-            results.push = { success: true, skipped: true, message: "Nenhum commit para enviar" };
-          } else {
-            throw pushError;
-          }
-        }
-
-        // Resumo final
-        const allSuccess = Object.values(results).every(r => r?.success !== false);
-        const stepsExecuted = Object.entries(results)
-          .filter(([_, r]) => r && !r.skipped)
-          .map(([step, _]) => step);
-
-        return asToolResult({ 
-          success: allSuccess, 
-          message: `Update completo executado: ${stepsExecuted.join(" → ")}`,
-          results,
-          stepsExecuted
-        }, { tool: 'workflow', action: 'update' });
-      }
-      return asToolError("VALIDATION_ERROR", `Ação '${action}' não suportada`, { 
-        availableActions: ["init", "status", "add", "remove", "commit", "push", "ensure-remotes", "clean", "update"],
+      return asToolError("VALIDATION_ERROR", `Ação '${action}' não suportada`, {
+        availableActions: ["init", "status", "add", "remove", "commit", "push", "ensure-remotes", "clean"],
         suggestion: "Use uma das actions disponíveis"
       });
     } catch (e) {

package/src/utils/gitAdapter.js

@@ -2,7 +2,7 @@ import { spawn } from "node:child_process";
 import fs from "node:fs";
 import path from "node:path";
 import { MCPError, createError, mapExternalError } from "./errors.js";
-import { getRepoNameFromPath, getProvidersEnv } from "./repoHelpers.js";
+import { getRepoNameFromPath, getProvidersEnv, findGitRoot } from "./repoHelpers.js";
 
 // Common locations for Git on Windows, Linux, and macOS
 const GIT_CANDIDATES = [

package/src/utils/repoHelpers.js

@@ -66,6 +66,26 @@ export function validateFilePath(projectPath, filePath) {
   return absoluteFile;
 }
 
+/**
+ * Encontra a raiz do repositório Git subindo a árvore de diretórios
+ * @param {string} startDir - Diretório inicial
+ * @returns {string|null} Caminho da raiz do repo ou null se não encontrado
+ */
+export function findGitRoot(startDir) {
+  let current = path.resolve(startDir);
+  const root = path.parse(current).root;
+
+  while (true) {
+    if (fs.existsSync(path.join(current, ".git"))) {
+      return current;
+    }
+    if (current === root) {
+      return null;
+    }
+    current = path.dirname(current);
+  }
+}
+
 export function getEnv(key) {
   const v = process.env[key];
   return v === undefined ? "" : String(v);
@@ -158,3 +178,39 @@ export function detectProjectType(projectPath) {
   return "general";
 }
 
+/**
+ * Executa uma operação com retries exponenciais
+ * @param {Function} operation - Função assíncrona a executar
+ * @param {number} maxRetries - Número máximo de tentativas
+ * @param {string} context - Contexto para logs
+ * @returns {Promise<any>} Resultado da operação
+ */
+export async function withRetry(operation, maxRetries = 3, context = "") {
+  let lastError;
+  for (let i = 0; i < maxRetries; i++) {
+    try {
+      return await operation();
+    } catch (e) {
+      lastError = e;
+      const msg = e.message || String(e);
+      // Retry on network errors, lock files, or timeouts
+      const isRetryable = msg.includes("lock") || 
+                          msg.includes("network") || 
+                          msg.includes("resolve host") || 
+                          msg.includes("timeout") || 
+                          msg.includes("connection") ||
+                          msg.includes("ECONNRESET") ||
+                          msg.includes("ETIMEDOUT");
+      
+      if (!isRetryable && i === 0) throw e; // Fail fast if not retryable and first attempt
+      
+      if (i < maxRetries - 1) {
+        const delay = 2000 * Math.pow(2, i);
+        console.warn(`[${context}] Attempt ${i + 1} failed, retrying in ${delay}ms... Error: ${msg}`);
+        await new Promise(r => setTimeout(r, delay));
+      }
+    }
+  }
+  throw lastError;
+}
+