vibeteam 0.6.0 → 0.6.1

package/dist/server/server/GitStatusManager.js

@@ -15,6 +15,10 @@ export class GitStatusManager {
     directories = new Map(); // sessionId -> { directory, isWorktree, sourceRepo }
     pollInterval = null;
     onUpdate = null;
+    // Per-session timestamp (ms) of the most recent successful `git fetch`
+    // — surfaced via gitStatus.lastFetched so the Git panel can show
+    // "fetched Xm ago".
+    lastFetchPerSession = new Map();
     // PERFORMANCE: Activity-based state for adaptive polling
     isActivityChecker = null; // Function to check if any agent is working
     sessionStatusChecker = null; // Function to check session status by ID
@@ -22,6 +26,7 @@ export class GitStatusManager {
     POLL_INTERVAL_ACTIVE_MS = 15000;  // 15s when agent is working (was 5s)
     POLL_INTERVAL_IDLE_MS = 60000;   // 60s when idle (was 30s)
     EXEC_TIMEOUT_MS = 5000; // Timeout for git commands
+    MANUAL_FETCH_TIMEOUT_MS = 30000; // Longer timeout for user-triggered fetches
     FETCH_INTERVAL_MS = 120000; // Fetch from remote every 120s (was 60s)
     lastFetchTime = 0;
     currentPollInterval = 60000; // Start with idle interval
@@ -81,6 +86,7 @@ export class GitStatusManager {
     untrack(sessionId) {
         this.directories.delete(sessionId);
         this.statusCache.delete(sessionId);
+        this.lastFetchPerSession.delete(sessionId);
     }
     /**
      * Get cached status for a session
@@ -151,18 +157,26 @@ export class GitStatusManager {
         const now = Date.now();
         if (now - this.lastFetchTime > this.FETCH_INTERVAL_MS) {
             this.lastFetchTime = now;
-            // Fetch in background for all unique directories (skip stopped/offline)
-            const uniqueDirs = new Set();
+            // Fetch in background per unique directory; record per-session
+            // timestamps for the sessions that share each dir.
+            const dirToSessions = new Map();
             for (const [sessionId, info] of this.directories) {
                 // PERFORMANCE: Skip stopped/offline sessions for git fetch
                 if (this.sessionStatusChecker) {
                     const status = this.sessionStatusChecker(sessionId);
                     if (status === 'offline' || status === 'stopped') continue;
                 }
-                uniqueDirs.add(info.sourceRepo || info.directory);
+                const dir = info.sourceRepo || info.directory;
+                if (!dirToSessions.has(dir)) dirToSessions.set(dir, []);
+                dirToSessions.get(dir).push(sessionId);
             }
-            for (const dir of uniqueDirs) {
-                this.execGit(['fetch', '--quiet'], dir).catch(() => { }); // Silent fail
+            for (const [dir, sids] of dirToSessions) {
+                this.execGit(['fetch', '--quiet'], dir)
+                    .then(() => {
+                        const fetchedAt = Date.now();
+                        for (const sid of sids) this.lastFetchPerSession.set(sid, fetchedAt);
+                    })
+                    .catch(() => { /* silent */ });
             }
         }
         // PERFORMANCE: Skip stopped/offline sessions for status polling
@@ -185,6 +199,8 @@ export class GitStatusManager {
         if (!info)
             return null;
         const status = await this.getGitStatus(info.directory, info.isWorktree);
+        // Decorate with per-session metadata (last successful `git fetch` ms).
+        status.lastFetched = this.lastFetchPerSession.get(sessionId) ?? null;
         // Check if status changed
         const oldStatus = this.statusCache.get(sessionId);
         const changed = !oldStatus || this.hasStatusChanged(oldStatus, status);
@@ -206,7 +222,8 @@ export class GitStatusManager {
             old.totalFiles !== current.totalFiles ||
             old.linesAdded !== current.linesAdded ||
             old.linesRemoved !== current.linesRemoved ||
-            old.lastCommitTime !== current.lastCommitTime);
+            old.lastCommitTime !== current.lastCommitTime ||
+            old.lastFetched !== current.lastFetched);
     }
     /**
      * Get git status for a directory
@@ -254,45 +271,7 @@ export class GitStatusManager {
         status.branch = branchResult.trim();
         // Parse ahead/behind - for worktrees, compare against origin/main
         try {
-            let compareRef;
-            if (isWorktree) {
-                // For worktrees, compare against origin/main (or origin/master as fallback)
-                try {
-                    await this.execGit(['rev-parse', 'origin/main'], directory);
-                    compareRef = 'origin/main';
-                }
-                catch {
-                    try {
-                        await this.execGit(['rev-parse', 'origin/master'], directory);
-                        compareRef = 'origin/master';
-                    }
-                    catch {
-                        compareRef = null;
-                    }
-                }
-            }
-            else {
-                // For regular repos, try upstream first, then origin/main
-                try {
-                    await this.execGit(['rev-parse', '@{upstream}'], directory);
-                    compareRef = '@{upstream}';
-                }
-                catch {
-                    try {
-                        await this.execGit(['rev-parse', 'origin/main'], directory);
-                        compareRef = 'origin/main';
-                    }
-                    catch {
-                        try {
-                            await this.execGit(['rev-parse', 'origin/master'], directory);
-                            compareRef = 'origin/master';
-                        }
-                        catch {
-                            compareRef = null;
-                        }
-                    }
-                }
-            }
+            const compareRef = await this.resolveCompareRef(directory, isWorktree);
             if (compareRef) {
                 const abResult = await this.execGit(['rev-list', '--left-right', '--count', `${compareRef}...HEAD`], directory);
                 const [behind, ahead] = abResult.trim().split(/\s+/).map(Number);
@@ -372,11 +351,327 @@ export class GitStatusManager {
      * Execute a git command in a directory using execFile (no shell).
      * Args should be passed as an array, not a string, to prevent command injection.
      */
