@andrebuzeli/git-mcp 7.6.1 → 8.0.1

package/dist/utils/gitAdapter.js

@@ -0,0 +1,1071 @@
+import * as git from 'isomorphic-git';
+import * as fs from 'fs';
+import * as path from 'path';
+import http from 'isomorphic-git/http/node';
+// ============================================================================
+// ISOMORPHIC GIT ADAPTER IMPLEMENTATION
+// ============================================================================
+export class IsomorphicGitAdapter {
+    constructor(providerManager) {
+        this.providerManager = providerManager;
+    }
+    // ========================================================================
+    // HELPER METHODS
+    // ========================================================================
+    /**
+     * Get authentication callback for HTTP operations
+     */
+    getAuthCallback(remote) {
+        return () => {
+            // Determine if this is GitHub or Gitea based on remote URL
+            const isGitHub = remote.includes('github.com');
+            if (isGitHub) {
+                const token = process.env.GITHUB_TOKEN;
+                if (!token) {
+                    throw new Error('GITHUB_TOKEN not found in environment variables');
+                }
+                return {
+                    username: token,
+                    password: 'x-oauth-basic',
+                };
+            }
+            else {
+                const token = process.env.GITEA_TOKEN;
+                if (!token) {
+                    throw new Error('GITEA_TOKEN not found in environment variables');
+                }
+                return {
+                    username: token,
+                    password: 'x-oauth-basic',
+                };
+            }
+        };
+    }
+    /**
+     * Get author information from provider or fallback to config/default
+     */
+    async getAuthor(dir, providedAuthor) {
+        if (providedAuthor) {
+            return {
+                ...providedAuthor,
+                timestamp: providedAuthor.timestamp || Math.floor(Date.now() / 1000),
+                timezoneOffset: providedAuthor.timezoneOffset || new Date().getTimezoneOffset(),
+            };
+        }
+        // Try to get from provider manager (GitHub/Gitea username)
+        try {
+            const githubToken = process.env.GITHUB_TOKEN;
+            const giteaToken = process.env.GITEA_TOKEN;
+            if (githubToken && this.providerManager.github) {
+                const user = await this.providerManager.github.rest.users.getAuthenticated();
+                return {
+                    name: user.data.name || user.data.login,
+                    email: user.data.email || `${user.data.login}@users.noreply.github.com`,
+                    timestamp: Math.floor(Date.now() / 1000),
+                    timezoneOffset: new Date().getTimezoneOffset(),
+                };
+            }
+            if (giteaToken && this.providerManager.giteaBaseUrl) {
+                const axios = (await import('axios')).default;
+                const response = await axios.get(`${this.providerManager.giteaBaseUrl}/api/v1/user`, {
+                    headers: { Authorization: `token ${giteaToken}` },
+                });
+                const user = response.data;
+                return {
+                    name: user.full_name || user.login,
+                    email: user.email || `${user.login}@gitea.local`,
+                    timestamp: Math.floor(Date.now() / 1000),
+                    timezoneOffset: new Date().getTimezoneOffset(),
+                };
+            }
+        }
+        catch (err) {
+            // Continue to fallback
+        }
+        // Try to get from local Git config
+        try {
+            const name = await git.getConfig({ fs, dir, path: 'user.name' });
+            const email = await git.getConfig({ fs, dir, path: 'user.email' });
+            if (name && email) {
+                return {
+                    name,
+                    email,
+                    timestamp: Math.floor(Date.now() / 1000),
+                    timezoneOffset: new Date().getTimezoneOffset(),
+                };
+            }
+        }
+        catch (err) {
+            // Continue to fallback
+        }
+        // Default fallback
+        return {
+            name: 'MCP User',
+            email: 'mcp@localhost',
+            timestamp: Math.floor(Date.now() / 1000),
+            timezoneOffset: new Date().getTimezoneOffset(),
+        };
+    }
+    /**
+     * Convert isomorphic-git status matrix to StatusResult format
+     */
+    async convertStatusMatrix(dir, matrix) {
+        const FILE = 0, HEAD = 1, WORKDIR = 2, STAGE = 3;
+        const modified = [];
+        const created = [];
+        const deleted = [];
+        const not_added = [];
+        const files = [];
+        for (const row of matrix) {
+            const filepath = row[FILE];
+            const headStatus = row[HEAD];
+            const workdirStatus = row[WORKDIR];
+            const stageStatus = row[STAGE];
+            // Determine status
+            if (headStatus === 0 && workdirStatus === 2 && stageStatus === 0) {
+                // New file, not staged
+                not_added.push(filepath);
+                files.push({ path: filepath, working_dir: 'new' });
+            }
+            else if (headStatus === 0 && workdirStatus === 2 && stageStatus === 2) {
+                // New file, staged
+                created.push(filepath);
+                files.push({ path: filepath, index: 'new', working_dir: 'new' });
+            }
+            else if (headStatus === 1 && workdirStatus === 2 && stageStatus === 1) {
+                // Modified file, not staged
+                not_added.push(filepath);
+                files.push({ path: filepath, working_dir: 'modified' });
+            }
+            else if (headStatus === 1 && workdirStatus === 2 && stageStatus === 2) {
+                // Modified file, staged
+                modified.push(filepath);
+                files.push({ path: filepath, index: 'modified', working_dir: 'modified' });
+            }
+            else if (headStatus === 1 && workdirStatus === 0 && stageStatus === 1) {
+                // Deleted file, not staged
+                not_added.push(filepath);
+                files.push({ path: filepath, working_dir: 'deleted' });
+            }
+            else if (headStatus === 1 && workdirStatus === 0 && stageStatus === 0) {
+                // Deleted file, staged
+                deleted.push(filepath);
+                files.push({ path: filepath, index: 'deleted', working_dir: 'deleted' });
+            }
+        }
+        const current = await this.getCurrentBranch(dir);
+        const staged = [...modified, ...created, ...deleted]; // All staged files
+        const isClean = modified.length === 0 && created.length === 0 &&
+            deleted.length === 0 && not_added.length === 0;
+        return {
+            modified,
+            created,
+            deleted,
+            renamed: [], // isomorphic-git doesn't detect renames automatically
+            not_added,
+            staged,
+            conflicted: [],
+            current,
+            tracking: null, // Will be implemented in remote operations
+            ahead: 0,
+            behind: 0,
+            isClean,
+            files,
+        };
+    }
+    // ========================================================================
+    // REPOSITORY OPERATIONS
+    // ========================================================================
+    async init(dir, defaultBranch = 'master') {
+        await git.init({
+            fs,
+            dir,
+            defaultBranch,
+        });
+    }
+    async status(dir) {
+        const matrix = await git.statusMatrix({
+            fs,
+            dir,
+        });
+        return this.convertStatusMatrix(dir, matrix);
+    }
+    // ========================================================================
+    // STAGING OPERATIONS
+    // ========================================================================
+    async add(dir, files) {
+        for (const filepath of files) {
+            if (filepath === '.') {
+                // Add all files
+                const matrix = await git.statusMatrix({ fs, dir });
+                for (const row of matrix) {
+                    const file = row[0];
+                    const workdirStatus = row[2];
+                    if (workdirStatus === 2) { // File exists in workdir
+                        await git.add({ fs, dir, filepath: file });
+                    }
+                    else if (workdirStatus === 0 && row[1] === 1) { // File deleted
+                        await git.remove({ fs, dir, filepath: file });
+                    }
+                }
+            }
+            else {
+                await git.add({ fs, dir, filepath });
+            }
+        }
+    }
+    async remove(dir, files) {
+        for (const filepath of files) {
+            await git.remove({ fs, dir, filepath });
+        }
+    }
+    // ========================================================================
+    // COMMIT OPERATIONS
+    // ========================================================================
+    async commit(dir, message, providedAuthor) {
+        const author = await this.getAuthor(dir, providedAuthor);
+        const sha = await git.commit({
+            fs,
+            dir,
+            message,
+            author: {
+                name: author.name,
+                email: author.email,
+                timestamp: author.timestamp,
+                timezoneOffset: author.timezoneOffset,
+            },
+        });
+        return sha;
+    }
+    // ========================================================================
+    // BRANCH OPERATIONS
+    // ========================================================================
+    async listBranches(dir, remote = false) {
+        const branches = remote
+            ? await git.listBranches({ fs, dir, remote: 'origin' })
+            : await git.listBranches({ fs, dir });
+        return branches;
+    }
+    async createBranch(dir, branchName, startPoint) {
+        // Simply create branch - isomorphic-git creates it at current HEAD by default
+        await git.branch({ fs, dir, ref: branchName });
+    }
+    async deleteBranch(dir, branchName, force) {
+        // Note: isomorphic-git doesn't have a force option for branch deletion
+        // We'll implement it by checking if branch is merged
+        await git.deleteBranch({ fs, dir, ref: branchName });
+    }
+    async renameBranch(dir, oldName, newName) {
+        // isomorphic-git doesn't have renameBranch, so we rename the ref file directly
+        const currentBranch = await this.getCurrentBranch(dir);
+        const wasOnOldBranch = currentBranch === oldName;
+        // Read the old branch ref
+        const oldRefPath = path.join(dir, '.git', 'refs', 'heads', oldName);
+        const newRefPath = path.join(dir, '.git', 'refs', 'heads', newName);
+        if (!fs.existsSync(oldRefPath)) {
+            throw new Error(`Branch ${oldName} does not exist`);
+        }
+        // Copy ref to new location
+        const refContent = fs.readFileSync(oldRefPath, 'utf8');
+        fs.writeFileSync(newRefPath, refContent);
+        // Delete old ref
+        fs.unlinkSync(oldRefPath);
+        // If we were on the old branch, update HEAD
+        if (wasOnOldBranch) {
+            const headPath = path.join(dir, '.git', 'HEAD');
+            fs.writeFileSync(headPath, `ref: refs/heads/${newName}\n`);
+        }
+    }
+    async checkout(dir, ref) {
+        await git.checkout({
+            fs,
+            dir,
+            ref,
+            force: false,
+        });
+    }
+    async getCurrentBranch(dir) {
+        try {
+            const branch = await git.currentBranch({ fs, dir, fullname: false });
+            return branch || 'HEAD';
+        }
+        catch (err) {
+            return 'HEAD';
+        }
+    }
+    // ========================================================================
+    // REMOTE OPERATIONS (Placeholder - will be implemented in next step)
+    // ========================================================================
+    async addRemote(dir, name, url) {
+        await git.addRemote({ fs, dir, remote: name, url });
+    }
+    async removeRemote(dir, name) {
+        await git.deleteRemote({ fs, dir, remote: name });
+    }
+    async listRemotes(dir) {
+        const remotes = await git.listRemotes({ fs, dir });
+        return remotes.map((r) => ({
+            name: r.remote,
+            remote: r.remote,
+            url: r.url,
+            fetch: r.url,
+        }));
+    }
+    async fetch(dir, remote, ref) {
+        const remotes = await git.listRemotes({ fs, dir });
+        const remoteUrl = remotes.find(r => r.remote === remote)?.url || '';
+        const onAuth = this.getAuthCallback(remoteUrl);
+        await git.fetch({
+            fs,
+            http,
+            dir,
+            remote,
+            ref,
+            onAuth,
+            singleBranch: !!ref,
+        });
+    }
+    async pull(dir, remote, branch) {
+        await git.pull({
+            fs,
+            http,
+            dir,
+            ref: branch,
+            remote,
+            onAuth: this.getAuthCallback(remote),
+            singleBranch: true,
+        });
+    }
+    async push(dir, remote, branch, force) {
+        // Get remote URL to detect provider
+        const remotes = await git.listRemotes({ fs, dir });
+        const remoteInfo = remotes.find(r => r.remote === remote);
+        if (!remoteInfo) {
+            throw new Error(`Remote '${remote}' not found`);
+        }
+        // Determine authentication based on provider
+        let onAuth;
+        if (remoteInfo.url.includes('github.com')) {
+            // GitHub: token as username, 'x-oauth-basic' as password
+            const token = process.env.GITHUB_TOKEN;
+            if (token) {
+                onAuth = () => ({
+                    username: token,
+                    password: 'x-oauth-basic'
+                });
+            }
+        }
+        else if (remoteInfo.url.includes('gitlab.com')) {
+            // GitLab: 'oauth2' as username, token as password
+            const token = process.env.GITLAB_TOKEN;
+            if (token) {
+                onAuth = () => ({
+                    username: 'oauth2',
+                    password: token
+                });
+            }
+        }
+        else {
+            // Gitea and others: username as username, token as password
+            const username = process.env.GITEA_USERNAME || 'git';
+            const token = process.env.GITEA_TOKEN;
+            if (token) {
+                onAuth = () => ({
+                    username: username,
+                    password: token
+                });
+            }
+        }
+        try {
+            // Set upstream tracking automatically
+            const currentBranch = await this.getCurrentBranch(dir);
+            const refToPush = branch.startsWith('refs/') ? branch : `refs/heads/${branch}`;
+            await git.push({
+                fs,
+                http,
+                dir,
+                remote,
+                ref: refToPush,
+                remoteRef: refToPush,
+                onAuth,
+                force,
+                onAuthFailure: () => {
+                    throw new Error(`Authentication failed for remote '${remote}'`);
+                }
+            });
+            // Set upstream tracking branch configuration
+            if (!branch.startsWith('refs/') && currentBranch === branch) {
+                await git.setConfig({
+                    fs,
+                    dir,
+                    path: `branch.${branch}.remote`,
+                    value: remote
+                });
+                await git.setConfig({
+                    fs,
+                    dir,
+                    path: `branch.${branch}.merge`,
+                    value: `refs/heads/${branch}`
+                });
+            }
+        }
+        catch (error) {
+            if (error.code === 'HTTP401Unauthorized' || error.code === 'HTTP403Forbidden') {
+                throw new Error(`Push failed: Authentication error for ${remote}. ` +
+                    `Check your token and permissions. Error: ${error.message}`);
+            }
+            throw error;
+        }
+    }
+    // ========================================================================
+    // MERGE OPERATIONS (Placeholder - will be implemented in next step)
+    // ========================================================================
+    async merge(dir, theirBranch, author) {
+        const commitAuthor = await this.getAuthor(dir, author);
+        const currentBranch = await this.getCurrentBranch(dir);
+        try {
+            await git.merge({
+                fs,
+                dir,
+                ours: currentBranch,
+                theirs: theirBranch,
+                author: {
+                    name: commitAuthor.name,
+                    email: commitAuthor.email,
+                },
+            });
+            // Atualizar working directory com os arquivos merged
+            await git.checkout({
+                fs,
+                dir,
+                ref: currentBranch,
+                force: true,
+            });
+            return {
+                success: true,
+                message: `Merged ${theirBranch} into ${currentBranch}`,
+            };
+        }
+        catch (err) {
+            if (err.code === 'MergeNotSupportedError') {
+                return {
+                    success: false,
+                    conflicts: err.data?.conflicts || [],
+                    message: `Merge conflict detected. Files with conflicts: ${err.data?.conflicts?.join(', ') || 'unknown'}. Please resolve conflicts manually.`,
+                };
+            }
+            throw err;
+        }
+    }
+    // ========================================================================
+    // TAG OPERATIONS (Placeholder - will be implemented in next step)
+    // ========================================================================
+    async listTags(dir) {
+        const tags = await git.listTags({ fs, dir });
+        return tags;
+    }
+    async createTag(dir, tagName, ref = 'HEAD', message) {
+        const oid = await git.resolveRef({ fs, dir, ref });
+        if (message) {
+            const author = await this.getAuthor(dir);
+            await git.annotatedTag({
+                fs,
+                dir,
+                ref: tagName,
+                object: oid,
+                message,
+                tagger: {
+                    name: author.name,
+                    email: author.email,
+                    timestamp: author.timestamp,
+                    timezoneOffset: author.timezoneOffset,
+                },
+            });
+        }
+        else {
+            await git.tag({
+                fs,
+                dir,
+                ref: tagName,
+                object: oid,
+            });
+        }
+    }
+    async deleteTag(dir, tagName) {
+        await git.deleteTag({ fs, dir, ref: tagName });
+    }
+    // ========================================================================
+    // HISTORY OPERATIONS (Placeholder - will be implemented in next step)
+    // ========================================================================
+    async log(dir, options) {
+        const commits = await git.log({
+            fs,
+            dir,
+            ref: options?.ref || 'HEAD',
+            depth: options?.maxCount,
+        });
+        return commits.map(commit => ({
+            hash: commit.oid,
+            date: new Date(commit.commit.author.timestamp * 1000).toISOString(),
+            message: commit.commit.message,
+            author_name: commit.commit.author.name,
+            author_email: commit.commit.author.email,
+            refs: '', // Will be populated if needed
+        }));
+    }
+    async diff(dir, ref1, ref2) {
+        // Basic diff implementation - will be enhanced with walkers
+        return {
+            files: [],
+            summary: {
+                additions: 0,
+                deletions: 0,
+                changes: 0,
+            },
+        };
+    }
+    // ========================================================================
+    // RESET OPERATIONS (Placeholder - will be implemented in next step)
+    // ========================================================================
+    async reset(dir, ref, mode) {
+        // Resolve ref - handle HEAD~N syntax manually since isomorphic-git doesn't support it
+        let oid;
+        if (ref.match(/^HEAD~\d+$/)) {
+            // Extract number from HEAD~N
+            const steps = parseInt(ref.replace('HEAD~', ''));
+            const logs = await git.log({ fs, dir, depth: steps + 1 });
+            if (logs.length <= steps) {
+                throw new Error(`Not enough commits to resolve ${ref}`);
+            }
+            oid = logs[steps].oid;
+        }
+        else {
+            oid = await git.resolveRef({ fs, dir, ref });
+        }
+        const currentBranch = await this.getCurrentBranch(dir);
+        if (mode === 'hard') {
+            // Hard reset: move HEAD, update index, and update working directory
+            await git.writeRef({ fs, dir, ref: `refs/heads/${currentBranch}`, value: oid, force: true });
+            await git.checkout({ fs, dir, ref: oid, force: true });
+        }
+        else if (mode === 'mixed') {
+            // Mixed reset: move HEAD and update index, keep working directory
+            await git.writeRef({ fs, dir, ref: `refs/heads/${currentBranch}`, value: oid, force: true });
+            await git.checkout({ fs, dir, ref: oid });
+        }
+        else {
+            // Soft reset: only move HEAD
+            await git.writeRef({ fs, dir, ref: `refs/heads/${currentBranch}`, value: oid, force: true });
+        }
+    }
+    // ========================================================================
+    // STASH OPERATIONS - Hybrid implementation using refs/stash
+    // ========================================================================
+    /**
+     * Get stash reflog path
+     */
+    getStashReflogPath(dir) {
+        return path.join(dir, '.git', 'logs', 'refs', 'stash');
+    }
+    /**
+     * Get stash ref path
+     */
+    getStashRefPath(dir) {
+        return path.join(dir, '.git', 'refs', 'stash');
+    }
+    /**
+     * Read stash reflog entries
+     */
+    async readStashReflog(dir) {
+        const reflogPath = this.getStashReflogPath(dir);
+        if (!fs.existsSync(reflogPath)) {
+            return [];
+        }
+        const content = fs.readFileSync(reflogPath, 'utf8');
+        const lines = content.trim().split('\n').filter(l => l);
+        const entries = [];
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            const match = line.match(/^(\w+) (\w+) .+ <.+> (\d+) [+-]\d+ (.+)$/);
+            if (match) {
+                const [, , newSha, timestamp, msg] = match;
+                entries.push({
+                    index: i,
+                    message: msg.replace(/^stash@\{\d+\}: /, ''),
+                    date: new Date(parseInt(timestamp) * 1000),
+                    ref: newSha,
+                });
+            }
+        }
+        return entries.reverse(); // Most recent first
+    }
+    /**
+     * Write stash reflog entry
+     */
+    async writeStashReflogEntry(dir, oldSha, newSha, message) {
+        const reflogPath = this.getStashReflogPath(dir);
+        const reflogDir = path.dirname(reflogPath);
+        // Create logs/refs directory if it doesn't exist
+        if (!fs.existsSync(reflogDir)) {
+            fs.mkdirSync(reflogDir, { recursive: true });
+        }
+        const author = await this.getAuthor(dir);
+        const timestamp = Math.floor(Date.now() / 1000);
+        const timezoneOffset = new Date().getTimezoneOffset();
+        const tzString = timezoneOffset <= 0
+            ? `+${String(Math.abs(timezoneOffset) / 60).padStart(2, '0')}00`
+            : `-${String(timezoneOffset / 60).padStart(2, '0')}00`;
+        const entry = `${oldSha} ${newSha} ${author.name} <${author.email}> ${timestamp} ${tzString} ${message}\n`;
+        fs.appendFileSync(reflogPath, entry);
+    }
+    async stashSave(dir, message, includeUntracked) {
+        const author = await this.getAuthor(dir);
+        const currentBranch = await this.getCurrentBranch(dir);
+        const stashMessage = message || `WIP on ${currentBranch}`;
+        // Get current HEAD
+        const headSha = await git.resolveRef({ fs, dir, ref: 'HEAD' });
+        // Create index commit (staged changes)
+        const matrix = await git.statusMatrix({ fs, dir });
+        const stagedFiles = [];
+        for (const row of matrix) {
+            const filepath = row[0];
+            const stageStatus = row[3];
+            if (stageStatus === 2) {
+                stagedFiles.push(filepath);
+            }
+        }
+        // Stage all changes for stash commit
+        for (const row of matrix) {
+            const filepath = row[0];
+            const workdirStatus = row[2];
+            if (workdirStatus === 2) {
+                await git.add({ fs, dir, filepath });
+            }
+            else if (workdirStatus === 0 && row[1] === 1) {
+                await git.remove({ fs, dir, filepath });
+            }
+        }
+        // Create stash commit
+        const stashSha = await git.commit({
+            fs,
+            dir,
+            message: `stash@{0}: ${stashMessage}`,
+            author: {
+                name: author.name,
+                email: author.email,
+                timestamp: author.timestamp,
+                timezoneOffset: author.timezoneOffset,
+            },
+            parent: [headSha],
+        });
+        // Update refs/stash
+        const stashRefPath = this.getStashRefPath(dir);
+        const stashRefDir = path.dirname(stashRefPath);
+        if (!fs.existsSync(stashRefDir)) {
+            fs.mkdirSync(stashRefDir, { recursive: true });
+        }
+        fs.writeFileSync(stashRefPath, stashSha + '\n');
+        // Write reflog entry
+        const oldStashSha = fs.existsSync(stashRefPath) ? fs.readFileSync(stashRefPath, 'utf8').trim() : '0000000000000000000000000000000000000000';
+        await this.writeStashReflogEntry(dir, oldStashSha, stashSha, `stash@{0}: ${stashMessage}`);
+        // Reset working directory to HEAD
+        await git.checkout({ fs, dir, ref: headSha, force: true });
+        // Restore originally staged files
+        for (const filepath of stagedFiles) {
+            await git.add({ fs, dir, filepath });
+        }
+    }
+    async stashList(dir) {
+        return await this.readStashReflog(dir);
+    }
+    async stashApply(dir, stashRef) {
+        const stashes = await this.readStashReflog(dir);
+        if (stashes.length === 0) {
+            throw new Error('No stash entries found');
+        }
+        let stashEntry;
+        if (stashRef) {
+            const match = stashRef.match(/stash@\{(\d+)\}/);
+            const index = match ? parseInt(match[1]) : 0;
+            stashEntry = stashes[index];
+            if (!stashEntry) {
+                throw new Error(`Stash entry not found: ${stashRef}`);
+            }
+        }
+        else {
+            stashEntry = stashes[0]; // Most recent
+        }
+        // Read commit to get files
+        const commit = await git.readCommit({ fs, dir, oid: stashEntry.ref });
+        // Checkout files from stash commit
+        await git.checkout({
+            fs,
+            dir,
+            ref: stashEntry.ref,
+            force: false,
+            filepaths: undefined,
+        });
+    }
+    async stashPop(dir, stashRef) {
+        await this.stashApply(dir, stashRef);
+        await this.stashDrop(dir, stashRef);
+    }
+    async stashDrop(dir, stashRef) {
+        const stashes = await this.readStashReflog(dir);
+        if (stashes.length === 0) {
+            throw new Error('No stash entries found');
+        }
+        let indexToDrop = 0;
+        if (stashRef) {
+            const match = stashRef.match(/stash@\{(\d+)\}/);
+            indexToDrop = match ? parseInt(match[1]) : 0;
+        }
+        if (indexToDrop >= stashes.length) {
+            throw new Error(`Stash entry not found: ${stashRef || 'stash@{0}'}`);
+        }
+        // Rewrite reflog without the dropped entry
+        const reflogPath = this.getStashReflogPath(dir);
+        const content = fs.readFileSync(reflogPath, 'utf8');
+        const lines = content.trim().split('\n').filter(l => l);
+        lines.splice(lines.length - 1 - indexToDrop, 1);
+        if (lines.length > 0) {
+            fs.writeFileSync(reflogPath, lines.join('\n') + '\n');
+            // Update refs/stash to point to the new top
+            const newTopLine = lines[lines.length - 1];
+            const match = newTopLine.match(/^(\w+) (\w+)/);
+            if (match) {
+                fs.writeFileSync(this.getStashRefPath(dir), match[2] + '\n');
+            }
+        }
+        else {
+            // No more stashes, remove ref and reflog
+            if (fs.existsSync(this.getStashRefPath(dir))) {
+                fs.unlinkSync(this.getStashRefPath(dir));
+            }
+            if (fs.existsSync(reflogPath)) {
+                fs.unlinkSync(reflogPath);
+            }
+        }
+    }
+    async stashClear(dir) {
+        const reflogPath = this.getStashReflogPath(dir);
+        const refPath = this.getStashRefPath(dir);
+        if (fs.existsSync(reflogPath)) {
+            fs.unlinkSync(reflogPath);
+        }
+        if (fs.existsSync(refPath)) {
+            fs.unlinkSync(refPath);
+        }
+    }
+    // ========================================================================
+    // CONFIG OPERATIONS - Hybrid implementation (local + global/system)
+    // ========================================================================
+    /**
+     * Get global Git config path (~/.gitconfig)
+     */
+    getGlobalConfigPath() {
+        const homeDir = process.env.HOME || process.env.USERPROFILE || '';
+        return path.join(homeDir, '.gitconfig');
+    }
+    /**
+     * Get system Git config path
+     */
+    getSystemConfigPath() {
+        if (process.platform === 'win32') {
+            const programData = process.env.PROGRAMDATA || 'C:\\ProgramData';
+            return path.join(programData, 'Git', 'config');
+        }
+        else {
+            return '/etc/gitconfig';
+        }
+    }
+    /**
+     * Parse INI-style Git config file
+     */
+    parseGitConfig(content) {
+        const config = {};
+        const lines = content.split('\n');
+        let currentSection = '';
+        let currentSubsection = '';
+        for (const line of lines) {
+            const trimmed = line.trim();
+            // Skip empty lines and comments
+            if (!trimmed || trimmed.startsWith('#') || trimmed.startsWith(';')) {
+                continue;
+            }
+            // Match section headers: [section] or [section "subsection"]
+            const sectionMatch = trimmed.match(/^\[([^\]"]+)(?:\s+"([^"]+)")?\]$/);
+            if (sectionMatch) {
+                currentSection = sectionMatch[1];
+                currentSubsection = sectionMatch[2] || '';
+                continue;
+            }
+            // Match key-value pairs
+            const keyValueMatch = trimmed.match(/^([^=]+?)\s*=\s*(.*)$/);
+            if (keyValueMatch && currentSection) {
+                const key = keyValueMatch[1].trim();
+                const value = keyValueMatch[2].trim().replace(/^"|"$/g, ''); // Remove quotes
+                let fullKey = currentSection;
+                if (currentSubsection) {
+                    fullKey += `.${currentSubsection}`;
+                }
+                fullKey += `.${key}`;
+                config[fullKey] = value;
+            }
+        }
+        return config;
+    }
+    /**
+     * Write INI-style Git config file
+     */
+    writeGitConfig(config) {
+        const sections = {};
+        // Group by section
+        for (const [fullKey, value] of Object.entries(config)) {
+            const parts = fullKey.split('.');
+            if (parts.length >= 2) {
+                const section = parts.slice(0, -1).join('.');
+                const key = parts[parts.length - 1];
+                if (!sections[section]) {
+                    sections[section] = {};
+                }
+                sections[section][key] = value;
+            }
+        }
+        // Generate INI content
+        let content = '';
+        for (const [section, keys] of Object.entries(sections)) {
+            // Handle subsections: core.remote "origin" -> [core "origin"]
+            const sectionParts = section.split('.');
+            if (sectionParts.length > 1) {
+                content += `[${sectionParts[0]} "${sectionParts.slice(1).join('.')}"]\n`;
+            }
+            else {
+                content += `[${section}]\n`;
+            }
+            for (const [key, value] of Object.entries(keys)) {
+                if (value) { // Skip empty values
+                    content += `\t${key} = ${value}\n`;
+                }
+            }
+        }
+        return content;
+    }
+    async getConfig(dir, key, scope) {
+        if (scope === 'global') {
+            const globalConfigPath = this.getGlobalConfigPath();
+            if (fs.existsSync(globalConfigPath)) {
+                const content = fs.readFileSync(globalConfigPath, 'utf8');
+                const config = this.parseGitConfig(content);
+                return config[key];
+            }
+            return undefined;
+        }
+        else if (scope === 'system') {
+            const systemConfigPath = this.getSystemConfigPath();
+            if (fs.existsSync(systemConfigPath)) {
+                const content = fs.readFileSync(systemConfigPath, 'utf8');
+                const config = this.parseGitConfig(content);
+                return config[key];
+            }
+            return undefined;
+        }
+        else {
+            // Local config via isomorphic-git
+            return await git.getConfig({ fs, dir, path: key });
+        }
+    }
+    async setConfig(dir, key, value, scope) {
+        if (scope === 'global') {
+            const globalConfigPath = this.getGlobalConfigPath();
+            let config = {};
+            if (fs.existsSync(globalConfigPath)) {
+                const content = fs.readFileSync(globalConfigPath, 'utf8');
+                config = this.parseGitConfig(content);
+            }
+            config[key] = value;
+            const newContent = this.writeGitConfig(config);
+            fs.writeFileSync(globalConfigPath, newContent);
+        }
+        else if (scope === 'system') {
+            const systemConfigPath = this.getSystemConfigPath();
+            let config = {};
+            if (fs.existsSync(systemConfigPath)) {
+                const content = fs.readFileSync(systemConfigPath, 'utf8');
+                config = this.parseGitConfig(content);
+            }
+            config[key] = value;
+            const newContent = this.writeGitConfig(config);
+            fs.writeFileSync(systemConfigPath, newContent);
+        }
+        else {
+            // Local config via isomorphic-git
+            await git.setConfig({ fs, dir, path: key, value });
+        }
+    }
+    async listConfig(dir, scope) {
+        if (scope === 'global') {
+            const globalConfigPath = this.getGlobalConfigPath();
+            if (fs.existsSync(globalConfigPath)) {
+                const content = fs.readFileSync(globalConfigPath, 'utf8');
+                return this.parseGitConfig(content);
+            }
+            return {};
+        }
+        else if (scope === 'system') {
+            const systemConfigPath = this.getSystemConfigPath();
+            if (fs.existsSync(systemConfigPath)) {
+                const content = fs.readFileSync(systemConfigPath, 'utf8');
+                return this.parseGitConfig(content);
+            }
+            return {};
+        }
+        else {
+            // Local config - read .git/config directly
+            const configPath = path.join(dir, '.git', 'config');
+            if (fs.existsSync(configPath)) {
+                const content = fs.readFileSync(configPath, 'utf8');
+                return this.parseGitConfig(content);
+            }
+            return {};
+        }
+    }
+    // Alias for backwards compatibility
+    async getAllConfig(dir, scope) {
+        return this.listConfig(dir, scope);
+    }
+    async unsetConfig(dir, key, scope) {
+        if (scope === 'global') {
+            const globalConfigPath = this.getGlobalConfigPath();
+            if (fs.existsSync(globalConfigPath)) {
+                const content = fs.readFileSync(globalConfigPath, 'utf8');
+                const config = this.parseGitConfig(content);
+                delete config[key];
+                const newContent = this.writeGitConfig(config);
+                fs.writeFileSync(globalConfigPath, newContent);
+            }
+        }
+        else if (scope === 'system') {
+            const systemConfigPath = this.getSystemConfigPath();
+            if (fs.existsSync(systemConfigPath)) {
+                const content = fs.readFileSync(systemConfigPath, 'utf8');
+                const config = this.parseGitConfig(content);
+                delete config[key];
+                const newContent = this.writeGitConfig(config);
+                fs.writeFileSync(systemConfigPath, newContent);
+            }
+        }
+        else {
+            // Local config - isomorphic-git doesn't have unsetConfig
+            // We'll read, modify, and write the .git/config file
+            const configPath = path.join(dir, '.git', 'config');
+            if (fs.existsSync(configPath)) {
+                const content = fs.readFileSync(configPath, 'utf8');
+                const config = this.parseGitConfig(content);
+                delete config[key];
+                const newContent = this.writeGitConfig(config);
+                fs.writeFileSync(configPath, newContent);
+            }
+        }
+    }
+    // ========================================================================
+    // RESET CONVENIENCE METHODS
+    // ========================================================================
+    async resetSoft(dir, ref) {
+        return this.reset(dir, ref, 'soft');
+    }
+    async resetMixed(dir, ref) {
+        return this.reset(dir, ref, 'mixed');
+    }
+    async resetHard(dir, ref) {
+        return this.reset(dir, ref, 'hard');
+    }
+    // ========================================================================
+    // GITIGNORE MANAGEMENT
+    // ========================================================================
+    async createGitignore(dir, patterns) {
+        const gitignorePath = path.join(dir, '.gitignore');
+        fs.writeFileSync(gitignorePath, patterns.join('\n') + '\n');
+    }
+    async addToGitignore(dir, patterns) {
+        const gitignorePath = path.join(dir, '.gitignore');
+        let existing = '';
+        if (fs.existsSync(gitignorePath)) {
+            existing = fs.readFileSync(gitignorePath, 'utf8');
+        }
+        const newPatterns = patterns.filter(p => !existing.includes(p));
+        if (newPatterns.length > 0) {
+            fs.appendFileSync(gitignorePath, '\n' + newPatterns.join('\n') + '\n');
+        }
+    }
+    async removeFromGitignore(dir, patterns) {
+        const gitignorePath = path.join(dir, '.gitignore');
+        if (!fs.existsSync(gitignorePath))
+            return;
+        let content = fs.readFileSync(gitignorePath, 'utf8');
+        const lines = content.split('\n');
+        const filtered = lines.filter(line => !patterns.includes(line.trim()));
+        fs.writeFileSync(gitignorePath, filtered.join('\n'));
+    }
+    async listGitignore(dir) {
+        const gitignorePath = path.join(dir, '.gitignore');
+        if (!fs.existsSync(gitignorePath))
+            return [];
+        const content = fs.readFileSync(gitignorePath, 'utf8');
+        return content.split('\n')
+            .map(line => line.trim())
+            .filter(line => line && !line.startsWith('#'));
+    }
+    // ========================================================================
+    // FILE OPERATIONS
+    // ========================================================================
+    async readFile(dir, filepath, ref = 'HEAD') {
+        try {
+            const oid = await git.resolveRef({ fs, dir, ref });
+            const { blob } = await git.readBlob({
+                fs,
+                dir,
+                oid,
+                filepath,
+            });
+            return Buffer.from(blob).toString('utf8');
+        }
+        catch (err) {
+            // Fallback to reading from working directory
+            const fullPath = path.join(dir, filepath);
+            if (fs.existsSync(fullPath)) {
+                return fs.readFileSync(fullPath, 'utf8');
+            }
+            throw new Error(`File not found: ${filepath}`);
+        }
+    }
+    async listFiles(dir, ref = 'HEAD') {
+        try {
+            const oid = await git.resolveRef({ fs, dir, ref });
+            const tree = await git.listFiles({ fs, dir, ref: oid });
+            return tree;
+        }
+        catch (err) {
+            // Fallback to reading working directory
+            const files = [];
+            const walk = (currentPath, relativePath = '') => {
+                const entries = fs.readdirSync(currentPath, { withFileTypes: true });
+                for (const entry of entries) {
+                    if (entry.name === '.git')
+                        continue;
+                    const fullPath = path.join(currentPath, entry.name);
+                    const relPath = path.join(relativePath, entry.name);
+                    if (entry.isDirectory()) {
+                        walk(fullPath, relPath);
+                    }
+                    else {
+                        files.push(relPath.replace(/\\/g, '/'));
+                    }
+                }
+            };
+            walk(dir);
+            return files;
+        }
+    }
+}
+//# sourceMappingURL=gitAdapter.js.map