@andrebuzeli/git-mcp 12.0.0 → 13.6.0

package/src/utils/gitAdapter.js

@@ -2,8 +2,9 @@ import * as git from "isomorphic-git";
 import fs from "node:fs";
 import path from "node:path";
 import http from "isomorphic-git/http/node";
-import { MCPError } from "./errors.js";
+import { MCPError, createError, mapExternalError } from "./errors.js";
 import { getProvidersEnv } from "./repoHelpers.js";
+import { withRetry } from "./retry.js";
 
 export class GitAdapter {
   constructor(providerManager) {
@@ -90,27 +91,409 @@ export class GitAdapter {
   getAuth(remoteUrl) {
     const { githubToken, giteaToken } = getProvidersEnv();
     if (remoteUrl.includes("github.com")) {
-      if (!githubToken) throw new MCPError("AUTH", "GITHUB_TOKEN ausente");
+      if (!githubToken) throw createError("AUTH_GITHUB_INVALID", { message: "GITHUB_TOKEN não configurado" });
       return () => ({ username: githubToken, password: "x-oauth-basic" });
     }
     if (giteaToken) return () => ({ username: "git", password: giteaToken });
-    throw new MCPError("AUTH", "GITEA_TOKEN ausente");
+    throw createError("AUTH_GITEA_INVALID", { message: "GITEA_TOKEN não configurado" });
   }
 
-  async pushOne(dir, remote, branch) {
+  async pushOne(dir, remote, branch, force = false) {
     const remotes = await git.listRemotes({ fs, dir });
     const info = remotes.find(r => r.remote === remote);
-    if (!info) throw new MCPError("REMOTE", `Remote '${remote}' não encontrado`);
+    if (!info) {
+      const available = remotes.map(r => r.remote).join(", ");
+      throw createError("REMOTE_NOT_FOUND", { 
+        message: `Remote '${remote}' não encontrado`, 
+        remote, 
+        availableRemotes: available || "nenhum" 
+      });
+    }
     const onAuth = this.getAuth(info.url);
     const ref = branch.startsWith("refs/") ? branch : `refs/heads/${branch}`;
-    await git.push({ fs, http, dir, remote, ref, remoteRef: ref, onAuth });
+    try {
+      await withRetry(() => git.push({ fs, http, dir, remote, ref, remoteRef: ref, onAuth, force }));
+    } catch (e) {
+      if (e.message?.includes("non-fast-forward") || e.message?.includes("rejected")) {
+        throw createError("PUSH_REJECTED", { message: e.message, remote, branch });
+      }
+      throw mapExternalError(e, { type: "push", remote, branch });
+    }
   }
 
-  async pushParallel(dir, branch) {
+  async pushParallel(dir, branch, force = false) {
     const remotes = await git.listRemotes({ fs, dir });
     const targets = remotes.filter(r => ["github", "gitea"].includes(r.remote));
-    if (targets.length === 0) throw new MCPError("REMOTE", "Nenhum remote github/gitea configurado");
-    await Promise.all(targets.map(t => this.pushOne(dir, t.remote, branch)));
+    if (targets.length === 0) {
+      throw createError("REMOTE_NOT_FOUND", { 
+        message: "Nenhum remote github/gitea configurado",
+        availableRemotes: remotes.map(r => r.remote).join(", ") || "nenhum",
+        suggestion: "Use action='ensure-remotes' para configurar os remotes"
+      });
+    }
+    const results = await Promise.allSettled(targets.map(t => this.pushOne(dir, t.remote, branch, force)));
+    const errors = results.filter(r => r.status === "rejected");
+    if (errors.length === targets.length) {
+      throw createError("PUSH_REJECTED", { 
+        message: "Push falhou para todos os remotes",
+        errors: errors.map(e => e.reason?.message || String(e.reason))
+      });
+    }
+    return { 
+      pushed: targets.filter((t, i) => results[i].status === "fulfilled").map(t => t.remote),
+      failed: errors.map((e, i) => ({ remote: targets[i]?.remote, error: e.reason?.message }))
+    };
+  }
+
+  // ============ BRANCHES ============
+  async listBranches(dir, remote = false) {
+    if (remote) {
+      const remotes = await git.listRemotes({ fs, dir });
+      const branches = [];
+      for (const r of remotes) {
+        try {
+          const refs = await git.listServerRefs({ http, url: r.url, prefix: "refs/heads/", onAuth: this.getAuth(r.url) });
+          for (const ref of refs) branches.push(`${r.remote}/${ref.ref.replace("refs/heads/", "")}`);
+        } catch { /* ignore */ }
+      }
+      return branches;
+    }
+    return await git.listBranches({ fs, dir });
+  }
+
+  async createBranch(dir, name, ref = "HEAD") {
+    const oid = await git.resolveRef({ fs, dir, ref });
+    await git.branch({ fs, dir, ref: name, checkout: false });
+  }
+
+  async deleteBranch(dir, name, force = false) {
+    await git.deleteBranch({ fs, dir, ref: name });
+  }
+
+  async renameBranch(dir, oldName, newName) {
+    await git.renameBranch({ fs, dir, oldref: oldName, ref: newName });
+  }
+
+  async checkout(dir, ref) {
+    await git.checkout({ fs, dir, ref, force: true });
+  }
+
+  // ============ TAGS ============
+  async listTags(dir) {
+    return await git.listTags({ fs, dir });
+  }
+
+  async createTag(dir, tag, ref = "HEAD", message = "") {
+    const oid = await git.resolveRef({ fs, dir, ref });
+    if (message) {
+      const author = await this.getAuthor(dir);
+      await git.tag({ fs, dir, ref: tag, object: oid, tagger: { name: author.name, email: author.email }, message });
+    } else {
+      await git.tag({ fs, dir, ref: tag, object: oid });
+    }
+  }
+
+  async deleteTag(dir, tag) {
+    await git.deleteTag({ fs, dir, ref: tag });
+  }
+
+  async pushTag(dir, remote, tag) {
+    const remotes = await git.listRemotes({ fs, dir });
+    const info = remotes.find(r => r.remote === remote);
+    if (!info) throw new MCPError("REMOTE", `Remote '${remote}' não encontrado`);
+    const onAuth = this.getAuth(info.url);
+    await git.push({ fs, http, dir, remote, ref: `refs/tags/${tag}`, remoteRef: `refs/tags/${tag}`, onAuth });
+  }
+
+  // ============ STASH (simulated via JSON file) ============
+  _getStashFile(dir) {
+    return path.join(dir, ".git", "stash.json");
+  }
+
+  async listStash(dir) {
+    const stashFile = this._getStashFile(dir);
+    if (!fs.existsSync(stashFile)) return [];
+    try {
+      return JSON.parse(fs.readFileSync(stashFile, "utf8"));
+    } catch { return []; }
+  }
+
+  async saveStash(dir, message = "WIP", includeUntracked = false) {
+    const st = await this.status(dir);
+    if (st.isClean && !includeUntracked) {
+      throw createError("NOTHING_TO_STASH", { 
+        message: "Working tree limpa, nada para stash",
+        status: st
+      });
+    }
+    
+    // Salva arquivos modificados/adicionados
+    const filesToSave = [...st.not_added, ...st.modified, ...st.created];
+    const stashData = { message, timestamp: Date.now(), files: {} };
+    
+    for (const file of filesToSave) {
+      const fullPath = path.join(dir, file);
+      if (fs.existsSync(fullPath)) {
+        stashData.files[file] = fs.readFileSync(fullPath, "utf8");
+      }
+    }
+    
+    // Carrega stashes existentes
+    const stashes = await this.listStash(dir);
+    stashes.unshift(stashData);
+    
+    // Salva lista de stashes
+    fs.writeFileSync(this._getStashFile(dir), JSON.stringify(stashes, null, 2));
+    
+    // Restaura arquivos para estado HEAD mantendo a branch atual
+    const currentBranch = await this.getCurrentBranch(dir);
+    if (currentBranch && currentBranch !== "HEAD") {
+      await git.checkout({ fs, dir, ref: currentBranch, force: true });
+    } else {
+      // Se estiver em detached HEAD, usa o SHA atual
+      const oid = await git.resolveRef({ fs, dir, ref: "HEAD" });
+      await git.checkout({ fs, dir, ref: oid, force: true });
+    }
+  }
+
+  async applyStash(dir, ref = "stash@{0}") {
+    const stashes = await this.listStash(dir);
+    const idx = Number(ref.match(/\{(\d+)\}/)?.[1] || 0);
+    const stash = stashes[idx];
+    if (!stash) {
+      throw createError("STASH_NOT_FOUND", { 
+        message: `Stash '${ref}' não encontrado`,
+        requestedIndex: idx,
+        availableStashes: stashes.length,
+        stashList: stashes.map((s, i) => `stash@{${i}}: ${s.message}`).slice(0, 5)
+      });
+    }
+    
+    // Restaura arquivos do stash
+    for (const [file, content] of Object.entries(stash.files)) {
+      const fullPath = path.join(dir, file);
+      fs.mkdirSync(path.dirname(fullPath), { recursive: true });
+      fs.writeFileSync(fullPath, content);
+    }
+  }
+
+  async popStash(dir, ref = "stash@{0}") {
+    await this.applyStash(dir, ref);
+    await this.dropStash(dir, ref);
+  }
+
+  async dropStash(dir, ref = "stash@{0}") {
+    const stashes = await this.listStash(dir);
+    const idx = Number(ref.match(/\{(\d+)\}/)?.[1] || 0);
+    stashes.splice(idx, 1);
+    
+    if (stashes.length === 0) {
+      const stashFile = this._getStashFile(dir);
+      if (fs.existsSync(stashFile)) fs.unlinkSync(stashFile);
+    } else {
+      fs.writeFileSync(this._getStashFile(dir), JSON.stringify(stashes, null, 2));
+    }
+  }
+
+  async clearStash(dir) {
+    const stashFile = this._getStashFile(dir);
+    if (fs.existsSync(stashFile)) fs.unlinkSync(stashFile);
+  }
+
+  // ============ CONFIG ============
+  async getConfig(dir, key, scope = "local") {
+    return await git.getConfig({ fs, dir, path: key }).catch(() => undefined);
+  }
+
+  async setConfig(dir, key, value, scope = "local") {
+    await git.setConfig({ fs, dir, path: key, value });
+  }
+
+  async unsetConfig(dir, key, scope = "local") {
+    // isomorphic-git não tem unset, então setamos para undefined
+    const configPath = path.join(dir, ".git", "config");
+    if (!fs.existsSync(configPath)) return;
+    let content = fs.readFileSync(configPath, "utf8");
+    const regex = new RegExp(`^\\s*${key.split(".").pop()}\\s*=.*$`, "gm");
+    content = content.replace(regex, "");
+    fs.writeFileSync(configPath, content);
+  }
+
+  async listConfig(dir, scope = "local") {
+    const configPath = path.join(dir, ".git", "config");
+    const items = {};
+    if (!fs.existsSync(configPath)) return items;
+    const content = fs.readFileSync(configPath, "utf8");
+    let section = "";
+    for (const line of content.split("\n")) {
+      const secMatch = line.match(/^\[([^\]]+)\]$/);
+      if (secMatch) { section = secMatch[1].replace(/\s+"/g, ".").replace(/"/g, ""); continue; }
+      const kvMatch = line.match(/^\s*(\w+)\s*=\s*(.*)$/);
+      if (kvMatch && section) items[`${section}.${kvMatch[1]}`] = kvMatch[2].trim();
+    }
+    return items;
+  }
+
+  // ============ FILES ============
+  async listFiles(dir, ref = "HEAD") {
+    const oid = await git.resolveRef({ fs, dir, ref });
+    const { tree } = await git.readTree({ fs, dir, oid });
+    const files = [];
+    const walk = async (treePath, entries) => {
+      for (const entry of entries) {
+        const fullPath = treePath ? `${treePath}/${entry.path}` : entry.path;
+        if (entry.type === "blob") files.push(fullPath);
+        else if (entry.type === "tree") {
+          const { tree: subTree } = await git.readTree({ fs, dir, oid: entry.oid });
+          await walk(fullPath, subTree);
+        }
+      }
+    };
+    await walk("", tree);
+    return files;
+  }
+
+  async readFile(dir, filepath, ref = "HEAD") {
+    const oid = await git.resolveRef({ fs, dir, ref });
+    const { blob } = await git.readBlob({ fs, dir, oid, filepath });
+    return new TextDecoder().decode(blob);
+  }
+
+  // ============ HISTORY ============
+  async log(dir, { ref = "HEAD", maxCount = 50 } = {}) {
+    const commits = await git.log({ fs, dir, ref, depth: maxCount });
+    return commits.map(c => ({
+      sha: c.oid,
+      message: c.commit.message,
+      author: c.commit.author,
+      date: new Date(c.commit.author.timestamp * 1000).toISOString()
+    }));
+  }
+
+  // ============ SYNC (FETCH/PULL) ============
+  async fetch(dir, remote, branch) {
+    const remotes = await git.listRemotes({ fs, dir });
+    const info = remotes.find(r => r.remote === remote);
+    if (!info) {
+      throw createError("REMOTE_NOT_FOUND", { 
+        message: `Remote '${remote}' não encontrado`,
+        availableRemotes: remotes.map(r => r.remote)
+      });
+    }
+    const onAuth = this.getAuth(info.url);
+    try {
+      await withRetry(() => git.fetch({ fs, http, dir, remote, ref: branch, singleBranch: true, onAuth }));
+    } catch (e) {
+      throw mapExternalError(e, { type: "fetch", remote, branch, provider: info.url.includes("github") ? "github" : "gitea" });
+    }
+  }
+
+  async pull(dir, remote, branch) {
+    const remotes = await git.listRemotes({ fs, dir });
+    const info = remotes.find(r => r.remote === remote);
+    if (!info) {
+      throw createError("REMOTE_NOT_FOUND", { 
+        message: `Remote '${remote}' não encontrado`,
+        availableRemotes: remotes.map(r => r.remote)
+      });
+    }
+    const onAuth = this.getAuth(info.url);
+    const author = await this.getAuthor(dir);
+    try {
+      await withRetry(async () => git.pull({ fs, http, dir, remote, ref: branch, singleBranch: true, onAuth, author }));
+    } catch (e) {
+      if (e.message?.includes("conflict")) {
+        throw createError("MERGE_CONFLICT", { message: e.message, remote, branch });
+      }
+      throw mapExternalError(e, { type: "pull", remote, branch, provider: info.url.includes("github") ? "github" : "gitea" });
+    }
+  }
+
+  // ============ RESET ============
+  async _resolveRef(dir, ref) {
+    // Resolve refs como HEAD~1, HEAD~2, etc.
+    const match = ref.match(/^(HEAD|[a-zA-Z0-9_\-\/]+)~(\d+)$/);
+    if (match) {
+      const baseRef = match[1];
+      const steps = parseInt(match[2], 10);
+      const commits = await git.log({ fs, dir, ref: baseRef, depth: steps + 1 });
+      if (commits.length > steps) return commits[steps].oid;
+      throw createError("INSUFFICIENT_HISTORY", { 
+        message: `Não foi possível resolver ${ref}`,
+        requestedSteps: steps,
+        availableCommits: commits.length,
+        suggestion: `Histórico tem apenas ${commits.length} commits. Use HEAD~${commits.length - 1} no máximo.`
+      });
+    }
+    // Refs normais
+    try {
+      return await git.resolveRef({ fs, dir, ref });
+    } catch (e) {
+      const branches = await git.listBranches({ fs, dir }).catch(() => []);
+      const tags = await git.listTags({ fs, dir }).catch(() => []);
+      throw createError("REF_NOT_FOUND", { 
+        message: `Ref '${ref}' não encontrada`,
+        ref,
+        availableBranches: branches.slice(0, 10),
+        availableTags: tags.slice(0, 10)
+      });
+    }
+  }
+
+  async resetSoft(dir, ref) {
+    const oid = await this._resolveRef(dir, ref);
+    const headPath = path.join(dir, ".git", "HEAD");
+    const headContent = fs.readFileSync(headPath, "utf8").trim();
+    if (headContent.startsWith("ref:")) {
+      const branchRef = headContent.replace("ref: ", "");
+      const branchPath = path.join(dir, ".git", branchRef);
+      fs.writeFileSync(branchPath, oid + "\n");
+    }
+  }
+
+  async resetMixed(dir, ref) {
+    await this.resetSoft(dir, ref);
+    // Reset index to match ref
+    const oid = await this._resolveRef(dir, ref);
+    await git.checkout({ fs, dir, ref: oid, noUpdateHead: true });
+  }
+
+  async resetHard(dir, ref) {
+    const oid = await this._resolveRef(dir, ref);
+    await git.checkout({ fs, dir, ref: oid, force: true });
+    await this.resetSoft(dir, ref);
+  }
+
+  // ============ GITIGNORE ============
+  async listGitignore(dir) {
+    const ignorePath = path.join(dir, ".gitignore");
+    if (!fs.existsSync(ignorePath)) return [];
+    return fs.readFileSync(ignorePath, "utf8").split("\n").filter(l => l.trim() && !l.startsWith("#"));
+  }
+
+  async createGitignore(dir, patterns = []) {
+    const ignorePath = path.join(dir, ".gitignore");
+    fs.writeFileSync(ignorePath, patterns.join("\n") + "\n");
+  }
+
+  async addToGitignore(dir, patterns = []) {
+    const ignorePath = path.join(dir, ".gitignore");
+    const existing = fs.existsSync(ignorePath) ? fs.readFileSync(ignorePath, "utf8") : "";
+    const newContent = existing.trimEnd() + "\n" + patterns.join("\n") + "\n";
+    fs.writeFileSync(ignorePath, newContent);
+  }
+
+  async removeFromGitignore(dir, patterns = []) {
+    const ignorePath = path.join(dir, ".gitignore");
+    if (!fs.existsSync(ignorePath)) return;
+    let lines = fs.readFileSync(ignorePath, "utf8").split("\n");
+    lines = lines.filter(l => !patterns.includes(l.trim()));
+    fs.writeFileSync(ignorePath, lines.join("\n"));
+  }
+
+  // ============ REMOTES ============
+  async listRemotes(dir) {
+    return await git.listRemotes({ fs, dir });
   }
 }
 

package/src/utils/retry.js

@@ -1,12 +1,61 @@
-export async function withRetry(fn, { retries = 3, baseDelayMs = 300 } = {}) {
-  let attempt = 0;
-  let lastErr;
-  while (attempt < retries) {
-    try { return await fn(); } catch (e) { lastErr = e; }
-    const delay = baseDelayMs * Math.pow(2, attempt);
-    await new Promise(r => setTimeout(r, delay));
-    attempt++;
+// Sistema de Retry com Backoff Exponencial
+
+const DEFAULT_OPTIONS = {
+  maxRetries: 3,
+  initialDelay: 1000,
+  maxDelay: 10000,
+  backoffFactor: 2,
+  retryableErrors: ["ETIMEDOUT", "ECONNRESET", "ENOTFOUND", "ECONNREFUSED", "timeout", "rate limit", "429", "503", "502"]
+};
+
+function shouldRetry(error, options) {
+  const msg = (error?.message || String(error)).toLowerCase();
+  const code = error?.code?.toLowerCase() || "";
+  
+  return options.retryableErrors.some(e => 
+    msg.includes(e.toLowerCase()) || code.includes(e.toLowerCase())
+  );
+}
+
+function sleep(ms) {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+export async function withRetry(fn, options = {}) {
+  const opts = { ...DEFAULT_OPTIONS, ...options };
+  let lastError;
+  let delay = opts.initialDelay;
+  
+  for (let attempt = 1; attempt <= opts.maxRetries; attempt++) {
+    try {
+      return await fn();
+    } catch (error) {
+      lastError = error;
+      
+      if (attempt === opts.maxRetries || !shouldRetry(error, opts)) {
+        throw error;
+      }
+      
+      // Log retry (silencioso)
+      console.error(`[Retry] Attempt ${attempt}/${opts.maxRetries} failed, retrying in ${delay}ms...`);
+      
+      await sleep(delay);
+      delay = Math.min(delay * opts.backoffFactor, opts.maxDelay);
+    }
   }
-  throw lastErr;
+  
+  throw lastError;
+}
+
+// Wrapper para axios com retry
+export async function axiosWithRetry(axiosInstance, config, options = {}) {
+  return withRetry(() => axiosInstance(config), options);
 }
 
+// Wrapper para operações git com retry
+export async function gitWithRetry(fn, options = {}) {
+  return withRetry(fn, {
+    ...options,
+    retryableErrors: [...DEFAULT_OPTIONS.retryableErrors, "ENOENT", "lock"]
+  });
+}