-    async execGit(args, cwd) {
+    async execGit(args, cwd, timeoutMs) {
         const { stdout } = await execFileAsync('git', args, {
             cwd,
-            timeout: this.EXEC_TIMEOUT_MS,
+            timeout: typeof timeoutMs === 'number' ? timeoutMs : this.EXEC_TIMEOUT_MS,
         });
         return stdout;
     }
+    /**
+     * Resolve a session's working directory or throw a typed error.
+     */
+    resolveDirectory(sessionId) {
+        const info = this.directories.get(sessionId);
+        if (!info) {
+            const err = new Error('not_tracked');
+            err.code = 'not_tracked';
+            throw err;
+        }
+        return info.directory;
+    }
+    /**
+     * Translate exec errors into a stable code surface for callers.
+     */
+    classifyExecError(err) {
+        if (!err) return 'unknown';
+        if (err.code === 'ENOENT') return 'git_unavailable';
+        const msg = String(err.stderr || err.message || '').toLowerCase();
+        if (msg.includes('not a git repository')) return 'not_a_repo';
+        if (msg.includes('no such file or directory')) return 'path_missing';
+        if (msg.includes('does not exist') && msg.includes('path')) return 'path_missing';
+        if (msg.includes('could not resolve host') || msg.includes('connection') || msg.includes('network is unreachable')) return 'network_error';
+        if (msg.includes('authentication') || msg.includes('permission denied') || msg.includes('could not read username')) return 'auth_error';
+        return 'git_error';
+    }
+    /**
+     * Resolve the upstream comparison ref for a directory.
+     * - Worktrees skip the local upstream and compare directly against origin/main(/master)
+     * - Regular repos prefer @{upstream}, falling back to origin/main(/master)
+     * Returns null if no usable ref exists.
+     */
+    async resolveCompareRef(directory, isWorktree) {
+        const tryRef = async (ref) => {
+            try {
+                await this.execGit(['rev-parse', ref], directory);
+                return ref;
+            } catch {
+                return null;
+            }
+        };
+        if (!isWorktree) {
+            const upstream = await tryRef('@{upstream}');
+            if (upstream) return upstream;
+        }
+        return (await tryRef('origin/main')) || (await tryRef('origin/master'));
+    }
+    /**
+     * Manually fetch from the remote for this session (user-triggered).
+     * Records the timestamp on success and re-polls status so ahead/behind
+     * counts reflect the new remote state.
+     */
+    async fetchRemote(sessionId) {
+        const directory = this.resolveDirectory(sessionId);
+        const info = this.directories.get(sessionId);
+        const fetchTarget = info.sourceRepo || directory;
+        try {
+            await this.execGit(['fetch', '--prune', '--quiet'], fetchTarget, this.MANUAL_FETCH_TIMEOUT_MS);
+        } catch (err) {
+            const code = this.classifyExecError(err);
+            const e = new Error(code);
+            e.code = code;
+            throw e;
+        }
+        const fetchedAt = Date.now();
+        // Record for every session that shares this fetch target dir.
+        for (const [sid, sInfo] of this.directories) {
+            if ((sInfo.sourceRepo || sInfo.directory) === fetchTarget) {
+                this.lastFetchPerSession.set(sid, fetchedAt);
+            }
+        }
+        // Refresh status so ahead/behind reflects the new remote refs.
+        const status = await this.fetchStatus(sessionId);
+        return { lastFetched: fetchedAt, status };
+    }
+    /**
+     * List incoming commits — i.e. commits reachable from the configured
+     * upstream/origin ref but not from HEAD. Useful for "what would I get if
+     * I pulled?". Returns empty array when there is no upstream or the
+     * branch is up-to-date.
+     */
+    async getIncoming(sessionId, limit = 20) {
+        const directory = this.resolveDirectory(sessionId);
+        const info = this.directories.get(sessionId);
+        const compareRef = await this.resolveCompareRef(directory, info.isWorktree);
+        if (!compareRef) return { commits: [], hasMore: false, compareRef: null };
+        const safeLimit = Math.max(1, Math.min(100, Math.floor(Number(limit) || 20)));
+        const fmt = ['%H', '%h', '%s', '%an', '%ae', '%ct', '%P'].join('%x1f');
+        try {
+            const out = await this.execGit(
+                ['log', `HEAD..${compareRef}`, `-n${safeLimit + 1}`, `--format=${fmt}`],
+                directory
+            );
+            const lines = out.split('\n').filter((l) => l.length > 0);
+            const trimmed = lines.slice(0, safeLimit);
+            const hasMore = lines.length > safeLimit;
+            const commits = trimmed.map(parseCommitLine);
+            return { commits, hasMore, compareRef };
+        } catch (err) {
+            const msg = String(err.stderr || err.message || '').toLowerCase();
+            if (msg.includes('unknown revision') || msg.includes('bad revision')) {
+                return { commits: [], hasMore: false, compareRef };
+            }
+            const code = this.classifyExecError(err);
+            const e = new Error(code);
+            e.code = code;
+            throw e;
+        }
+    }
+    /**
+     * List changed files (staged, unstaged, untracked) for a session.
+     * Uses porcelain v1 with -z for NUL-safe parsing of paths and renames.
+     */
+    async getFiles(sessionId) {
+        const directory = this.resolveDirectory(sessionId);
+        try {
+            const [statusOut, diffNumstatOut, diffCachedNumstatOut] = await Promise.all([
+                this.execGit(['status', '--porcelain=v1', '-z'], directory),
+                this.execGit(['diff', '--numstat', '-z'], directory).catch(() => ''),
+                this.execGit(['diff', '--cached', '--numstat', '-z'], directory).catch(() => ''),
+            ]);
+            const files = parsePorcelainZ(statusOut);
+            const unstagedStats = parseNumstatZ(diffNumstatOut);
+            const stagedStats = parseNumstatZ(diffCachedNumstatOut);
+            for (const file of files) {
+                const u = unstagedStats.get(file.path);
+                const s = stagedStats.get(file.path);
+                let added = 0;
+                let removed = 0;
+                let hasStat = false;
+                if (u) { added += u.added; removed += u.removed; hasStat = true; }
+                if (s) { added += s.added; removed += s.removed; hasStat = true; }
+                if (hasStat) {
+                    file.linesAdded = added;
+                    file.linesRemoved = removed;
+                }
+            }
+            return files;
+        }
+        catch (err) {
+            const code = this.classifyExecError(err);
+            const e = new Error(code);
+            e.code = code;
+            throw e;
+        }
+    }
+    /**
+     * List recent commits, paginated via `before` (exclusive cursor).
+     */
+    async getCommits(sessionId, limit = 20, beforeSha) {
+        const directory = this.resolveDirectory(sessionId);
+        const safeLimit = Math.max(1, Math.min(100, Math.floor(Number(limit) || 20)));
+        const ref = beforeSha ? `${beforeSha}~1` : 'HEAD';
+        const fmt = ['%H', '%h', '%s', '%an', '%ae', '%ct', '%P'].join('%x1f');
+        try {
+            const out = await this.execGit(
+                ['log', ref, `-n${safeLimit + 1}`, `--format=${fmt}`],
+                directory
+            );
+            const lines = out.split('\n').filter((l) => l.length > 0);
+            const trimmed = lines.slice(0, safeLimit);
+            const hasMore = lines.length > safeLimit;
+            const commits = trimmed.map(parseCommitLine);
+            return { commits, hasMore };
+        }
+        catch (err) {
+            // Empty repo with no HEAD → return an empty list, not an error.
+            const msg = String(err.stderr || err.message || '').toLowerCase();
+            if (msg.includes('does not have any commits') || msg.includes('unknown revision') || msg.includes('bad revision')) {
+                return { commits: [], hasMore: false };
+            }
+            const code = this.classifyExecError(err);
+            const e = new Error(code);
+            e.code = code;
+            throw e;
+        }
+    }
+    /**
+     * Get detailed info for a single commit, including per-file numstat.
+     */
+    async getCommitDetail(sessionId, sha) {
+        const directory = this.resolveDirectory(sessionId);
+        if (!/^[a-f0-9]{4,40}$/i.test(sha)) {
+            const e = new Error('invalid_sha');
+            e.code = 'invalid_sha';
+            throw e;
+        }
+        try {
+            const fmt = ['%H', '%an', '%ae', '%ct', '%P', '%s', '%b'].join('%x1f');
+            const headerOut = await this.execGit(
+                ['show', '-s', `--format=${fmt}`, sha],
+                directory
+            );
+            const numstatOut = await this.execGit(
+                ['show', '--numstat', '--format=', sha],
+                directory
+            );
+            const parts = headerOut.replace(/\n+$/, '').split('\x1f');
+            const [hash, authorName, authorEmail, ts, parents, subject, body] = parts;
+            const files = numstatOut
+                .split('\n')
+                .map((l) => l.trim())
+                .filter(Boolean)
+                .map((line) => {
+                    const cols = line.split('\t');
+                    if (cols.length < 3) return null;
+                    const added = cols[0] === '-' ? 0 : parseInt(cols[0], 10) || 0;
+                    const removed = cols[1] === '-' ? 0 : parseInt(cols[1], 10) || 0;
+                    return { path: cols[2], linesAdded: added, linesRemoved: removed };
+                })
+                .filter(Boolean);
+            return {
+                hash,
+                shortHash: hash.slice(0, 7),
+                subject: subject || '',
+                authorName,
+                authorEmail,
+                timestamp: parseInt(ts, 10) || 0,
+                parents: parents ? parents.split(' ').filter(Boolean) : [],
+                body: (body || '').replace(/\n+$/, ''),
+                files,
+            };
+        }
+        catch (err) {
+            const msg = String(err.stderr || err.message || '').toLowerCase();
+            if (msg.includes('unknown revision') || msg.includes('bad revision') || msg.includes('ambiguous argument')) {
+                const e = new Error('not_found');
+                e.code = 'not_found';
+                throw e;
+            }
+            const code = this.classifyExecError(err);
+            const e = new Error(code);
+            e.code = code;
+            throw e;
+        }
+    }
+}
+
+// ============================================================================
+// Helpers (porcelain -z and numstat -z parsing)
+// ============================================================================
+
+function parsePorcelainZ(input) {
+    if (!input) return [];
+    const tokens = input.split('\0');
+    const files = [];
+    for (let i = 0; i < tokens.length; i++) {
+        const entry = tokens[i];
+        if (!entry) continue;
+        if (entry.length < 3) continue;
+        const code = entry.slice(0, 2);
+        const path = entry.slice(3);
+        const staged = code[0];
+        const unstaged = code[1];
+        const isUntracked = staged === '?' && unstaged === '?';
+        const isRename = staged === 'R' || staged === 'C';
+        let oldPath;
+        if (isRename) {
+            // -z renames: next token is the original path
+            const next = tokens[i + 1];
+            if (next != null) {
+                oldPath = next;
+                i += 1;
+            }
+        }
+        files.push({
+            path,
+            ...(oldPath ? { oldPath } : {}),
+            statusStaged: staged,
+            statusUnstaged: unstaged,
+            isUntracked,
+        });
+    }
+    return files;
+}
+
+function parseNumstatZ(input) {
+    const map = new Map();
+    if (!input) return map;
+    // `git diff --numstat -z` emits records separated by NUL.
+    // Each record: "<added>\t<removed>\t<path>" — for renames it becomes:
+    //   "<added>\t<removed>\t\0<oldpath>\0<newpath>"
+    const tokens = input.split('\0');
+    for (let i = 0; i < tokens.length; i++) {
+        const t = tokens[i];
+        if (!t) continue;
+        const cols = t.split('\t');
+        if (cols.length < 3) continue;
+        const added = cols[0] === '-' ? 0 : parseInt(cols[0], 10) || 0;
+        const removed = cols[1] === '-' ? 0 : parseInt(cols[1], 10) || 0;
+        let pathField = cols[2];
+        if (pathField === '') {
+            // rename: next two tokens are oldpath, newpath
+            const oldPath = tokens[i + 1];
+            const newPath = tokens[i + 2];
+            i += 2;
+            if (newPath) map.set(newPath, { added, removed });
+            if (oldPath && oldPath !== newPath) map.set(oldPath, { added, removed });
+        } else {
+            map.set(pathField, { added, removed });
+        }
+    }
+    return map;
+}
+
+function parseCommitLine(line) {
+    const [hash, shortHash, subject, authorName, authorEmail, ts, parents] = line.split('\x1f');
+    return {
+        hash: hash || '',
+        shortHash: shortHash || (hash ? hash.slice(0, 7) : ''),
+        subject: subject || '',
+        authorName: authorName || '',
+        authorEmail: authorEmail || '',
+        timestamp: parseInt(ts, 10) || 0,
+        parents: parents ? parents.split(' ').filter(Boolean) : [],
+    };
 }