@andre.buzeli/git-mcp 15.12.5

package/src/utils/gitAdapter.js

@@ -0,0 +1,996 @@
+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, findGitRoot } 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: 120 segundos para suportar drives de rede)
+const GIT_TIMEOUT = parseInt(process.env.GIT_TIMEOUT_MS || "120000", 10);
+
+export class GitAdapter {
+    constructor(providerManager) {
+        this.pm = providerManager;
+        this.gitPath = "git"; // Initial default
+        this.gitEnv = {
+            ...process.env,
+            LANG: "en_US.UTF-8",
+            GIT_OPTIONAL_LOCKS: "0", // Evita operações de background que seguram lock (importante para drives de rede)
+        };
+        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");
+                let shouldDelete = false;
+
+                if (fs.existsSync(lockPath)) {
+                    try {
+                        const stats = fs.statSync(lockPath);
+                        const now = Date.now();
+                        const ageMs = now - stats.mtimeMs;
+                        // Se arquivo tem mais de 5 minutos ou se o erro já persiste (implicado pelo fato de estarmos aqui) -> Deletar
+                        // Para redes lentas, 5 min é seguro.
+                        if (ageMs > 5 * 60 * 1000) {
+                            console.error(`[GitAdapter] Lock file is old (${Math.round(ageMs / 1000)}s), deleting...`);
+                            shouldDelete = true;
+                        } else {
+                            // Se é recente, pode ser um processo ativo. Mas como falhou o comando, assumimos que bloqueou.
+                            // Em execuções agenticas sequenciais, dificilmente tem outro processo legítimo rodando ao mesmo tempo.
+                            console.error(`[GitAdapter] Lock file found. Agentic force cleanup activated.`);
+                            shouldDelete = true;
+                        }
+
+                        if (shouldDelete) {
+                            console.error("[GitAdapter] Auto-fix: removing stale .git/index.lock...");
+                            try {
+                                fs.unlinkSync(lockPath);
+                            } catch (unlinkErr) {
+                                console.error("[GitAdapter] Failed to delete lock file:", unlinkErr.message);
+                                // Set shouldDelete to false so we don't try to retry if deletion failed
+                                shouldDelete = false;
+                            }
+
+                            if (shouldDelete) {
+                                // Espera um pouco para o sistema de arquivos (especialmente SMB) registrar
+                                await new Promise(r => setTimeout(r, 5000));
+                                return await this._exec(dir, args, { ...options, _lockRetried: true });
+                            }
+                        }
+                    } catch (fsError) {
+                        console.error("[GitAdapter] Error handling lock file:", fsError.message);
+                        // Continua para lançar o erro original
+                    }
+                }
+            }
+
+            // 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) {
+        // Enforce token user as author if available
+        const profile = await this.pm.getPrioritizedUser().catch(() => null);
+
+        if (profile && profile.username) {
+            const { username, email } = profile;
+
+            // 1. Enforce Username
+            const currentName = await this.getConfig(dir, "user.name");
+            if (currentName !== username) {
+                console.error(`[GitAdapter] Enforcing author from token: ${username} (was: ${currentName || "unset"})`);
+                await this.setConfig(dir, "user.name", username);
+            }
+
+            // 2. Enforce Email
+            // If we got a real email from token, use it. 
+            // If not, and local is unset/wrong, use noreply fallback.
+            const targetEmail = email || `${username}@users.noreply.${profile.provider === 'github' ? 'github.com' : 'gitea'}`;
+
+            const currentEmail = await this.getConfig(dir, "user.email");
+            if (currentEmail !== targetEmail) {
+                // Only update if it's different.
+                // NOTE: If user has a valid private email set locally, this might overwrite it via "enforcement".
+                // But user requested: "author always be the name of the user of the token , the email too"
+                console.error(`[GitAdapter] Enforcing email from token: ${targetEmail} (was: ${currentEmail || "unset"})`);
+                await this.setConfig(dir, "user.email", targetEmail);
+            }
+
+            return { name: username, email: targetEmail };
+        }
+
+        // Fallback logic for when no token is available or API failed
+        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 { }
+
+        // If no config and no token user, fallback to generic
+        const defaultWho = "Git User";
+        const startEmail = `${defaultWho}@users.noreply`;
+
+        await this.setConfig(dir, "user.name", defaultWho);
+        await this.setConfig(dir, "user.email", startEmail);
+
+        return { name: defaultWho, email: startEmail };
+    }
+
+    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;
+    }
+}
+