claudedesk 4.3.1 → 4.4.0

package/dist/main/git-manager.js

@@ -0,0 +1,841 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GitManager = void 0;
+const child_process_1 = require("child_process");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const ipc_emitter_1 = require("./ipc-emitter");
+class GitManager {
+    constructor(checkpointManager) {
+        this.emitter = null;
+        this.watchers = new Map();
+        this.debounceTimers = new Map();
+        this.mutexes = new Map();
+        this.gitBinary = null;
+        this.defaultTimeoutMs = 30000;
+        this.maxDiffSizeBytes = 102400; // 100KB
+        this.checkpointManager = checkpointManager || null;
+        this.detectGitBinary();
+    }
+    setMainWindow(window) {
+        this.emitter = new ipc_emitter_1.IPCEmitter(window);
+    }
+    destroy() {
+        for (const [workDir, watcher] of this.watchers) {
+            watcher.close();
+            const timer = this.debounceTimers.get(workDir);
+            if (timer)
+                clearTimeout(timer);
+        }
+        this.watchers.clear();
+        this.debounceTimers.clear();
+        this.mutexes.clear();
+        this.emitter = null;
+    }
+    // ── Git binary detection ──
+    detectGitBinary() {
+        const cmd = process.platform === 'win32' ? 'where' : 'which';
+        const arg = 'git';
+        try {
+            (0, child_process_1.execFile)(cmd, [arg], { timeout: 5000 }, (err, stdout) => {
+                if (!err && stdout.trim()) {
+                    this.gitBinary = stdout.trim().split('\n')[0].trim();
+                    console.log('[GitManager] Found git binary:', this.gitBinary);
+                }
+                else {
+                    console.warn('[GitManager] Git binary not found');
+                    this.gitBinary = null;
+                }
+            });
+        }
+        catch {
+            this.gitBinary = null;
+        }
+    }
+    // ── Low-level command execution ──
+    execGit(workDir, args, timeoutMs) {
+        return new Promise((resolve) => {
+            const binary = this.gitBinary || 'git';
+            const timeout = timeoutMs || this.defaultTimeoutMs;
+            (0, child_process_1.execFile)(binary, args, {
+                cwd: workDir,
+                timeout,
+                maxBuffer: 10 * 1024 * 1024, // 10MB
+                env: { ...process.env, GIT_TERMINAL_PROMPT: '0' },
+            }, (err, stdout, stderr) => {
+                const exitCode = err && 'code' in err ? err.code : (err ? 1 : 0);
+                resolve({
+                    stdout: stdout || '',
+                    stderr: stderr || '',
+                    exitCode: typeof exitCode === 'number' ? exitCode : 1,
+                });
+            });
+        });
+    }
+    async withMutex(workDir, fn) {
+        const prev = this.mutexes.get(workDir) || Promise.resolve();
+        let resolve;
+        const next = new Promise((r) => { resolve = r; });
+        this.mutexes.set(workDir, next);
+        await prev;
+        try {
+            return await fn();
+        }
+        finally {
+            resolve();
+        }
+    }
+    detectErrorCode(stderr, exitCode) {
+        const msg = stderr.toLowerCase();
+        if (msg.includes('not a git repository'))
+            return 'NOT_A_REPO';
+        if (msg.includes('authentication failed') || msg.includes('could not read username'))
+            return 'AUTH_FAILED';
+        if (msg.includes('merge conflict') || msg.includes('unmerged'))
+            return 'MERGE_CONFLICTS';
+        if (msg.includes('no upstream') || msg.includes('has no upstream branch'))
+            return 'NO_UPSTREAM';
+        if (msg.includes('rejected') || msg.includes('non-fast-forward'))
+            return 'PUSH_REJECTED';
+        if (msg.includes('already exists'))
+            return 'BRANCH_EXISTS';
+        if (msg.includes('not found') || msg.includes('did not match'))
+            return 'BRANCH_NOT_FOUND';
+        if (msg.includes('uncommitted changes') || msg.includes('local changes'))
+            return 'UNCOMMITTED_CHANGES';
+        if (msg.includes('nothing to commit'))
+            return 'NOTHING_TO_COMMIT';
+        if (exitCode === 128)
+            return 'NOT_A_REPO';
+        return 'UNKNOWN';
+    }
+    makeError(stderr, exitCode) {
+        const errorCode = this.detectErrorCode(stderr, exitCode);
+        return {
+            success: false,
+            message: stderr.trim() || `Git operation failed (exit code ${exitCode})`,
+            errorCode,
+        };
+    }
+    // ── Status parsing (porcelain v2) ──
+    parseStatus(raw) {
+        const status = {
+            isRepo: true,
+            isDetached: false,
+            hasConflicts: false,
+            branch: null,
+            upstream: null,
+            ahead: 0,
+            behind: 0,
+            files: [],
+            stagedCount: 0,
+            unstagedCount: 0,
+            untrackedCount: 0,
+            conflictedCount: 0,
+        };
+        const lines = raw.split('\n');
+        for (const line of lines) {
+            if (!line)
+                continue;
+            // Branch headers
+            if (line.startsWith('# branch.head ')) {
+                const head = line.slice('# branch.head '.length);
+                if (head === '(detached)') {
+                    status.isDetached = true;
+                    status.branch = null;
+                }
+                else {
+                    status.branch = head;
+                }
+                continue;
+            }
+            if (line.startsWith('# branch.upstream ')) {
+                status.upstream = line.slice('# branch.upstream '.length);
+                continue;
+            }
+            if (line.startsWith('# branch.ab ')) {
+                const match = line.match(/\+(\d+) -(\d+)/);
+                if (match) {
+                    status.ahead = parseInt(match[1], 10);
+                    status.behind = parseInt(match[2], 10);
+                }
+                continue;
+            }
+            // Changed entries (ordinary): 1 XY N1 N2 N3 hH hI path
+            if (line.startsWith('1 ')) {
+                const parts = line.split(' ');
+                if (parts.length >= 9) {
+                    const xy = parts[1];
+                    const filePath = parts.slice(8).join(' ');
+                    const indexChar = xy[0];
+                    const workChar = xy[1];
+                    // Staged change
+                    if (indexChar !== '.') {
+                        status.files.push({
+                            path: filePath,
+                            originalPath: null,
+                            indexStatus: this.charToStatus(indexChar),
+                            workTreeStatus: this.charToStatus(workChar),
+                            area: 'staged',
+                        });
+                        status.stagedCount++;
+                    }
+                    // Unstaged change (not already counted if also staged)
+                    if (workChar !== '.' && indexChar === '.') {
+                        status.files.push({
+                            path: filePath,
+                            originalPath: null,
+                            indexStatus: this.charToStatus(indexChar),
+                            workTreeStatus: this.charToStatus(workChar),
+                            area: 'unstaged',
+                        });
+                        status.unstagedCount++;
+                    }
+                    else if (workChar !== '.' && indexChar !== '.') {
+                        // Both staged and unstaged changes
+                        status.files.push({
+                            path: filePath,
+                            originalPath: null,
+                            indexStatus: this.charToStatus(indexChar),
+                            workTreeStatus: this.charToStatus(workChar),
+                            area: 'unstaged',
+                        });
+                        status.unstagedCount++;
+                    }
+                }
+                continue;
+            }
+            // Renamed entries: 2 XY N1 N2 N3 hH hI Rxx path\torigPath
+            if (line.startsWith('2 ')) {
+                const parts = line.split('\t');
+                if (parts.length >= 2) {
+                    const firstParts = parts[0].split(' ');
+                    const xy = firstParts[1];
+                    const filePath = parts[0].split(' ').slice(9).join(' ');
+                    const originalPath = parts[1];
+                    const indexChar = xy[0];
+                    if (indexChar !== '.') {
+                        status.files.push({
+                            path: filePath,
+                            originalPath,
+                            indexStatus: 'renamed',
+                            workTreeStatus: this.charToStatus(xy[1]),
+                            area: 'staged',
+                        });
+                        status.stagedCount++;
+                    }
+                }
+                continue;
+            }
+            // Unmerged entries: u XY N1 N2 N3 N4 h1 h2 h3 path
+            if (line.startsWith('u ')) {
+                const parts = line.split(' ');
+                if (parts.length >= 11) {
+                    const filePath = parts.slice(10).join(' ');
+                    status.files.push({
+                        path: filePath,
+                        originalPath: null,
+                        indexStatus: 'unmerged',
+                        workTreeStatus: 'unmerged',
+                        area: 'conflicted',
+                    });
+                    status.conflictedCount++;
+                    status.hasConflicts = true;
+                }
+                continue;
+            }
+            // Untracked entries: ? path
+            if (line.startsWith('? ')) {
+                const filePath = line.slice(2);
+                status.files.push({
+                    path: filePath,
+                    originalPath: null,
+                    indexStatus: 'untracked',
+                    workTreeStatus: 'untracked',
+                    area: 'untracked',
+                });
+                status.untrackedCount++;
+                continue;
+            }
+        }
+        return status;
+    }
+    charToStatus(c) {
+        switch (c) {
+            case 'A': return 'added';
+            case 'M': return 'modified';
+            case 'D': return 'deleted';
+            case 'R': return 'renamed';
+            case 'C': return 'copied';
+            case '?': return 'untracked';
+            case '!': return 'ignored';
+            case 'U': return 'unmerged';
+            default: return 'modified';
+        }
+    }
+    // ── Branch parsing ──
+    parseBranches(raw) {
+        const branches = [];
+        const lines = raw.split('\n').filter(l => l.trim());
+        for (const line of lines) {
+            // Format: "branchname upstream:short upstream:track"
+            // e.g. "main origin/main [ahead 1]"
+            // or  "* main origin/main [ahead 1, behind 2]"
+            const isCurrent = line.startsWith('* ');
+            const clean = isCurrent ? line.slice(2) : line;
+            const parts = clean.trim().split(/\s+/);
+            const name = parts[0];
+            if (!name)
+                continue;
+            let upstream = null;
+            let ahead = 0;
+            let behind = 0;
+            if (parts.length > 1 && parts[1] && !parts[1].startsWith('[')) {
+                upstream = parts[1];
+            }
+            // Parse ahead/behind from track info
+            const trackMatch = clean.match(/\[ahead (\d+)(?:, behind (\d+))?\]/);
+            if (trackMatch) {
+                ahead = parseInt(trackMatch[1], 10);
+                behind = trackMatch[2] ? parseInt(trackMatch[2], 10) : 0;
+            }
+            const behindMatch = clean.match(/\[behind (\d+)\]/);
+            if (behindMatch && ahead === 0) {
+                behind = parseInt(behindMatch[1], 10);
+            }
+            branches.push({ name, isCurrent, upstream, ahead, behind });
+        }
+        return branches;
+    }
+    // ── Public API: Core status ──
+    async getStatus(workDir) {
+        return this.withMutex(workDir, async () => {
+            // Check if it's a git repo
+            const check = await this.execGit(workDir, ['rev-parse', '--is-inside-work-tree']);
+            if (check.exitCode !== 0) {
+                return {
+                    isRepo: false,
+                    isDetached: false,
+                    hasConflicts: false,
+                    branch: null,
+                    upstream: null,
+                    ahead: 0,
+                    behind: 0,
+                    files: [],
+                    stagedCount: 0,
+                    unstagedCount: 0,
+                    untrackedCount: 0,
+                    conflictedCount: 0,
+                };
+            }
+            const result = await this.execGit(workDir, ['status', '--porcelain=v2', '--branch']);
+            return this.parseStatus(result.stdout);
+        });
+    }
+    async getBranches(workDir) {
+        return this.withMutex(workDir, async () => {
+            const result = await this.execGit(workDir, [
+                'branch', '--list', '--format=%(if)%(HEAD)%(then)* %(end)%(refname:short) %(upstream:short) %(upstream:track)',
+            ]);
+            if (result.exitCode !== 0)
+                return [];
+            return this.parseBranches(result.stdout);
+        });
+    }
+    // ── Public API: Staging ──
+    async stageFiles(workDir, files) {
+        return this.withMutex(workDir, async () => {
+            const result = await this.execGit(workDir, ['add', '--', ...files]);
+            if (result.exitCode !== 0)
+                return this.makeError(result.stderr, result.exitCode);
+            return { success: true, message: `Staged ${files.length} file(s)`, errorCode: null };
+        });
+    }
+    async unstageFiles(workDir, files) {
+        return this.withMutex(workDir, async () => {
+            const result = await this.execGit(workDir, ['reset', 'HEAD', '--', ...files]);
+            if (result.exitCode !== 0)
+                return this.makeError(result.stderr, result.exitCode);
+            return { success: true, message: `Unstaged ${files.length} file(s)`, errorCode: null };
+        });
+    }
+    async stageAll(workDir) {
+        return this.withMutex(workDir, async () => {
+            const result = await this.execGit(workDir, ['add', '-A']);
+            if (result.exitCode !== 0)
+                return this.makeError(result.stderr, result.exitCode);
+            return { success: true, message: 'Staged all changes', errorCode: null };
+        });
+    }
+    async unstageAll(workDir) {
+        return this.withMutex(workDir, async () => {
+            const result = await this.execGit(workDir, ['reset', 'HEAD']);
+            if (result.exitCode !== 0)
+                return this.makeError(result.stderr, result.exitCode);
+            return { success: true, message: 'Unstaged all changes', errorCode: null };
+        });
+    }
+    // ── Public API: Commit ──
+    async commit(request) {
+        return this.withMutex(request.workingDirectory, async () => {
+            const result = await this.execGit(request.workingDirectory, ['commit', '-m', request.message]);
+            if (result.exitCode !== 0)
+                return this.makeError(result.stderr, result.exitCode);
+            // Parse commit hash from output
+            const hashMatch = result.stdout.match(/\[[\w\-/]+ ([a-f0-9]+)\]/);
+            const shortHash = hashMatch ? hashMatch[1] : 'unknown';
+            // Create checkpoint if requested
+            if (request.createCheckpoint && request.sessionId && this.checkpointManager) {
+                try {
+                    await this.checkpointManager.createCheckpoint({
+                        sessionId: request.sessionId,
+                        name: `git: ${shortHash} ${request.message}`.slice(0, 50),
+                        description: `Git commit: ${request.message}\n\nHash: ${shortHash}`,
+                        tags: ['git-commit'],
+                    });
+                }
+                catch (err) {
+                    console.warn('[GitManager] Failed to create checkpoint:', err);
+                }
+            }
+            return { success: true, message: `Committed: ${shortHash} ${request.message}`, errorCode: null };
+        });
+    }
+    async generateMessage(workDir) {
+        return this.withMutex(workDir, async () => {
+            // Get staged file stats
+            const statResult = await this.execGit(workDir, ['diff', '--cached', '--numstat']);
+            const nameResult = await this.execGit(workDir, ['diff', '--cached', '--name-only']);
+            if (!nameResult.stdout.trim()) {
+                return {
+                    message: 'chore: update files',
+                    type: 'chore',
+                    scope: null,
+                    description: 'update files',
+                    confidence: 'low',
+                    reasoning: 'No staged changes found',
+                };
+            }
+            const files = nameResult.stdout.trim().split('\n').filter(f => f);
+            let totalInsertions = 0;
+            let totalDeletions = 0;
+            // Parse numstat
+            const statLines = statResult.stdout.trim().split('\n').filter(l => l);
+            for (const line of statLines) {
+                const parts = line.split('\t');
+                if (parts.length >= 2) {
+                    const ins = parseInt(parts[0], 10);
+                    const del = parseInt(parts[1], 10);
+                    if (!isNaN(ins))
+                        totalInsertions += ins;
+                    if (!isNaN(del))
+                        totalDeletions += del;
+                }
+            }
+            // Analyze file types
+            const extensions = files.map(f => path.extname(f).toLowerCase());
+            const directories = files.map(f => {
+                const dir = path.dirname(f);
+                return dir === '.' ? '' : dir.split(/[/\\]/)[0];
+            });
+            // Detect type using heuristics
+            const { type, confidence, reasoning } = this.inferCommitType(files, extensions, totalInsertions, totalDeletions);
+            // Detect scope
+            const scope = this.inferScope(directories);
+            // Generate description
+            const description = this.generateDescription(files, extensions, totalInsertions, totalDeletions);
+            const message = scope
+                ? `${type}(${scope}): ${description}`
+                : `${type}: ${description}`;
+            return { message, type, scope, description, confidence, reasoning };
+        });
+    }
+    inferCommitType(files, _extensions, insertions, deletions) {
+        // Test files
+        if (files.every(f => f.includes('.test.') || f.includes('.spec.') || f.includes('__tests__/'))) {
+            return { type: 'test', confidence: 'high', reasoning: 'All changed files are test files' };
+        }
+        // Documentation files
+        if (files.every(f => {
+            const ext = path.extname(f).toLowerCase();
+            return ['.md', '.txt', '.rst'].includes(ext) || f.startsWith('docs/');
+        })) {
+            return { type: 'docs', confidence: 'high', reasoning: 'All changed files are documentation' };
+        }
+        // CI/CD files
+        if (files.every(f => f.includes('Dockerfile') || f.endsWith('.yml') || f.endsWith('.yaml') ||
+            f.startsWith('.github/') || f.includes('Jenkinsfile'))) {
+            return { type: 'ci', confidence: 'high', reasoning: 'All changed files are CI/CD configuration' };
+        }
+        // Style files (balanced changes)
+        if (files.every(f => {
+            const ext = path.extname(f).toLowerCase();
+            return ['.css', '.scss', '.less'].includes(ext);
+        })) {
+            const ratio = insertions > 0 ? deletions / insertions : 0;
+            if (ratio > 0.8 && ratio < 1.2) {
+                return { type: 'style', confidence: 'medium', reasoning: 'All changed files are stylesheets with balanced changes' };
+            }
+        }
+        // Build files
+        if (files.every(f => {
+            const name = path.basename(f).toLowerCase();
+            return name === 'package.json' || f.endsWith('.lock') ||
+                name.startsWith('webpack.') || name.startsWith('tsconfig.') || name.startsWith('vite.');
+        })) {
+            return { type: 'build', confidence: 'medium', reasoning: 'All changed files are build configuration' };
+        }
+        // Refactor (heavy deletions)
+        if (deletions > insertions * 2 && deletions > 50) {
+            return { type: 'refactor', confidence: 'medium', reasoning: `Deletions (${deletions}) significantly exceed insertions (${insertions})` };
+        }
+        // New feature (mostly additions)
+        if (files.every(f => !f.includes('.test.') && !f.includes('.spec.')) && insertions > 0 && deletions === 0) {
+            return { type: 'feat', confidence: 'medium', reasoning: 'Only additions, no modifications to existing files' };
+        }
+        // Small fix
+        if (files.length <= 3 && (insertions + deletions) < 20) {
+            return { type: 'fix', confidence: 'low', reasoning: `Small change: ${files.length} file(s), ${insertions + deletions} lines` };
+        }
+        return { type: 'chore', confidence: 'low', reasoning: 'No specific pattern detected' };
+    }
+    inferScope(directories) {
+        const nonEmpty = directories.filter(d => d);
+        if (nonEmpty.length === 0)
+            return null;
+        // Count occurrences
+        const counts = new Map();
+        for (const dir of nonEmpty) {
+            counts.set(dir, (counts.get(dir) || 0) + 1);
+        }
+        // If all in same directory, use it
+        if (counts.size === 1) {
+            return nonEmpty[0];
+        }
+        // If most files in one directory (>60%)
+        const sorted = [...counts.entries()].sort((a, b) => b[1] - a[1]);
+        if (sorted[0][1] / nonEmpty.length > 0.6) {
+            return sorted[0][0];
+        }
+        return null;
+    }
+    generateDescription(files, extensions, insertions, deletions) {
+        const count = files.length;
+        // Determine primary file type
+        const extCounts = new Map();
+        for (const ext of extensions) {
+            if (ext)
+                extCounts.set(ext, (extCounts.get(ext) || 0) + 1);
+        }
+        const primaryExt = [...extCounts.entries()].sort((a, b) => b[1] - a[1])[0];
+        const fileTypeMap = {
+            '.ts': 'TypeScript',
+            '.tsx': 'TypeScript',
+            '.js': 'JavaScript',
+            '.jsx': 'JavaScript',
+            '.css': 'CSS',
+            '.scss': 'SCSS',
+            '.md': 'markdown',
+            '.json': 'JSON',
+            '.py': 'Python',
+            '.rs': 'Rust',
+            '.go': 'Go',
+        };
+        const fileType = primaryExt ? (fileTypeMap[primaryExt[0]] || primaryExt[0].slice(1)) : 'files';
+        // Determine verb
+        let verb = 'update';
+        if (deletions === 0 && insertions > 0)
+            verb = 'add';
+        else if (insertions === 0 && deletions > 0)
+            verb = 'remove';
+        else if (deletions > insertions * 2)
+            verb = 'refactor';
+        if (count === 1) {
+            const basename = path.basename(files[0]);
+            return `${verb} ${basename}`;
+        }
+        return `${verb} ${count} ${fileType} files`;
+    }
+    // ── Public API: Remote operations ──
+    async push(workDir, setUpstream) {
+        return this.withMutex(workDir, async () => {
+            // Get current branch
+            const branchResult = await this.execGit(workDir, ['rev-parse', '--abbrev-ref', 'HEAD']);
+            const branch = branchResult.stdout.trim();
+            const args = setUpstream
+                ? ['push', '-u', 'origin', branch]
+                : ['push', 'origin', branch];
+            const result = await this.execGit(workDir, args);
+            if (result.exitCode !== 0)
+                return this.makeError(result.stderr, result.exitCode);
+            return { success: true, message: `Pushed to origin/${branch}`, errorCode: null };
+        });
+    }
+    async pull(workDir) {
+        return this.withMutex(workDir, async () => {
+            const result = await this.execGit(workDir, ['pull']);
+            if (result.exitCode !== 0)
+                return this.makeError(result.stderr, result.exitCode);
+            return { success: true, message: result.stdout.trim() || 'Pulled successfully', errorCode: null };
+        });
+    }
+    async fetch(workDir) {
+        return this.withMutex(workDir, async () => {
+            const result = await this.execGit(workDir, ['fetch', 'origin']);
+            if (result.exitCode !== 0)
+                return this.makeError(result.stderr, result.exitCode);
+            return { success: true, message: 'Fetched from origin', errorCode: null };
+        });
+    }
+    // ── Public API: Branches ──
+    async switchBranch(workDir, branch) {
+        return this.withMutex(workDir, async () => {
+            const result = await this.execGit(workDir, ['checkout', branch]);
+            if (result.exitCode !== 0)
+                return this.makeError(result.stderr, result.exitCode);
+            return { success: true, message: `Switched to branch '${branch}'`, errorCode: null };
+        });
+    }
+    async createBranch(workDir, branch) {
+        return this.withMutex(workDir, async () => {
+            const result = await this.execGit(workDir, ['checkout', '-b', branch]);
+            if (result.exitCode !== 0)
+                return this.makeError(result.stderr, result.exitCode);
+            return { success: true, message: `Created and switched to branch '${branch}'`, errorCode: null };
+        });
+    }
+    // ── Public API: History & Diff ──
+    async log(workDir, count = 50) {
+        return this.withMutex(workDir, async () => {
+            const result = await this.execGit(workDir, [
+                'log', `--format=%H|%h|%an|%ae|%aI|%s`, `-${count}`, '--shortstat',
+            ]);
+            if (result.exitCode !== 0)
+                return [];
+            const commits = [];
+            const lines = result.stdout.split('\n');
+            let current = null;
+            for (const line of lines) {
+                if (!line.trim())
+                    continue;
+                // Check if it's a commit line (starts with hash)
+                if (line.includes('|') && line.match(/^[a-f0-9]{40}\|/)) {
+                    if (current)
+                        commits.push(current);
+                    const parts = line.split('|');
+                    current = {
+                        hash: parts[0],
+                        shortHash: parts[1],
+                        authorName: parts[2],
+                        authorEmail: parts[3],
+                        date: parts[4],
+                        subject: parts.slice(5).join('|'),
+                        filesChanged: 0,
+                        insertions: 0,
+                        deletions: 0,
+                    };
+                }
+                else if (current && line.includes('file')) {
+                    // Parse shortstat: " 3 files changed, 45 insertions(+), 12 deletions(-)"
+                    const filesMatch = line.match(/(\d+) files? changed/);
+                    const insMatch = line.match(/(\d+) insertions?\(\+\)/);
+                    const delMatch = line.match(/(\d+) deletions?\(-\)/);
+                    if (filesMatch)
+                        current.filesChanged = parseInt(filesMatch[1], 10);
+                    if (insMatch)
+                        current.insertions = parseInt(insMatch[1], 10);
+                    if (delMatch)
+                        current.deletions = parseInt(delMatch[1], 10);
+                }
+            }
+            if (current)
+                commits.push(current);
+            return commits;
+        });
+    }
+    async diff(workDir, filePath, staged) {
+        return this.withMutex(workDir, async () => {
+            const args = staged
+                ? ['diff', '--cached', '--', filePath]
+                : ['diff', '--', filePath];
+            const result = await this.execGit(workDir, args);
+            const totalSize = Buffer.byteLength(result.stdout, 'utf-8');
+            const isTruncated = totalSize > this.maxDiffSizeBytes;
+            const diff = isTruncated
+                ? result.stdout.slice(0, this.maxDiffSizeBytes)
+                : result.stdout;
+            return { filePath, diff, isTruncated, totalSizeBytes: totalSize };
+        });
+    }
+    async commitDiff(workDir, hash) {
+        return this.withMutex(workDir, async () => {
+            // Get commit info
+            const logResult = await this.execGit(workDir, [
+                'log', `--format=%H|%h|%an|%ae|%aI|%s`, '-1', hash,
+            ]);
+            const statResult = await this.execGit(workDir, [
+                'diff-tree', '--no-commit-id', '-r', '--stat', hash,
+            ]);
+            const parts = logResult.stdout.trim().split('|');
+            const commit = {
+                hash: parts[0] || hash,
+                shortHash: parts[1] || hash.slice(0, 7),
+                authorName: parts[2] || '',
+                authorEmail: parts[3] || '',
+                date: parts[4] || '',
+                subject: parts.slice(5).join('|') || '',
+                filesChanged: 0,
+                insertions: 0,
+                deletions: 0,
+            };
+            // Parse stat output for file count
+            const statLines = statResult.stdout.trim().split('\n').filter(l => l.trim());
+            if (statLines.length > 0) {
+                const summaryLine = statLines[statLines.length - 1];
+                const filesMatch = summaryLine.match(/(\d+) files? changed/);
+                const insMatch = summaryLine.match(/(\d+) insertions?\(\+\)/);
+                const delMatch = summaryLine.match(/(\d+) deletions?\(-\)/);
+                if (filesMatch)
+                    commit.filesChanged = parseInt(filesMatch[1], 10);
+                if (insMatch)
+                    commit.insertions = parseInt(insMatch[1], 10);
+                if (delMatch)
+                    commit.deletions = parseInt(delMatch[1], 10);
+            }
+            return commit;
+        });
+    }
+    // ── Public API: Discard ──
+    async discardFile(workDir, filePath) {
+        return this.withMutex(workDir, async () => {
+            const result = await this.execGit(workDir, ['checkout', '--', filePath]);
+            if (result.exitCode !== 0)
+                return this.makeError(result.stderr, result.exitCode);
+            return { success: true, message: `Discarded changes to ${filePath}`, errorCode: null };
+        });
+    }
+    async discardAll(workDir) {
+        return this.withMutex(workDir, async () => {
+            const result = await this.execGit(workDir, ['checkout', '--', '.']);
+            if (result.exitCode !== 0)
+                return this.makeError(result.stderr, result.exitCode);
+            return { success: true, message: 'Discarded all unstaged changes', errorCode: null };
+        });
+    }
+    // ── Public API: Init ──
+    async init(workDir) {
+        return this.withMutex(workDir, async () => {
+            const result = await this.execGit(workDir, ['init']);
+            if (result.exitCode !== 0)
+                return this.makeError(result.stderr, result.exitCode);
+            return { success: true, message: 'Initialized git repository', errorCode: null };
+        });
+    }
+    // ── Public API: Watching ──
+    startWatching(workDir) {
+        if (this.watchers.has(workDir))
+            return true;
+        const gitDir = path.join(workDir, '.git');
+        if (!fs.existsSync(gitDir))
+            return false;
+        try {
+            const watcher = fs.watch(gitDir, { recursive: false }, () => {
+                this.debouncedRefresh(workDir);
+            });
+            // Also watch the index file specifically
+            const indexPath = path.join(gitDir, 'index');
+            if (fs.existsSync(indexPath)) {
+                try {
+                    const indexWatcher = fs.watch(indexPath, () => {
+                        this.debouncedRefresh(workDir);
+                    });
+                    // Store with a modified key
+                    this.watchers.set(workDir + ':index', indexWatcher);
+                }
+                catch {
+                    // Index watch failed, git dir watch is enough
+                }
+            }
+            this.watchers.set(workDir, watcher);
+            watcher.on('error', (err) => {
+                console.warn('[GitManager] Watch error for', workDir, err);
+                this.stopWatching(workDir);
+            });
+            return true;
+        }
+        catch (err) {
+            console.warn('[GitManager] Failed to watch', workDir, err);
+            return false;
+        }
+    }
+    stopWatching(workDir) {
+        const watcher = this.watchers.get(workDir);
+        if (watcher) {
+            watcher.close();
+            this.watchers.delete(workDir);
+        }
+        const indexWatcher = this.watchers.get(workDir + ':index');
+        if (indexWatcher) {
+            indexWatcher.close();
+            this.watchers.delete(workDir + ':index');
+        }
+        const timer = this.debounceTimers.get(workDir);
+        if (timer) {
+            clearTimeout(timer);
+            this.debounceTimers.delete(workDir);
+        }
+        return true;
+    }
+    debouncedRefresh(workDir) {
+        const existing = this.debounceTimers.get(workDir);
+        if (existing)
+            clearTimeout(existing);
+        const timer = setTimeout(async () => {
+            this.debounceTimers.delete(workDir);
+            try {
+                const status = await this.getStatus(workDir);
+                if (this.emitter) {
+                    this.emitter.emit('onGitStatusChanged', status);
+                }
+            }
+            catch (err) {
+                console.warn('[GitManager] Failed to refresh status for', workDir, err);
+            }
+        }, 500);
+        this.debounceTimers.set(workDir, timer);
+    }
+}
+exports.GitManager = GitManager;