@andrebuzeli/git-mcp 15.2.1 → 15.2.3

package/src/utils/gitAdapter.js

@@ -1,1087 +1,584 @@
-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, createError, mapExternalError } from "./errors.js";
-import { getProvidersEnv, getRepoNameFromPath } from "./repoHelpers.js";
-import { withRetry } from "./retry.js";
-
-export class GitAdapter {
-  constructor(providerManager) {
-    this.pm = providerManager;
-  }
-
-  async init(dir, defaultBranch = "main") {
-    await git.init({ fs, dir, defaultBranch });
-  }
-
-  // Verifica se é um repositório git válido
-  async _ensureGitRepo(dir) {
-    const gitDir = path.join(dir, ".git");
-    if (!fs.existsSync(gitDir)) {
-      throw createError("NOT_A_GIT_REPO", {
-        message: `'${dir}' não é um repositório git`,
-        suggestion: "Use git-workflow init para criar um repositório"
-      });
-    }
-  }
-
-  async status(dir) {
-    await this._ensureGitRepo(dir);
-    const matrix = await git.statusMatrix({ fs, dir });
-    const FILE = 0, HEAD = 1, WORKDIR = 2, STAGE = 3;
-    const modified = [], created = [], deleted = [], not_added = [], files = [];
-    for (const row of matrix) {
-      const f = row[FILE], h = row[HEAD], w = row[WORKDIR], s = row[STAGE];
-      if (h === 0 && w === 2 && s === 0) { not_added.push(f); files.push({ path: f, working_dir: "new" }); }
-      else if (h === 0 && w === 2 && s === 2) { created.push(f); files.push({ path: f, index: "new", working_dir: "new" }); }
-      else if (h === 1 && w === 2 && s === 1) { not_added.push(f); files.push({ path: f, working_dir: "modified" }); }
-      else if (h === 1 && w === 2 && s === 2) { modified.push(f); files.push({ path: f, index: "modified", working_dir: "modified" }); }
-      else if (h === 1 && w === 0 && s === 1) { not_added.push(f); files.push({ path: f, working_dir: "deleted" }); }
-      else if (h === 1 && w === 0 && s === 0) { deleted.push(f); files.push({ path: f, index: "deleted", working_dir: "deleted" }); }
-    }
-    const current = await this.getCurrentBranch(dir);
-    const staged = [...modified, ...created, ...deleted];
-    const isClean = modified.length === 0 && created.length === 0 && deleted.length === 0 && not_added.length === 0;
-    return { modified, created, deleted, renamed: [], not_added, staged, conflicted: [], current, tracking: null, ahead: 0, behind: 0, isClean, files };
-  }
-
-  async add(dir, files) {
-    for (const fp of files) {
-      if (fp === ".") {
-        const matrix = await git.statusMatrix({ fs, dir });
-        for (const row of matrix) {
-          const file = row[0];
-          const work = row[2];
-          if (work === 2) await git.add({ fs, dir, filepath: file });
-          else if (work === 0 && row[1] === 1) await git.remove({ fs, dir, filepath: file });
-        }
-      } else {
-        await git.add({ fs, dir, filepath: fp });
-      }
-    }
-  }
-
-  async remove(dir, files) {
-    for (const fp of files) await git.remove({ fs, dir, filepath: fp });
-  }
-
-  async getAuthor(dir) {
-    const name = await git.getConfig({ fs, dir, path: "user.name" }).catch(() => "");
-    const email = await git.getConfig({ fs, dir, path: "user.email" }).catch(() => "");
-    if (name && email) return { name, email };
-    
-    // Tenta inferir do provider
-    const ownerGH = await this.pm.getGitHubOwner().catch(() => null);
-    const ownerGE = await this.pm.getGiteaOwner().catch(() => null);
-    const who = ownerGH || ownerGE;
-    if (who) {
-      const inferred = { name: who, email: `${who}@users.noreply` };
-      await git.setConfig({ fs, dir, path: "user.name", value: inferred.name }).catch(() => {});
-      await git.setConfig({ fs, dir, path: "user.email", value: inferred.email }).catch(() => {});
-      return inferred;
-    }
-    
-    // Fallback padrão - usa valores genéricos para não bloquear operações
-    const defaultAuthor = { name: "Git User", email: "git@localhost" };
-    await git.setConfig({ fs, dir, path: "user.name", value: defaultAuthor.name }).catch(() => {});
-    await git.setConfig({ fs, dir, path: "user.email", value: defaultAuthor.email }).catch(() => {});
-    return defaultAuthor;
-  }
-
-  async commit(dir, message) {
-    const author = await this.getAuthor(dir);
-    const sha = await git.commit({ fs, dir, message, author: { name: author.name, email: author.email } });
-    return sha;
-  }
-
-  async getCurrentBranch(dir) {
-    return (await git.currentBranch({ fs, dir, fullname: false }).catch(() => "HEAD")) || "HEAD";
-  }
-
-  async ensureRemotes(dir, { githubUrl, giteaUrl }) {
-    const remotes = await git.listRemotes({ fs, dir });
-    // Usa o helper para normalizar o nome do repo
-    let repoName = getRepoNameFromPath(dir);
-    // Fix específico para seu caso: se normalizar para GIT_MCP, força git-mcp (padrão kebab-case)
-    if (repoName === "GIT_MCP") repoName = "git-mcp"; 
-    
-    // Tenta obter URLs autenticadas/corretas do ProviderManager
-    const calculatedUrls = await this.pm.getRemoteUrls(repoName);
-    const targetGithub = calculatedUrls.github || githubUrl;
-    const targetGitea = calculatedUrls.gitea || giteaUrl;
-
-    const ensure = async (name, url) => {
-      if (!url) return;
-      const existing = remotes.find(r => r.remote === name);
-      
-      // SEMPRE força a atualização se a URL for diferente
-      // Isso garante que a URL do ENV (mcp.json) tenha prioridade sobre o .git/config local
-      if (existing) {
-        if (existing.url !== url) {
-          await git.deleteRemote({ fs, dir, remote: name });
-          await git.addRemote({ fs, dir, remote: name, url });
-        }
-      } else {
-        await git.addRemote({ fs, dir, remote: name, url });
-      }
-    };
-
-    await ensure("github", targetGithub);
-    await ensure("gitea", targetGitea);
-    
-    // Origin prefere GitHub, fallback para Gitea
-    // Também força atualização do origin se necessário
-    const originUrl = targetGithub || targetGitea;
-    if (originUrl) await ensure("origin", originUrl);
-  }
-
-  getAuth(remoteUrl) {
-    const { githubToken, giteaToken } = getProvidersEnv();
-    if (remoteUrl.includes("github.com")) {
-      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 createError("AUTH_GITEA_INVALID", { message: "GITEA_TOKEN não configurado" });
-  }
-
-  async pushOne(dir, remote, branch, force = false) {
-    const remotes = await git.listRemotes({ fs, dir });
-    const info = remotes.find(r => r.remote === remote);
-    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}`;
-    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, force = false) {
-    // Auto-fix remotes antes de tentar push
-    await this.ensureRemotes(dir, {});
-
-    const remotes = await git.listRemotes({ fs, dir });
-    const targets = remotes.filter(r => ["github", "gitea"].includes(r.remote));
-    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") {
-    // Verifica se há commits no repositório
-    try {
-      const oid = await git.resolveRef({ fs, dir, ref });
-      await git.branch({ fs, dir, ref: name, checkout: false });
-    } catch (e) {
-      if (e.code === "NotFoundError" || e.message?.includes("Could not find")) {
-        throw createError("NO_COMMITS", {
-          message: `Não é possível criar branch '${name}': repositório não tem commits. Faça um commit primeiro.`,
-          ref,
-          suggestion: "Use git-workflow commit para criar o primeiro commit"
-        });
-      }
-      throw e;
-    }
-  }
-
-  async deleteBranch(dir, name, force = false) {
-    // Verifica se está tentando deletar a branch atual
-    const currentBranch = await this.getCurrentBranch(dir);
-    if (currentBranch === name) {
-      throw createError("CANNOT_DELETE_CURRENT_BRANCH", {
-        message: `Não é possível deletar a branch atual '${name}'`,
-        branch: name,
-        suggestion: "Mude para outra branch antes de deletar esta"
-      });
-    }
-    
-    try {
-      await git.deleteBranch({ fs, dir, ref: name });
-    } catch (e) {
-      if (e.code === "NotFoundError" || e.message?.includes("Could not find")) {
-        throw createError("BRANCH_NOT_FOUND", {
-          message: `Branch '${name}' não encontrada`,
-          branch: name
-        });
-      }
-      throw e;
-    }
-  }
-
-  async renameBranch(dir, oldName, newName) {
-    try {
-      await git.renameBranch({ fs, dir, oldref: oldName, ref: newName });
-    } catch (e) {
-      if (e.code === "NotFoundError" || e.message?.includes("Could not find")) {
-        throw createError("BRANCH_NOT_FOUND", {
-          message: `Branch '${oldName}' não encontrada`,
-          branch: oldName
-        });
-      }
-      throw e;
-    }
-  }
-
-  async checkout(dir, ref) {
-    try {
-      await git.checkout({ fs, dir, ref, force: true });
-    } catch (e) {
-      if (e.code === "NotFoundError" || e.message?.includes("Could not find")) {
-        throw createError("REF_NOT_FOUND", {
-          message: `Branch ou ref '${ref}' não encontrado`,
-          ref,
-          suggestion: "Verifique se o nome está correto com git-branches list"
-        });
-      }
-      throw e;
-    }
-  }
-
-  // ============ 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) {
-    // Verifica se a tag existe antes de tentar deletar
-    const tags = await this.listTags(dir);
-    if (!tags.includes(tag)) {
-      throw createError("TAG_NOT_FOUND", {
-        message: `Tag '${tag}' não encontrada`,
-        tag,
-        availableTags: tags.slice(0, 5)
-      });
-    }
-    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);
-    
-    // Verifica se há arquivos para stash
-    const filesToSave = [...st.not_added, ...st.modified, ...st.created];
-    if (filesToSave.length === 0 && !includeUntracked) {
-      throw createError("NOTHING_TO_STASH", { 
-        message: "Working tree limpa, nada para stash",
-        status: st
-      });
-    }
-    
-    // Salva arquivos modificados/adicionados
-    const stashData = { message, timestamp: Date.now(), files: {} };
-    
-    for (const file of filesToSave) {
-      const fullPath = path.join(dir, file);
-      if (fs.existsSync(fullPath)) {
-        // Lê como buffer para suportar binários
-        const content = fs.readFileSync(fullPath);
-        stashData.files[file] = content.toString("base64");
-        stashData.encoding = "base64";
-      }
-    }
-    
-    // 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));
-    
-    // Remove arquivos stashados do working directory
-    for (const file of filesToSave) {
-      const fullPath = path.join(dir, file);
-      if (fs.existsSync(fullPath)) {
-        fs.unlinkSync(fullPath);
-      }
-    }
-    
-    // Tenta restaurar para estado HEAD se houver commits
-    try {
-      const currentBranch = await this.getCurrentBranch(dir);
-      if (currentBranch && currentBranch !== "HEAD") {
-        await git.checkout({ fs, dir, ref: currentBranch, force: true }).catch(() => {});
-      } else {
-        const oid = await git.resolveRef({ fs, dir, ref: "HEAD" }).catch(() => null);
-        if (oid) await git.checkout({ fs, dir, ref: oid, force: true }).catch(() => {});
-      }
-    } catch {
-      // Repo pode não ter commits ainda, isso é ok
-    }
-  }
-
-  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 (suporta base64 e utf8)
-    for (const [file, content] of Object.entries(stash.files)) {
-      const fullPath = path.join(dir, file);
-      fs.mkdirSync(path.dirname(fullPath), { recursive: true });
-      if (stash.encoding === "base64") {
-        fs.writeFileSync(fullPath, Buffer.from(content, "base64"));
-      } else {
-        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") {
-    // Primeiro tenta via isomorphic-git
-    const value = await git.getConfig({ fs, dir, path: key }).catch(() => undefined);
-    if (value !== undefined) return value;
-    
-    // Fallback: lê diretamente do arquivo config
-    const configPath = path.join(dir, ".git", "config");
-    if (!fs.existsSync(configPath)) return undefined;
-    
-    const content = fs.readFileSync(configPath, "utf8");
-    const parts = key.split(".");
-    const section = parts.slice(0, -1).join(".");
-    const keyName = parts[parts.length - 1];
-    
-    // Parse manual do INI
-    let currentSection = "";
-    for (const line of content.split("\n")) {
-      const secMatch = line.match(/^\[([^\]]+)\]$/);
-      if (secMatch) {
-        currentSection = secMatch[1].replace(/\s+"/g, ".").replace(/"/g, "");
-        continue;
-      }
-      
-      if (currentSection === section) {
-        const kvMatch = line.match(/^\s*(\w+)\s*=\s*(.*)$/);
-        if (kvMatch && kvMatch[1] === keyName) {
-          return kvMatch[2].trim();
-        }
-      }
-    }
-    
-    return undefined;
-  }
-
-  async setConfig(dir, key, value, scope = "local") {
-    // Tenta via isomorphic-git primeiro
-    try {
-      await git.setConfig({ fs, dir, path: key, value });
-      
-      // Verifica se funcionou
-      const check = await git.getConfig({ fs, dir, path: key }).catch(() => undefined);
-      if (check === value) return;
-    } catch {}
-    
-    // Fallback: escreve diretamente no arquivo config
-    const configPath = path.join(dir, ".git", "config");
-    let content = "";
-    if (fs.existsSync(configPath)) {
-      content = fs.readFileSync(configPath, "utf8");
-    }
-    
-    const parts = key.split(".");
-    const section = parts.slice(0, -1).join(".");
-    const keyName = parts[parts.length - 1];
-    
-    // Verifica se a seção existe
-    const sectionHeader = `[${section}]`;
-    const sectionIndex = content.indexOf(sectionHeader);
-    
-    if (sectionIndex >= 0) {
-      // Seção existe, procura se a chave já existe
-      const lines = content.split("\n");
-      let inSection = false;
-      let keyFound = false;
-      
-      for (let i = 0; i < lines.length; i++) {
-        const line = lines[i];
-        if (line.trim().startsWith("[")) {
-          inSection = line.trim() === sectionHeader;
-        } else if (inSection) {
-          const kvMatch = line.match(/^\s*(\w+)\s*=/);
-          if (kvMatch && kvMatch[1] === keyName) {
-            lines[i] = `\t${keyName} = ${value}`;
-            keyFound = true;
-            break;
-          }
-        }
-      }
-      
-      if (!keyFound) {
-        // Adiciona a chave na seção existente
-        for (let i = 0; i < lines.length; i++) {
-          if (lines[i].trim() === sectionHeader) {
-            lines.splice(i + 1, 0, `\t${keyName} = ${value}`);
-            break;
-          }
-        }
-      }
-      
-      content = lines.join("\n");
-    } else {
-      // Seção não existe, adiciona no final
-      content += `\n[${section}]\n\t${keyName} = ${value}\n`;
-    }
-    
-    fs.writeFileSync(configPath, content);
-  }
-
-  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 });
-  }
-
-  // ============ MERGE ============
-  async merge(dir, branch, options = {}) {
-    const { message, noCommit, squash } = options;
-    const author = await this.getAuthor(dir);
-    
-    try {
-      // Resolve the branch to merge
-      const theirOid = await git.resolveRef({ fs, dir, ref: branch });
-      const ourOid = await git.resolveRef({ fs, dir, ref: "HEAD" });
-      
-      // Find merge base
-      const bases = await git.findMergeBase({ fs, dir, oids: [ourOid, theirOid] });
-      if (bases.length === 0) {
-        throw createError("MERGE_NO_BASE", {
-          message: "Não foi possível encontrar ancestral comum para merge"
-        });
-      }
-      
-      // Check if fast-forward is possible
-      if (bases[0] === ourOid) {
-        // Fast-forward merge
-        await git.checkout({ fs, dir, ref: theirOid, force: true });
-        const currentBranch = await this.getCurrentBranch(dir);
-        if (currentBranch !== "HEAD") {
-          const branchPath = path.join(dir, ".git", "refs", "heads", currentBranch);
-          fs.mkdirSync(path.dirname(branchPath), { recursive: true });
-          fs.writeFileSync(branchPath, theirOid + "\n");
-        }
-        return { fastForward: true, sha: theirOid };
-      }
-      
-      // Regular merge - we need to do a three-way merge
-      // For now, use a simplified approach that handles non-conflicting cases
-      const result = await git.merge({
-        fs,
-        dir,
-        ours: ourOid,
-        theirs: theirOid,
-        author,
-        message: message || `Merge branch '${branch}'`
-      }).catch(async (e) => {
-        // Check for conflicts
-        if (e.message?.includes("conflict")) {
-          return { 
-            conflicts: true, 
-            message: e.message,
-            files: await this._detectConflicts(dir)
-          };
-        }
-        throw e;
-      });
-      
-      if (result.conflicts) {
-        return {
-          merged: false,
-          conflicts: result.files || [],
-          message: "Merge com conflitos. Resolva manualmente e faça commit."
-        };
-      }
-      
-      return { 
-        merged: true, 
-        sha: result?.oid || result, 
-        fastForward: false 
-      };
-    } catch (e) {
-      if (e.code === "NotFoundError" || e.message?.includes("Could not find")) {
-        throw createError("BRANCH_NOT_FOUND", {
-          message: `Branch '${branch}' não encontrada`,
-          branch
-        });
-      }
-      throw e;
-    }
-  }
-
-  async _detectConflicts(dir) {
-    const matrix = await git.statusMatrix({ fs, dir });
-    const conflicts = [];
-    for (const row of matrix) {
-      const [file, head, workdir, stage] = row;
-      // Conflito: diferentes estados
-      if (head !== workdir || workdir !== stage) {
-        conflicts.push(file);
-      }
-    }
-    return conflicts;
-  }
-
-  async getMergeStatus(dir) {
-    const mergePath = path.join(dir, ".git", "MERGE_HEAD");
-    const isMerging = fs.existsSync(mergePath);
-    
-    if (!isMerging) {
-      return { merging: false };
-    }
-    
-    const mergeHead = fs.readFileSync(mergePath, "utf8").trim();
-    return {
-      merging: true,
-      mergeHead,
-      conflicts: await this._detectConflicts(dir)
-    };
-  }
-
-  async abortMerge(dir) {
-    const mergePath = path.join(dir, ".git", "MERGE_HEAD");
-    const mergeMsg = path.join(dir, ".git", "MERGE_MSG");
-    
-    if (!fs.existsSync(mergePath)) {
-      throw createError("NO_MERGE_IN_PROGRESS", {
-        message: "Nenhum merge em andamento para abortar"
-      });
-    }
-    
-    // Reset to HEAD
-    await this.resetHard(dir, "HEAD");
-    
-    // Remove merge files
-    if (fs.existsSync(mergePath)) fs.unlinkSync(mergePath);
-    if (fs.existsSync(mergeMsg)) fs.unlinkSync(mergeMsg);
-  }
-
-  // ============ DIFF ============
-  async diff(dir, options = {}) {
-    const { file, context = 3 } = options;
-    const matrix = await git.statusMatrix({ fs, dir });
-    const changes = [];
-    
-    for (const row of matrix) {
-      const [filepath, head, workdir, stage] = row;
-      
-      // Skip if file filter is set and doesn't match
-      if (file && filepath !== file) continue;
-      
-      // Skip unchanged files
-      if (head === workdir && workdir === stage) continue;
-      
-      const change = {
-        path: filepath,
-        status: this._getFileStatus(head, workdir, stage)
-      };
-      
-      // Get actual diff content for modified files
-      if (change.status === "modified" || change.status === "staged-modified") {
-        try {
-          const oldContent = await this._getFileAtRef(dir, filepath, "HEAD");
-          const newContent = fs.existsSync(path.join(dir, filepath)) 
-            ? fs.readFileSync(path.join(dir, filepath), "utf8")
-            : "";
-          change.diff = this._createUnifiedDiff(oldContent, newContent, filepath, context);
-        } catch (e) {
-          change.diff = `[Não foi possível gerar diff: ${e.message}]`;
-        }
-      }
-      
-      changes.push(change);
-    }
-    
-    return changes;
-  }
-
-  _getFileStatus(head, workdir, stage) {
-    if (head === 0 && workdir === 2 && stage === 0) return "new-untracked";
-    if (head === 0 && workdir === 2 && stage === 2) return "new-staged";
-    if (head === 1 && workdir === 2 && stage === 1) return "modified";
-    if (head === 1 && workdir === 2 && stage === 2) return "staged-modified";
-    if (head === 1 && workdir === 0 && stage === 1) return "deleted";
-    if (head === 1 && workdir === 0 && stage === 0) return "staged-deleted";
-    return "unknown";
-  }
-
-  async _getFileAtRef(dir, filepath, ref) {
-    try {
-      const oid = await git.resolveRef({ fs, dir, ref });
-      const { blob } = await git.readBlob({ fs, dir, oid, filepath });
-      return new TextDecoder().decode(blob);
-    } catch {
-      return "";
-    }
-  }
-
-  _createUnifiedDiff(oldContent, newContent, filename, context = 3) {
-    const oldLines = oldContent.split("\n");
-    const newLines = newContent.split("\n");
-    
-    // Simple line-by-line diff
-    const diff = [];
-    diff.push(`--- a/${filename}`);
-    diff.push(`+++ b/${filename}`);
-    
-    let i = 0, j = 0;
-    while (i < oldLines.length || j < newLines.length) {
-      if (oldLines[i] === newLines[j]) {
-        diff.push(` ${oldLines[i] || ""}`);
-        i++; j++;
-      } else if (j < newLines.length && (i >= oldLines.length || oldLines[i] !== newLines[j])) {
-        diff.push(`+${newLines[j]}`);
-        j++;
-      } else {
-        diff.push(`-${oldLines[i]}`);
-        i++;
-      }
-    }
-    
-    return diff.join("\n");
-  }
-
-  async diffCommits(dir, from, to, options = {}) {
-    const { file, context = 3 } = options;
-    
-    const fromOid = await this._resolveRef(dir, from);
-    const toOid = to ? await this._resolveRef(dir, to) : null;
-    
-    // Get file lists for both commits
-    const fromFiles = await this.listFiles(dir, fromOid);
-    const toFiles = toOid 
-      ? await this.listFiles(dir, toOid)
-      : await this._getWorkingFiles(dir);
-    
-    const allFiles = [...new Set([...fromFiles, ...toFiles])];
-    const changes = [];
-    
-    for (const filepath of allFiles) {
-      if (file && filepath !== file) continue;
-      
-      const inFrom = fromFiles.includes(filepath);
-      const inTo = toFiles.includes(filepath);
-      
-      let status, diff;
-      
-      if (!inFrom && inTo) {
-        status = "added";
-      } else if (inFrom && !inTo) {
-        status = "deleted";
-      } else {
-        // Compare content
-        const fromContent = await this._getFileAtRef(dir, filepath, fromOid);
-        const toContent = toOid 
-          ? await this._getFileAtRef(dir, filepath, toOid)
-          : fs.readFileSync(path.join(dir, filepath), "utf8");
-        
-        if (fromContent === toContent) continue;
-        
-        status = "modified";
-        diff = this._createUnifiedDiff(fromContent, toContent, filepath, context);
-      }
-      
-      changes.push({ path: filepath, status, diff });
-    }
-    
-    return changes;
-  }
-
-  async _getWorkingFiles(dir) {
-    const files = [];
-    const walk = (dirPath, prefix = "") => {
-      const entries = fs.readdirSync(dirPath, { withFileTypes: true });
-      for (const entry of entries) {
-        if (entry.name === ".git") continue;
-        const fullPath = path.join(dirPath, entry.name);
-        const relativePath = prefix ? `${prefix}/${entry.name}` : entry.name;
-        if (entry.isDirectory()) {
-          walk(fullPath, relativePath);
-        } else {
-          files.push(relativePath);
-        }
-      }
-    };
-    walk(dir);
-    return files;
-  }
-
-  async diffStats(dir, from, to) {
-    const changes = await this.diffCommits(dir, from, to);
-    
-    let insertions = 0;
-    let deletions = 0;
-    
-    for (const change of changes) {
-      if (change.diff) {
-        const lines = change.diff.split("\n");
-        for (const line of lines) {
-          if (line.startsWith("+") && !line.startsWith("+++")) insertions++;
-          if (line.startsWith("-") && !line.startsWith("---")) deletions++;
-        }
-      }
-    }
-    
-    return {
-      filesChanged: changes.length,
-      insertions,
-      deletions,
-      files: changes.map(c => ({ path: c.path, status: c.status }))
-    };
-  }
-
-  // ============ CLONE ============
-  async clone(url, dir, options = {}) {
-    const { branch, depth, singleBranch } = options;
-    
-    // Create directory if it doesn't exist
-    if (!fs.existsSync(dir)) {
-      fs.mkdirSync(dir, { recursive: true });
-    }
-    
-    // Detect auth from URL
-    let onAuth = undefined;
-    try {
-      onAuth = this.getAuth(url);
-    } catch {
-      // Public repo, no auth needed
-    }
-    
-    const cloneOptions = {
-      fs,
-      http,
-      dir,
-      url,
-      onAuth,
-      singleBranch: singleBranch || false
-    };
-    
-    if (branch) cloneOptions.ref = branch;
-    if (depth) cloneOptions.depth = depth;
-    
-    await withRetry(() => git.clone(cloneOptions));
-    
-    const currentBranch = await this.getCurrentBranch(dir);
-    const remotes = await this.listRemotes(dir);
-    
-    return {
-      branch: currentBranch,
-      remotes: remotes.map(r => r.remote)
-    };
-  }
-
-  // ============ RESET IMPROVED ============
-  async resetHardClean(dir, ref) {
-    // First do regular hard reset
-    await this.resetHard(dir, ref);
-    
-    // Then clean untracked files
-    const result = await this.cleanUntracked(dir);
-    return result;
-  }
-
-  async cleanUntracked(dir) {
-    const status = await this.status(dir);
-    
-    for (const file of status.not_added) {
-      const fullPath = path.join(dir, file);
-      if (fs.existsSync(fullPath)) {
-        const stat = fs.statSync(fullPath);
-        if (stat.isDirectory()) {
-          fs.rmSync(fullPath, { recursive: true, force: true });
-        } else {
-          fs.unlinkSync(fullPath);
-        }
-      }
-    }
-    
-    return { cleaned: status.not_added };
-  }
-}
-
+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";
+
+// Common locations for Git on Windows, prioritizing the actual binary over the shim
+const GIT_CANDIDATES = [
+    "C:\\Program Files\\Git\\mingw64\\bin\\git.exe",
+    "C:\\Program Files\\Git\\bin\\git.exe",
+    "C:\\Program Files\\Git\\cmd\\git.exe",
+    "C:\\Users\\andre\\AppData\\Local\\Programs\\Git\\mingw64\\bin\\git.exe",
+    "C:\\Users\\andre\\AppData\\Local\\Programs\\Git\\bin\\git.exe",
+    "C:\\Users\\andre\\AppData\\Local\\Programs\\Git\\cmd\\git.exe",
+    "git" // Fallback to PATH
+];
+
+export class GitAdapter {
+    constructor(providerManager) {
+        this.pm = providerManager;
+        this.gitPath = "git"; // Initial default
+        this.gitEnv = { ...process.env, LANG: "en_US.UTF-8" }; // Base env
+        this.resolvePromise = this._resolveGit();
+    }
+
+    async _resolveGit() {
+        console.error("[GitAdapter] Resolving git binary...");
+
+        for (const candidate of GIT_CANDIDATES) {
+            if (candidate !== "git" && !fs.existsSync(candidate)) continue;
+
+            try {
+                const version = await this._runSpawn(candidate, ["--version"], ".");
+                console.error(`[GitAdapter] Found git at: ${candidate} (${version.trim()})`);
+                this.gitPath = candidate;
+
+                // If we found a specific binary, we might need to adjust PATH for standard utils (ssh, etc)
+                // But for simply running git, the absolute path is key.
+                return;
+            } catch (e) {
+                // console.error(`[GitAdapter] Failed candidate ${candidate}: ${e.message}`);
+            }
+        }
+
+        console.error("[GitAdapter] WARNING: Could not resolve specific git binary. Using 'git' from PATH.");
+        this.gitPath = "git";
+    }
+
+    // Low-level spawn wrapper
+    _runSpawn(cmd, args, dir, env = {}) {
+        return new Promise((resolve, reject) => {
+            const cp = spawn(cmd, args, {
+                cwd: dir,
+                env: { ...this.gitEnv, ...env },
+                stdio: 'pipe'
+            });
+
+            let stdout = [];
+            let stderr = [];
+
+            cp.stdout.on("data", d => stdout.push(d));
+            cp.stderr.on("data", d => stderr.push(d));
+
+            cp.on("error", e => reject(new Error(`Failed to spawn ${cmd}: ${e.message}`)));
+
+            cp.on("close", code => {
+                const outStr = Buffer.concat(stdout).toString("utf8").trim();
+                const errStr = Buffer.concat(stderr).toString("utf8").trim();
+
+                if (code === 0) {
+                    resolve(outStr);
+                } else {
+                    const msg = errStr || outStr || `Exit code ${code}`;
+                    reject(new Error(msg));
+                }
+            });
+        });
+    }
+
+    async _exec(dir, args, options = {}) {
+        await this.resolvePromise;
+
+        try {
+            const output = await this._runSpawn(this.gitPath, args, dir, options.env);
+            return output;
+        } catch (e) {
+            if (options.ignoreErrors) return "";
+            // Enhance error message
+            const cmdStr = `git ${args.join(" ")}`;
+            throw new Error(`Command failed: ${cmdStr}\n${e.message}`);
+        }
+    }
+
+    async _ensureGitRepo(dir) {
+        if (!fs.existsSync(path.join(dir, ".git"))) {
+            throw createError("NOT_A_GIT_REPO", {
+                message: `'${dir}' não é um repositório git`,
+                suggestion: "Use git-workflow init para criar um repositório"
+            });
+        }
+    }
+
+    // =================================================================
+    // Git Operations
+    // =================================================================
+
+    async init(dir, defaultBranch = "main") {
+        await fs.promises.mkdir(dir, { recursive: true });
+        // Try modern init
+        try {
+            await this._exec(dir, ["init", "-b", defaultBranch]);
+        } catch {
+            await this._exec(dir, ["init"]);
+            await this._exec(dir, ["symbolic-ref", "HEAD", `refs/heads/${defaultBranch}`]).catch(() => { });
+        }
+    }
+
+    async status(dir) {
+        await this._ensureGitRepo(dir);
+
+        // porcelain v1 is easy to parse
+        const out = await this._exec(dir, ["status", "--porcelain=v1"]);
+        const lines = out.split("\n").filter(Boolean);
+
+        const modified = [], created = [], deleted = [], not_added = [], staged = [], files = [];
+
+        for (const line of lines) {
+            // XY PATH
+            const code = line.substring(0, 2);
+            const file = line.substring(3).trim();
+            const x = code[0], y = code[1];
+
+            const fileInfo = { path: file };
+
+            // X = Index
+            if (x !== ' ' && x !== '?') {
+                staged.push(file);
+                if (x === 'A') created.push(file);
+                if (x === 'D') deleted.push(file);
+                fileInfo.index = x === 'A' ? "new" : x === 'D' ? "deleted" : "modified";
+            }
+
+            // Y = Worktree
+            if (y !== ' ') {
+                if (y === 'M') { modified.push(file); fileInfo.working_dir = "modified"; }
+                if (y === 'D') { not_added.push(file); fileInfo.working_dir = "deleted"; }
+            }
+
+            // Untracked
+            if (code === '??') {
+                not_added.push(file);
+                fileInfo.working_dir = "new";
+            }
+
+            files.push(fileInfo);
+        }
+
+        const current = await this.getCurrentBranch(dir);
+        return {
+            modified, created, deleted, renamed: [], not_added, staged, conflicted: [],
+            current, isClean: lines.length === 0, files
+        };
+    }
+
+    async add(dir, files) {
+        if (files.includes(".")) {
+            await this._exec(dir, ["add", "."]);
+            await this._exec(dir, ["add", "--all"]); // Catch deletions if . didn't
+        } else {
+            await this._exec(dir, ["add", ...files]);
+        }
+    }
+
+    async remove(dir, files) {
+        await this._exec(dir, ["rm", "--cached", ...files]);
+    }
+
+    async getAuthor(dir) {
+        try {
+            const name = await this._exec(dir, ["config", "user.name"]);
+            const email = await this._exec(dir, ["config", "user.email"]);
+            if (name && email) return { name, email };
+        } catch { }
+
+        // Fallback logic
+        const ownerGH = await this.pm.getGitHubOwner().catch(() => null);
+        const ownerGE = await this.pm.getGiteaOwner().catch(() => null);
+        const who = ownerGH || ownerGE || "Git User";
+        const email = `${who}@users.noreply`;
+
+        await this.setConfig(dir, "user.name", who);
+        await this.setConfig(dir, "user.email", email);
+
+        return { name: who, email };
+    }
+
+    async commit(dir, message) {
+        await this.getAuthor(dir);
+        await this._exec(dir, ["commit", "-m", message]);
+        return await this._exec(dir, ["rev-parse", "HEAD"]);
+    }
+
+    async getCurrentBranch(dir) {
+        try {
+            return await this._exec(dir, ["rev-parse", "--abbrev-ref", "HEAD"]);
+        } catch {
+            return "HEAD";
+        }
+    }
+
+    // ============ REMOTES ============
+    async ensureRemotes(dir, { githubUrl, giteaUrl }) {
+        const remotesOutput = await this._exec(dir, ["remote", "-v"]);
+        const remotes = new Set(remotesOutput.split("\n").map(l => l.split("\t")[0]).filter(Boolean));
+
+        let repoName = getRepoNameFromPath(dir);
+        if (repoName === "GIT_MCP") repoName = "git-mcp";
+
+        const calcUrls = await this.pm.getRemoteUrls(repoName);
+        const targetGithub = calcUrls.github || githubUrl;
+        const targetGitea = calcUrls.gitea || giteaUrl;
+
+        const setRemote = async (name, url) => {
+            if (!url) return;
+            if (remotes.has(name)) {
+                await this._exec(dir, ["remote", "set-url", name, url]);
+            } else {
+                await this._exec(dir, ["remote", "add", name, url]);
+            }
+        };
+
+        await setRemote("github", targetGithub);
+        await setRemote("gitea", targetGitea);
+
+        const originUrl = targetGithub || targetGitea;
+        if (originUrl) await setRemote("origin", originUrl);
+    }
+
+    _getAuthHeader(url) {
+        const { githubToken, giteaToken } = getProvidersEnv();
+        if (url.includes("github.com") && githubToken) {
+            const basic = Buffer.from(`${githubToken}:x-oauth-basic`).toString("base64");
+            return `Authorization: Basic ${basic}`;
+        }
+        if (giteaToken) {
+            const basic = Buffer.from(`git:${giteaToken}`).toString("base64");
+            return `Authorization: Basic ${basic}`;
+        }
+        return null;
+    }
+
+    async pushOne(dir, remote, branch, force = false) {
+        const remoteUrl = await this._exec(dir, ["remote", "get-url", remote]);
+        const header = this._getAuthHeader(remoteUrl);
+
+        const args = [];
+        if (header) {
+            args.push("-c", `http.extraHeader=${header}`);
+        }
+        args.push("push");
+        if (force) args.push("--force");
+        args.push(remote, branch);
+
+        try {
+            await this._exec(dir, args);
+        } catch (e) {
+            if (e.message.includes("rejected")) {
+                throw createError("PUSH_REJECTED", { message: e.message, remote, branch });
+            }
+            throw mapExternalError(e, { type: "push", remote, branch });
+        }
+    }
+
+    async pushParallel(dir, branch, force = false) {
+        await this.ensureRemotes(dir, {});
+        const remotesStr = await this._exec(dir, ["remote"]);
+        const remotes = remotesStr.split("\n").filter(r => ["github", "gitea"].includes(r.trim()));
+
+        if (remotes.length === 0) {
+            throw createError("REMOTE_NOT_FOUND", { message: "Nenhum remote github/gitea configurado" });
+        }
+
+        // Parallel push
+        const results = await Promise.allSettled(remotes.map(r => this.pushOne(dir, r, branch, force)));
+        const errors = results.filter(r => r.status === "rejected");
+
+        if (errors.length === remotes.length) {
+            throw createError("PUSH_REJECTED", { message: "Push falhou para todos os remotes", errors: errors.map(e => e.reason.message) });
+        }
+
+        return {
+            pushed: remotes.filter((_, i) => results[i].status === "fulfilled"),
+            failed: errors.map((e, i) => ({ remote: remotes[i], error: e.reason.message }))
+        };
+    }
+
+    // ============ BRANCHES/TAGS ============
+    async listBranches(dir, remote = false) {
+        const args = ["branch", "--format=%(refname:short)"];
+        if (remote) args.push("-r");
+        const out = await this._exec(dir, args);
+        return out.split("\n").filter(Boolean).map(b => b.trim());
+    }
+
+    async diffStats(dir, from = "HEAD", to) {
+        // git diff --shortstat from..to
+        const args = ["diff", "--shortstat", from];
+        if (to) args.push(to);
+
+        try {
+            const out = await this._exec(dir, args);
+            // Result: " 1 file changed, 1 insertion(+), 1 deletion(-)"
+            const filesChanged = (out.match(/(\d+) file(s?) changed/) || [])[1] || 0;
+            const insertions = (out.match(/(\d+) insertion(s?)/) || [])[1] || 0;
+            const deletions = (out.match(/(\d+) deletion(s?)/) || [])[1] || 0;
+
+            return {
+                filesChanged: parseInt(filesChanged),
+                insertions: parseInt(insertions),
+                deletions: parseInt(deletions)
+            };
+        } catch {
+            return { filesChanged: 0, insertions: 0, deletions: 0 };
+        }
+    }
+
+    async createBranch(dir, name) {
+        await this._exec(dir, ["branch", name]);
+    }
+
+    async deleteBranch(dir, name) {
+        try {
+            await this._exec(dir, ["branch", "-D", name]);
+        } catch (e) {
+            throw createError("BRANCH_NOT_FOUND", { message: e.message });
+        }
+    }
+
+    async renameBranch(dir, oldName, newName) {
+        await this._exec(dir, ["branch", "-m", oldName, newName]);
+    }
+
+    async checkout(dir, ref) {
+        try {
+            await this._exec(dir, ["checkout", ref]);
+        } catch (e) {
+            throw createError("REF_NOT_FOUND", { message: e.message });
+        }
+    }
+
+    async listTags(dir) {
+        const out = await this._exec(dir, ["tag"]);
+        return out.split("\n").filter(Boolean);
+    }
+
+    async createTag(dir, tag, ref = "HEAD", message = "") {
+        if (message) {
+            await this._exec(dir, ["tag", "-a", tag, ref, "-m", message]);
+        } else {
+            await this._exec(dir, ["tag", tag, ref]);
+        }
+    }
+
+    async deleteTag(dir, tag) {
+        await this._exec(dir, ["tag", "-d", tag]);
+    }
+
+    async pushTag(dir, remote, tag) {
+        const url = await this._exec(dir, ["remote", "get-url", remote]);
+        const header = this._getAuthHeader(url);
+        const args = [];
+        if (header) args.push("-c", `http.extraHeader=${header}`);
+        args.push("push", remote, tag);
+
+        await this._exec(dir, args);
+    }
+
+    // ============ STASH (Native) ============
+    async listStash(dir) {
+        const out = await this._exec(dir, ["stash", "list", "--pretty=format:%gd: %gs"]);
+        return out.split("\n").filter(Boolean).map((line, i) => ({
+            index: i,
+            message: line.split(":").slice(1).join(":").trim()
+        }));
+    }
+
+    async saveStash(dir, message = "WIP", includeUntracked = false) {
+        const args = ["stash", "push"];
+        if (includeUntracked) args.push("-u");
+        args.push("-m", message);
+        await this._exec(dir, args);
+    }
+
+    async applyStash(dir, ref = "stash@{0}") {
+        await this._exec(dir, ["stash", "apply", ref]);
+    }
+
+    async popStash(dir, ref = "stash@{0}") {
+        await this._exec(dir, ["stash", "pop", ref]);
+    }
+
+    async dropStash(dir, ref = "stash@{0}") {
+        await this._exec(dir, ["stash", "drop", ref]);
+    }
+
+    async clearStash(dir) {
+        await this._exec(dir, ["stash", "clear"]);
+    }
+
+    // ============ CONFIG ============
+    async getConfig(dir, key) {
+        try {
+            return await this._exec(dir, ["config", "--get", key]);
+        } catch { return undefined; }
+    }
+
+    async setConfig(dir, key, value, scope = "local") {
+        const args = ["config"];
+        if (scope === "global") args.push("--global");
+        else if (scope === "system") args.push("--system");
+        else args.push("--local"); // default
+        args.push(key, value);
+        await this._exec(dir, args);
+    }
+
+    async unsetConfig(dir, key, scope = "local") {
+        const args = ["config"];
+        if (scope === "global") args.push("--global");
+        else if (scope === "system") args.push("--system");
+        else args.push("--local");
+        args.push("--unset", key);
+        try { await this._exec(dir, args); } catch { }
+    }
+
+    async listConfig(dir) {
+        const out = await this._exec(dir, ["config", "--list"]);
+        const items = {};
+        out.split("\n").filter(Boolean).forEach(line => {
+            const [k, ...v] = line.split("=");
+            items[k] = v.join("=");
+        });
+        return items;
+    }
+
+    // ============ FILES/LOG ============
+    async listFiles(dir, ref = "HEAD") {
+        const out = await this._exec(dir, ["ls-tree", "-r", "--name-only", ref]);
+        return out.split("\n").filter(Boolean);
+    }
+
+    async readFile(dir, filepath, ref = "HEAD") {
+        return await this._exec(dir, ["show", `${ref}:${filepath}`]);
+    }
+
+    async log(dir, { ref = "HEAD", maxCount = 50 } = {}) {
+        const format = "%H|%h|%s|%an|%ae|%aI";
+        const out = await this._exec(dir, ["log", "-n", maxCount.toString(), `--pretty=format:${format}`, ref]);
+        return out.split("\n").filter(Boolean).map(line => {
+            const [sha, short, message, name, email, date] = line.split("|");
+            return { sha, message, author: { name, email, timestamp: new Date(date).getTime() / 1000 }, date };
+        });
+    }
+
+    async fetch(dir, remote, branch) {
+        const url = await this._exec(dir, ["remote", "get-url", remote]);
+        const header = this._getAuthHeader(url);
+        const args = [];
+        if (header) args.push("-c", `http.extraHeader=${header}`);
+        args.push("fetch", remote, branch);
+        await this._exec(dir, args);
+    }
+
+    async pull(dir, remote, branch) {
+        const url = await this._exec(dir, ["remote", "get-url", remote]);
+        const header = this._getAuthHeader(url);
+        const args = [];
+        if (header) args.push("-c", `http.extraHeader=${header}`);
+        args.push("pull", remote, branch);
+
+        try {
+            await this._exec(dir, args);
+        } catch (e) {
+            if (e.message.includes("conflict")) throw createError("MERGE_CONFLICT", { message: "Conflict on pull" });
+            throw e;
+        }
+    }
+
+    // ============ RESET/MERGE ============
+    async resetSoft(dir, ref) { await this._exec(dir, ["reset", "--soft", ref]); }
+    async resetMixed(dir, ref) { await this._exec(dir, ["reset", "--mixed", ref]); }
+    async resetHard(dir, ref) { await this._exec(dir, ["reset", "--hard", ref]); }
+
+    async merge(dir, branch, options = {}) {
+        const { message, noCommit, squash } = options;
+        const args = ["merge"];
+        if (noCommit) args.push("--no-commit");
+        if (squash) args.push("--squash");
+        if (message) args.push("-m", message);
+        args.push(branch);
+
+        try {
+            await this._exec(dir, args);
+            return { merged: true };
+        } catch (e) {
+            if (e.message.includes("conflict")) {
+                const diff = await this._exec(dir, ["diff", "--name-only", "--diff-filter=U"]);
+                return { conflicts: diff.split("\n").filter(Boolean) };
+            }
+            throw e;
+        }
+    }
+
+    // ============ DIFF/CLONE ============
+    async diff(dir, options = {}) { return await this._exec(dir, ["diff"]); }
+    async diffCommits(dir, from, to) { return await this._exec(dir, ["diff", from, to]); }
+    async diffStats(dir, from, to) { const out = await this._exec(dir, ["diff", "--stat", from, to]); return { message: out }; }
+
+    async clone(url, dir, options = {}) {
+        const { branch, depth, singleBranch } = options;
+        const args = ["clone"];
+        if (branch) args.push("-b", branch);
+        if (depth) args.push("--depth", depth.toString());
+        if (singleBranch) args.push("--single-branch");
+        args.push(url, ".");
+
+        const header = this._getAuthHeader(url);
+        const cmdArgs = [];
+        if (header) cmdArgs.push("-c", `http.extraHeader=${header}`);
+        cmdArgs.push(...args);
+
+        await fs.promises.mkdir(dir, { recursive: true });
+        await this._exec(dir, cmdArgs);
+        return { branch: branch || "HEAD" };
+    }
+
+    async listGitignore(dir) {
+        if (fs.existsSync(path.join(dir, ".gitignore"))) {
+            return fs.readFileSync(path.join(dir, ".gitignore"), "utf8").split("\n");
+        }
+        return [];
+    }
+
+    async createGitignore(dir, patterns) {
+        fs.writeFileSync(path.join(dir, ".gitignore"), patterns.join("\n"));
+    }
+
+    async addToGitignore(dir, patterns) {
+        fs.appendFileSync(path.join(dir, ".gitignore"), "\n" + patterns.join("\n"));
+    }
+
+    async removeFromGitignore(dir, patterns) {
+        const p = path.join(dir, ".gitignore");
+        if (!fs.existsSync(p)) return;
+        let c = fs.readFileSync(p, "utf8");
+        patterns.forEach(pat => c = c.replace(pat, ""));
+        fs.writeFileSync(p, c);
+    }
+
+    async listRemotesRaw(dir) {
+        return this.listRemotes(dir);
+    }
+
+    async cleanUntracked(dir) {
+        // dry-run first to get list
+        const dry = await this._exec(dir, ["clean", "-n", "-d"]);
+        const files = dry.split("\n").filter(Boolean).map(l => l.replace("Would remove ", "").trim());
+
+        if (files.length > 0) {
+            await this._exec(dir, ["clean", "-f", "-d"]);
+        }
+        return { cleaned: files };
+    }
+
+    async listRemotes(dir) {
+        const out = await this._exec(dir, ["remote", "-v"]);
+        const map = new Map();
+        out.split("\n").filter(Boolean).forEach(line => {
+            const [name, rest] = line.split("\t");
+            const url = rest.split(" ")[0];
+            map.set(name, { remote: name, url });
+        });
+        return Array.from(map.values());
+    }
+}