@andrebuzeli/git-mcp 15.8.4 → 15.8.5

package/src/utils/gitAdapter.js

@@ -1,951 +1,932 @@
-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, Linux, and macOS
-const GIT_CANDIDATES = [
-    // Windows paths
-    "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",
-    // Linux/macOS paths
-    "/usr/bin/git",
-    "/usr/local/bin/git",
-    "/opt/homebrew/bin/git",  // macOS Homebrew ARM
-    // Fallback to PATH
-    "git"
-];
-
-// Timeout configurável via variável de ambiente (default: 60 segundos)
-const GIT_TIMEOUT = parseInt(process.env.GIT_TIMEOUT_MS || "60000", 10);
-
-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.timeout = GIT_TIMEOUT;
-        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 with timeout
-    _runSpawn(cmd, args, dir, env = {}) {
-        return new Promise((resolve, reject) => {
-            const cp = spawn(cmd, args, {
-                cwd: dir,
-                env: {
-                    ...this.gitEnv,
-                    ...env,
-                    GIT_TERMINAL_PROMPT: "0", // Prevent interactive prompts (fixes "No such device or address")
-                    GCM_INTERACTIVE: "never"  // Disable Credential Manager prompts
-                },
-                stdio: 'pipe'
-            });
-
-            let stdout = [];
-            let stderr = [];
-            let killed = false;
-
-            // Timeout handler
-            const timeoutId = setTimeout(() => {
-                killed = true;
-                cp.kill('SIGTERM');
-                reject(new Error(`Git command timed out after ${this.timeout}ms: git ${args.join(" ")}`));
-            }, this.timeout);
-
-            cp.stdout.on("data", d => stdout.push(d));
-            cp.stderr.on("data", d => stderr.push(d));
-
-            cp.on("error", e => {
-                clearTimeout(timeoutId);
-                reject(new Error(`Failed to spawn ${cmd}: ${e.message}`));
-            });
-
-            cp.on("close", code => {
-                clearTimeout(timeoutId);
-                if (killed) return; // Already rejected by timeout
-
-                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) {
-            const msg = e.message || "";
-
-            // Auto-fix 1: dubious ownership error (common on network shares)
-            if (msg.includes("dubious ownership") && !options._retried) {
-                console.error("[GitAdapter] Auto-fix: dubious ownership, adding safe.directory...");
-                try {
-                    await this._runSpawn(this.gitPath, ["config", "--global", "--add", "safe.directory", "*"], ".");
-                    return await this._exec(dir, args, { ...options, _retried: true });
-                } catch (configError) {
-                    console.error("[GitAdapter] Failed to configure safe.directory:", configError.message);
-                }
-            }
-
-            // Auto-fix 2: Lock file presente (outro processo git pode ter crashado)
-            if ((msg.includes(".git/index.lock") || msg.includes("Unable to create") && msg.includes("lock")) && !options._lockRetried) {
-                const lockPath = path.join(dir, ".git", "index.lock");
-                if (fs.existsSync(lockPath)) {
-                    console.error("[GitAdapter] Auto-fix: removing stale .git/index.lock...");
-                    try {
-                        fs.unlinkSync(lockPath);
-                        return await this._exec(dir, args, { ...options, _lockRetried: true });
-                    } catch (unlinkError) {
-                        console.error("[GitAdapter] Failed to remove lock file:", unlinkError.message);
-                    }
-                }
-            }
-
-            // Auto-fix 3: CRLF warnings (just retry with autocrlf config)
-            if (msg.includes("CRLF will be replaced") && !options._crlfRetried) {
-                console.error("[GitAdapter] Auto-fix: configuring core.autocrlf...");
-                try {
-                    await this._runSpawn(this.gitPath, ["config", "--local", "core.autocrlf", "true"], dir);
-                    return await this._exec(dir, args, { ...options, _crlfRetried: true });
-                } catch {
-                    // Continue with error
-                }
-            }
-
-            if (options.ignoreErrors) return "";
-
-            // Enhance error message with context
-            const cmdStr = `git ${args.join(" ")}`;
-            const enhancedError = new Error(`Command failed: ${cmdStr}\n${msg}`);
-            enhancedError.gitCommand = args[0];
-            enhancedError.originalMessage = msg;
-            throw enhancedError;
-        }
-    }
-
-    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"
-            });
-        }
-    }
-
-    /**
-     * Verifica se o diretório é um repositório git
-     * @param {string} dir - Diretório para verificar
-     * @returns {boolean} - true se é um repo git
-     */
-    async isRepo(dir) {
-        return fs.existsSync(path.join(dir, ".git"));
-    }
-
-    /**
-     * Verifica integridade do repositório git
-     * @param {string} dir - Diretório do repositório
-     * @returns {object} - Status de integridade
-     */
-    async checkIntegrity(dir) {
-        await this._ensureGitRepo(dir);
-
-        try {
-            // Verificação rápida de objetos
-            const output = await this._exec(dir, ["fsck", "--connectivity-only"], { ignoreErrors: true });
-            const hasErrors = output.includes("error") || output.includes("missing") || output.includes("broken");
-
-            return {
-                ok: !hasErrors,
-                output: output || "Repository integrity OK",
-                suggestion: hasErrors ? "Execute 'git gc --prune=now' ou considere re-clonar o repositório" : null
-            };
-        } catch (e) {
-            return {
-                ok: false,
-                error: e.message,
-                suggestion: "Repositório pode estar corrompido. Tente: git gc --prune=now ou re-clone"
-            };
-        }
-    }
-
-    /**
-     * Valida formato de URL de remote
-     * @param {string} url - URL para validar
-     * @returns {object} - Resultado da validação
-     */
-    validateRemoteUrl(url) {
-        if (!url || typeof url !== "string") {
-            return { valid: false, error: "URL vazia ou inválida" };
-        }
-
-        // Padrões válidos de URL git
-        const patterns = [
-            /^https?:\/\/[^\s]+\.git$/i,          // https://github.com/user/repo.git
-            /^https?:\/\/[^\s]+$/i,               // https://github.com/user/repo (sem .git)
-            /^git@[^\s]+:[^\s]+\.git$/i,          // git@github.com:user/repo.git
-            /^git:\/\/[^\s]+\.git$/i,             // git://github.com/user/repo.git
-            /^ssh:\/\/[^\s]+\.git$/i,             // ssh://git@github.com/user/repo.git
-        ];
-
-        const isValid = patterns.some(p => p.test(url));
-
-        if (!isValid) {
-            return {
-                valid: false,
-                error: "Formato de URL inválido",
-                suggestion: "Use: https://github.com/user/repo.git ou git@github.com:user/repo.git"
-            };
-        }
-
-        return { valid: true, url };
-    }
-
-    // =================================================================
-    // 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 = [], notAdded = [], 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.workingDir = "modified"; }
-                if (y === 'D') { notAdded.push(file); fileInfo.workingDir = "deleted"; }
-            }
-
-            // Untracked
-            if (code === '??') {
-                notAdded.push(file);
-                fileInfo.workingDir = "new";
-            }
-
-            files.push(fileInfo);
-        }
-
-        const currentBranch = await this.getCurrentBranch(dir);
-        return {
-            modified,
-            created,
-            deleted,
-            renamed: [],
-            notAdded,
-            // Aliases para compatibilidade
-            not_added: notAdded,
-            staged,
-            conflicted: [],
-            currentBranch,
-            current: currentBranch, // Alias para compatibilidade
-            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);
-
-        let email = "";
-
-        // Try to fetch real email
-        const emailGH = await this.pm.getGitHubEmail().catch(() => null);
-        const emailGE = await this.pm.getGiteaEmail().catch(() => null);
-
-        if (emailGE) email = emailGE;
-        else if (emailGH) email = emailGH;
-
-        const who = ownerGH || ownerGE || "Git User";
-
-        if (!email) {
-            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) {
-        // Ensure author is set
-        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));
-
-        const repoName = getRepoNameFromPath(dir);
-        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, setUpstream = 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");
-        if (setUpstream) {
-            args.push("-u", remote, branch);
-        } else {
-            args.push(remote, branch);
-        }
-
-        try {
-            await this._exec(dir, args);
-        } catch (e) {
-            const msg = e.message || "";
-            const msgLower = msg.toLowerCase();
-
-            // Auto-correção: Se branch não existe no remote, tenta com -u (set-upstream)
-            const branchNotExists = msgLower.includes("has no upstream branch") ||
-                msgLower.includes("no upstream branch") ||
-                (msgLower.includes("remote branch") && msgLower.includes("does not exist")) ||
-                msgLower.includes("ref_not_found") ||
-                (msgLower.includes("fatal") && msgLower.includes("current branch") && msgLower.includes("has no upstream"));
-
-            if (branchNotExists && !setUpstream && !force) {
-                console.error(`[GitAdapter] Auto-fix: branch '${branch}' não existe no remote '${remote}', tentando com --set-upstream (-u)...`);
-                return await this.pushOne(dir, remote, branch, force, true);
-            }
-
-            if (msg.includes("rejected") || msgLower.includes("non-fast-forward")) {
-                throw createError("PUSH_REJECTED", { message: msg, 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 com Promise.allSettled para melhor controle e auto-correção
-        const pushPromises = remotes.map(async (remote) => {
-            try {
-                await this.pushOne(dir, remote, branch, force, false);
-                return { remote, success: true, setUpstream: false };
-            } catch (error) {
-                const errorMsg = error.message || String(error);
-                const errorMsgLower = errorMsg.toLowerCase();
-
-                // Auto-correção 1: Se repositório não existe, cria automaticamente
-                const repoNotFound = errorMsgLower.includes("repository not found") ||
-                    errorMsgLower.includes("repo not found") ||
-                    (errorMsgLower.includes("fatal") && errorMsgLower.includes("repository") && errorMsgLower.includes("not found")) ||
-                    (errorMsgLower.includes("not found") && (errorMsgLower.includes("remote") || errorMsgLower.includes("404")));
-
-                if (repoNotFound && !force) {
-                    try {
-                        console.error(`[GitAdapter] Auto-fix: repositório não existe no remote '${remote}', criando automaticamente...`);
-                        const repoName = getRepoNameFromPath(dir);
-                        const ensured = await this.pm.ensureRepos({ repoName, createIfMissing: true, isPublic: false });
-
-                        // Atualiza remotes após criar repo
-                        await this.ensureRemotes(dir, {});
-
-                        // Tenta push novamente
-                        await this.pushOne(dir, remote, branch, force, true); // Usa -u para criar branch também
-                        return { remote, success: true, repoCreated: true, setUpstream: true };
-                    } catch (repoCreateError) {
-                        return { remote, success: false, error: `Falhou ao criar repo: ${repoCreateError.message}`, triedCreateRepo: true };
-                    }
-                }
-
-                // Auto-correção 2: Se branch não existe no remote, tenta com --set-upstream
-                const branchNotExists = errorMsgLower.includes("has no upstream branch") ||
-                    errorMsgLower.includes("no upstream branch") ||
-                    (errorMsgLower.includes("remote branch") && errorMsgLower.includes("does not exist")) ||
-                    errorMsgLower.includes("ref_not_found");
-
-                if (branchNotExists && !force) {
-                    try {
-                        console.error(`[GitAdapter] Auto-fix: branch '${branch}' não existe no remote '${remote}', tentando com --set-upstream...`);
-                        await this.pushOne(dir, remote, branch, force, true);
-                        return { remote, success: true, setUpstream: true };
-                    } catch (retryError) {
-                        return { remote, success: false, error: retryError.message, triedSetUpstream: true };
-                    }
-                }
-
-                return { remote, success: false, error: errorMsg };
-            }
-        });
-
-        const results = await Promise.allSettled(pushPromises);
-        const successful = results.filter(r => r.status === "fulfilled" && r.value.success);
-        const failed = results.filter(r => r.status === "rejected" || !r.value.success);
-
-        if (successful.length === 0) {
-            throw createError("PUSH_REJECTED", {
-                message: "Push falhou para todos os remotes",
-                errors: failed.map(f => f.value?.error || f.reason?.message || "Erro desconhecido")
-            });
-        }
-
-        return {
-            pushed: successful.map(s => s.value.remote),
-            failed: failed.map(f => ({
-                remote: f.value?.remote || "unknown",
-                error: f.value?.error || f.reason?.message || "Erro desconhecido"
-            }))
-        };
-    }
-
-    // ============ 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 resetHardClean(dir, ref) {
-        await this._exec(dir, ["reset", "--hard", ref]);
-        const cleanResult = await this.cleanUntracked(dir);
-        return cleanResult;
-    }
-
-    async getMergeStatus(dir) {
-        const mergeHeadPath = path.join(dir, ".git", "MERGE_HEAD");
-        const isMerging = fs.existsSync(mergeHeadPath);
-
-        if (!isMerging) {
-            return { merging: false, message: "Nenhum merge em andamento" };
-        }
-
-        // Get conflicted files
-        try {
-            const diff = await this._exec(dir, ["diff", "--name-only", "--diff-filter=U"]);
-            const conflicts = diff.split("\n").filter(Boolean);
-            return {
-                merging: true,
-                conflicts,
-                message: conflicts.length > 0
-                    ? `Merge em andamento com ${conflicts.length} conflito(s)`
-                    : "Merge em andamento sem conflitos"
-            };
-        } catch {
-            return { merging: true, conflicts: [], message: "Merge em andamento" };
-        }
-    }
-
-    async abortMerge(dir) {
-        await this._exec(dir, ["merge", "--abort"]);
-    }
-
-    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 {
-            const result = await this._exec(dir, args);
-            return { merged: true, message: result };
-        } catch (e) {
-            if (e.message.includes("conflict")) {
-                const diff = await this._exec(dir, ["diff", "--name-only", "--diff-filter=U"]);
-                const conflicts = diff.split("\n").filter(Boolean);
-                return { merged: false, conflicts, message: "Merge conflicts detected" };
-            }
-            if (e.message.includes("Already up to date")) {
-                return { merged: true, message: "Already up to date" };
-            }
-            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());
-    }
-
-    // ============ GIT LFS SUPPORT ============
-
-    /**
-     * Verifica se Git LFS está instalado
-     */
-    async isLfsInstalled() {
-        try {
-            await this._exec(".", ["lfs", "version"]);
-            return true;
-        } catch {
-            return false;
-        }
-    }
-
-    /**
-     * Inicializa Git LFS no repositório
-     */
-    async lfsInstall(dir) {
-        await this._exec(dir, ["lfs", "install"]);
-    }
-
-    /**
-     * Rastreia arquivos com Git LFS
-     * @param {string} dir - Diretório do repositório
-     * @param {string[]} patterns - Padrões de arquivo (ex: ["*.psd", "*.zip"])
-     */
-    async lfsTrack(dir, patterns) {
-        for (const pattern of patterns) {
-            await this._exec(dir, ["lfs", "track", pattern]);
-        }
-        // Adiciona .gitattributes automaticamente
-        await this._exec(dir, ["add", ".gitattributes"]);
-    }
-
-    /**
-     * Remove rastreamento LFS de padrões
-     */
-    async lfsUntrack(dir, patterns) {
-        for (const pattern of patterns) {
-            await this._exec(dir, ["lfs", "untrack", pattern]);
-        }
-    }
-
-    /**
-     * Lista arquivos rastreados por LFS
-     */
-    async lfsList(dir) {
-        const out = await this._exec(dir, ["lfs", "ls-files"]);
-        return out.split("\n").filter(Boolean).map(line => {
-            const parts = line.split(" - ");
-            return {
-                oid: parts[0]?.trim(),
-                file: parts[1]?.trim()
-            };
-        });
-    }
-
-    /**
-     * Lista padrões rastreados por LFS
-     */
-    async lfsTrackedPatterns(dir) {
-        const out = await this._exec(dir, ["lfs", "track"]);
-        return out.split("\n")
-            .filter(line => line.trim().startsWith("*") || line.includes("("))
-            .map(line => line.trim().split(" ")[0]);
-    }
-
-    /**
-     * Baixa arquivos LFS
-     */
-    async lfsPull(dir) {
-        await this._exec(dir, ["lfs", "pull"]);
-    }
-
-    /**
-     * Envia arquivos LFS
-     */
-    async lfsPush(dir, remote = "origin") {
-        await this._exec(dir, ["lfs", "push", "--all", remote]);
-    }
-
-    /**
-     * Status do Git LFS
-     */
-    async lfsStatus(dir) {
-        const out = await this._exec(dir, ["lfs", "status"]);
-        return out;
-    }
-}
-
+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, Linux, and macOS
+const GIT_CANDIDATES = [
+    // Windows paths
+    "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",
+    // Linux/macOS paths
+    "/usr/bin/git",
+    "/usr/local/bin/git",
+    "/opt/homebrew/bin/git",  // macOS Homebrew ARM
+    // Fallback to PATH
+    "git"
+];
+
+// Timeout configurável via variável de ambiente (default: 60 segundos)
+const GIT_TIMEOUT = parseInt(process.env.GIT_TIMEOUT_MS || "60000", 10);
+
+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.timeout = GIT_TIMEOUT;
+        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 with timeout
+    _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 = [];
+            let killed = false;
+            
+            // Timeout handler
+            const timeoutId = setTimeout(() => {
+                killed = true;
+                cp.kill('SIGTERM');
+                reject(new Error(`Git command timed out after ${this.timeout}ms: git ${args.join(" ")}`));
+            }, this.timeout);
+
+            cp.stdout.on("data", d => stdout.push(d));
+            cp.stderr.on("data", d => stderr.push(d));
+
+            cp.on("error", e => {
+                clearTimeout(timeoutId);
+                reject(new Error(`Failed to spawn ${cmd}: ${e.message}`));
+            });
+
+            cp.on("close", code => {
+                clearTimeout(timeoutId);
+                if (killed) return; // Already rejected by timeout
+                
+                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) {
+            const msg = e.message || "";
+            
+            // Auto-fix 1: dubious ownership error (common on network shares)
+            if (msg.includes("dubious ownership") && !options._retried) {
+                console.error("[GitAdapter] Auto-fix: dubious ownership, adding safe.directory...");
+                try {
+                    await this._runSpawn(this.gitPath, ["config", "--global", "--add", "safe.directory", "*"], ".");
+                    return await this._exec(dir, args, { ...options, _retried: true });
+                } catch (configError) {
+                    console.error("[GitAdapter] Failed to configure safe.directory:", configError.message);
+                }
+            }
+            
+            // Auto-fix 2: Lock file presente (outro processo git pode ter crashado)
+            if ((msg.includes(".git/index.lock") || msg.includes("Unable to create") && msg.includes("lock")) && !options._lockRetried) {
+                const lockPath = path.join(dir, ".git", "index.lock");
+                if (fs.existsSync(lockPath)) {
+                    console.error("[GitAdapter] Auto-fix: removing stale .git/index.lock...");
+                    try {
+                        fs.unlinkSync(lockPath);
+                        return await this._exec(dir, args, { ...options, _lockRetried: true });
+                    } catch (unlinkError) {
+                        console.error("[GitAdapter] Failed to remove lock file:", unlinkError.message);
+                    }
+                }
+            }
+            
+            // Auto-fix 3: CRLF warnings (just retry with autocrlf config)
+            if (msg.includes("CRLF will be replaced") && !options._crlfRetried) {
+                console.error("[GitAdapter] Auto-fix: configuring core.autocrlf...");
+                try {
+                    await this._runSpawn(this.gitPath, ["config", "--local", "core.autocrlf", "true"], dir);
+                    return await this._exec(dir, args, { ...options, _crlfRetried: true });
+                } catch {
+                    // Continue with error
+                }
+            }
+
+            if (options.ignoreErrors) return "";
+            
+            // Enhance error message with context
+            const cmdStr = `git ${args.join(" ")}`;
+            const enhancedError = new Error(`Command failed: ${cmdStr}\n${msg}`);
+            enhancedError.gitCommand = args[0];
+            enhancedError.originalMessage = msg;
+            throw enhancedError;
+        }
+    }
+
+    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"
+            });
+        }
+    }
+
+    /**
+     * Verifica se o diretório é um repositório git
+     * @param {string} dir - Diretório para verificar
+     * @returns {boolean} - true se é um repo git
+     */
+    async isRepo(dir) {
+        return fs.existsSync(path.join(dir, ".git"));
+    }
+
+    /**
+     * Verifica integridade do repositório git
+     * @param {string} dir - Diretório do repositório
+     * @returns {object} - Status de integridade
+     */
+    async checkIntegrity(dir) {
+        await this._ensureGitRepo(dir);
+        
+        try {
+            // Verificação rápida de objetos
+            const output = await this._exec(dir, ["fsck", "--connectivity-only"], { ignoreErrors: true });
+            const hasErrors = output.includes("error") || output.includes("missing") || output.includes("broken");
+            
+            return {
+                ok: !hasErrors,
+                output: output || "Repository integrity OK",
+                suggestion: hasErrors ? "Execute 'git gc --prune=now' ou considere re-clonar o repositório" : null
+            };
+        } catch (e) {
+            return {
+                ok: false,
+                error: e.message,
+                suggestion: "Repositório pode estar corrompido. Tente: git gc --prune=now ou re-clone"
+            };
+        }
+    }
+
+    /**
+     * Valida formato de URL de remote
+     * @param {string} url - URL para validar
+     * @returns {object} - Resultado da validação
+     */
+    validateRemoteUrl(url) {
+        if (!url || typeof url !== "string") {
+            return { valid: false, error: "URL vazia ou inválida" };
+        }
+        
+        // Padrões válidos de URL git
+        const patterns = [
+            /^https?:\/\/[^\s]+\.git$/i,          // https://github.com/user/repo.git
+            /^https?:\/\/[^\s]+$/i,               // https://github.com/user/repo (sem .git)
+            /^git@[^\s]+:[^\s]+\.git$/i,          // git@github.com:user/repo.git
+            /^git:\/\/[^\s]+\.git$/i,             // git://github.com/user/repo.git
+            /^ssh:\/\/[^\s]+\.git$/i,             // ssh://git@github.com/user/repo.git
+        ];
+        
+        const isValid = patterns.some(p => p.test(url));
+        
+        if (!isValid) {
+            return {
+                valid: false,
+                error: "Formato de URL inválido",
+                suggestion: "Use: https://github.com/user/repo.git ou git@github.com:user/repo.git"
+            };
+        }
+        
+        return { valid: true, url };
+    }
+
+    // =================================================================
+    // 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 = [], notAdded = [], 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.workingDir = "modified"; }
+                if (y === 'D') { notAdded.push(file); fileInfo.workingDir = "deleted"; }
+            }
+
+            // Untracked
+            if (code === '??') {
+                notAdded.push(file);
+                fileInfo.workingDir = "new";
+            }
+
+            files.push(fileInfo);
+        }
+
+        const currentBranch = await this.getCurrentBranch(dir);
+        return {
+            modified, 
+            created, 
+            deleted, 
+            renamed: [], 
+            notAdded,
+            // Aliases para compatibilidade
+            not_added: notAdded,
+            staged, 
+            conflicted: [],
+            currentBranch,
+            current: currentBranch, // Alias para compatibilidade
+            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));
+
+        const repoName = getRepoNameFromPath(dir);
+        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, setUpstream = 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");
+        if (setUpstream) {
+            args.push("-u", remote, branch);
+        } else {
+            args.push(remote, branch);
+        }
+
+        try {
+            await this._exec(dir, args);
+        } catch (e) {
+            const msg = e.message || "";
+            const msgLower = msg.toLowerCase();
+            
+            // Auto-correção: Se branch não existe no remote, tenta com -u (set-upstream)
+            const branchNotExists = msgLower.includes("has no upstream branch") || 
+                                   msgLower.includes("no upstream branch") ||
+                                   (msgLower.includes("remote branch") && msgLower.includes("does not exist")) ||
+                                   msgLower.includes("ref_not_found") ||
+                                   (msgLower.includes("fatal") && msgLower.includes("current branch") && msgLower.includes("has no upstream"));
+            
+            if (branchNotExists && !setUpstream && !force) {
+                console.error(`[GitAdapter] Auto-fix: branch '${branch}' não existe no remote '${remote}', tentando com --set-upstream (-u)...`);
+                return await this.pushOne(dir, remote, branch, force, true);
+            }
+            
+            if (msg.includes("rejected") || msgLower.includes("non-fast-forward")) {
+                throw createError("PUSH_REJECTED", { message: msg, 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 com Promise.allSettled para melhor controle e auto-correção
+        const pushPromises = remotes.map(async (remote) => {
+            try {
+                await this.pushOne(dir, remote, branch, force, false);
+                return { remote, success: true, setUpstream: false };
+            } catch (error) {
+                const errorMsg = error.message || String(error);
+                const errorMsgLower = errorMsg.toLowerCase();
+                
+                // Auto-correção 1: Se repositório não existe, cria automaticamente
+                const repoNotFound = errorMsgLower.includes("repository not found") || 
+                                    errorMsgLower.includes("repo not found") ||
+                                    (errorMsgLower.includes("fatal") && errorMsgLower.includes("repository") && errorMsgLower.includes("not found")) ||
+                                    (errorMsgLower.includes("not found") && (errorMsgLower.includes("remote") || errorMsgLower.includes("404")));
+                
+                if (repoNotFound && !force) {
+                    try {
+                        console.error(`[GitAdapter] Auto-fix: repositório não existe no remote '${remote}', criando automaticamente...`);
+                        const repoName = getRepoNameFromPath(dir);
+                        const ensured = await this.pm.ensureRepos({ repoName, createIfMissing: true, isPublic: false });
+                        
+                        // Atualiza remotes após criar repo
+                        await this.ensureRemotes(dir, {});
+                        
+                        // Tenta push novamente
+                        await this.pushOne(dir, remote, branch, force, true); // Usa -u para criar branch também
+                        return { remote, success: true, repoCreated: true, setUpstream: true };
+                    } catch (repoCreateError) {
+                        return { remote, success: false, error: `Falhou ao criar repo: ${repoCreateError.message}`, triedCreateRepo: true };
+                    }
+                }
+                
+                // Auto-correção 2: Se branch não existe no remote, tenta com --set-upstream
+                const branchNotExists = errorMsgLower.includes("has no upstream branch") || 
+                                       errorMsgLower.includes("no upstream branch") ||
+                                       (errorMsgLower.includes("remote branch") && errorMsgLower.includes("does not exist")) ||
+                                       errorMsgLower.includes("ref_not_found");
+                
+                if (branchNotExists && !force) {
+                    try {
+                        console.error(`[GitAdapter] Auto-fix: branch '${branch}' não existe no remote '${remote}', tentando com --set-upstream...`);
+                        await this.pushOne(dir, remote, branch, force, true);
+                        return { remote, success: true, setUpstream: true };
+                    } catch (retryError) {
+                        return { remote, success: false, error: retryError.message, triedSetUpstream: true };
+                    }
+                }
+                
+                return { remote, success: false, error: errorMsg };
+            }
+        });
+
+        const results = await Promise.allSettled(pushPromises);
+        const successful = results.filter(r => r.status === "fulfilled" && r.value.success);
+        const failed = results.filter(r => r.status === "rejected" || !r.value.success);
+
+        if (successful.length === 0) {
+            throw createError("PUSH_REJECTED", { 
+                message: "Push falhou para todos os remotes", 
+                errors: failed.map(f => f.value?.error || f.reason?.message || "Erro desconhecido") 
+            });
+        }
+
+        return {
+            pushed: successful.map(s => s.value.remote),
+            failed: failed.map(f => ({ 
+                remote: f.value?.remote || "unknown", 
+                error: f.value?.error || f.reason?.message || "Erro desconhecido" 
+            }))
+        };
+    }
+
+    // ============ 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 resetHardClean(dir, ref) {
+        await this._exec(dir, ["reset", "--hard", ref]);
+        const cleanResult = await this.cleanUntracked(dir);
+        return cleanResult;
+    }
+
+    async getMergeStatus(dir) {
+        const mergeHeadPath = path.join(dir, ".git", "MERGE_HEAD");
+        const isMerging = fs.existsSync(mergeHeadPath);
+        
+        if (!isMerging) {
+            return { merging: false, message: "Nenhum merge em andamento" };
+        }
+        
+        // Get conflicted files
+        try {
+            const diff = await this._exec(dir, ["diff", "--name-only", "--diff-filter=U"]);
+            const conflicts = diff.split("\n").filter(Boolean);
+            return { 
+                merging: true, 
+                conflicts,
+                message: conflicts.length > 0 
+                    ? `Merge em andamento com ${conflicts.length} conflito(s)`
+                    : "Merge em andamento sem conflitos"
+            };
+        } catch {
+            return { merging: true, conflicts: [], message: "Merge em andamento" };
+        }
+    }
+
+    async abortMerge(dir) {
+        await this._exec(dir, ["merge", "--abort"]);
+    }
+
+    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 {
+            const result = await this._exec(dir, args);
+            return { merged: true, message: result };
+        } catch (e) {
+            if (e.message.includes("conflict")) {
+                const diff = await this._exec(dir, ["diff", "--name-only", "--diff-filter=U"]);
+                const conflicts = diff.split("\n").filter(Boolean);
+                return { merged: false, conflicts, message: "Merge conflicts detected" };
+            }
+            if (e.message.includes("Already up to date")) {
+                return { merged: true, message: "Already up to date" };
+            }
+            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());
+    }
+
+    // ============ GIT LFS SUPPORT ============
+    
+    /**
+     * Verifica se Git LFS está instalado
+     */
+    async isLfsInstalled() {
+        try {
+            await this._exec(".", ["lfs", "version"]);
+            return true;
+        } catch {
+            return false;
+        }
+    }
+
+    /**
+     * Inicializa Git LFS no repositório
+     */
+    async lfsInstall(dir) {
+        await this._exec(dir, ["lfs", "install"]);
+    }
+
+    /**
+     * Rastreia arquivos com Git LFS
+     * @param {string} dir - Diretório do repositório
+     * @param {string[]} patterns - Padrões de arquivo (ex: ["*.psd", "*.zip"])
+     */
+    async lfsTrack(dir, patterns) {
+        for (const pattern of patterns) {
+            await this._exec(dir, ["lfs", "track", pattern]);
+        }
+        // Adiciona .gitattributes automaticamente
+        await this._exec(dir, ["add", ".gitattributes"]);
+    }
+
+    /**
+     * Remove rastreamento LFS de padrões
+     */
+    async lfsUntrack(dir, patterns) {
+        for (const pattern of patterns) {
+            await this._exec(dir, ["lfs", "untrack", pattern]);
+        }
+    }
+
+    /**
+     * Lista arquivos rastreados por LFS
+     */
+    async lfsList(dir) {
+        const out = await this._exec(dir, ["lfs", "ls-files"]);
+        return out.split("\n").filter(Boolean).map(line => {
+            const parts = line.split(" - ");
+            return {
+                oid: parts[0]?.trim(),
+                file: parts[1]?.trim()
+            };
+        });
+    }
+
+    /**
+     * Lista padrões rastreados por LFS
+     */
+    async lfsTrackedPatterns(dir) {
+        const out = await this._exec(dir, ["lfs", "track"]);
+        return out.split("\n")
+            .filter(line => line.trim().startsWith("*") || line.includes("("))
+            .map(line => line.trim().split(" ")[0]);
+    }
+
+    /**
+     * Baixa arquivos LFS
+     */
+    async lfsPull(dir) {
+        await this._exec(dir, ["lfs", "pull"]);
+    }
+
+    /**
+     * Envia arquivos LFS
+     */
+    async lfsPush(dir, remote = "origin") {
+        await this._exec(dir, ["lfs", "push", "--all", remote]);
+    }
+
+    /**
+     * Status do Git LFS
+     */
+    async lfsStatus(dir) {
+        const out = await this._exec(dir, ["lfs", "status"]);
+        return out;
+    }
+}
+