relay-ide 0.1.0

package/dist/server/git.js

@@ -0,0 +1,694 @@
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { createLogger } from './logger.js';
+const execFileAsync = promisify(execFile);
+const logger = createLogger('git');
+function normalizeBranchNames(stdout) {
+    const branches = stdout
+        .split('\n')
+        .map((branch) => branch.trim())
+        .filter((branch) => branch && !branch.includes('HEAD'))
+        .map((branch) => branch.replace(/^origin\//, ''));
+    return [...new Set(branches)].sort();
+}
+async function listBranches(repoPath, options = {}) {
+    const run = options.exec || execFileAsync;
+    if (options.refresh) {
+        try {
+            await run('git', ['fetch', '--all', '--prune'], { cwd: repoPath });
+        }
+        catch {
+            // Best effort — still return the locally-known refs below.
+        }
+    }
+    try {
+        const { stdout } = await run('git', ['branch', '-a', '--format=%(refname:short)'], { cwd: repoPath });
+        return normalizeBranchNames(stdout);
+    }
+    catch {
+        return [];
+    }
+}
+async function getCurrentBranch(repoPath, options = {}) {
+    const run = options.exec || execFileAsync;
+    try {
+        const { stdout } = await run('git', ['rev-parse', '--abbrev-ref', 'HEAD'], {
+            cwd: repoPath,
+        });
+        return stdout.trim() || null;
+    }
+    catch {
+        return null;
+    }
+}
+async function getActivityFeed(repoPath, options = {}) {
+    const run = options.exec || execFileAsync;
+    try {
+        const { stdout } = await run('git', [
+            'log',
+            '--all',
+            '--since=24 hours ago',
+            '--oneline',
+            '--max-count=50',
+            '--format=%H|%h|%s|%an|%ar|%D',
+        ], { cwd: repoPath, timeout: 5000 });
+        const lines = stdout.split('\n').filter((line) => line.trim());
+        const entries = [];
+        for (const line of lines) {
+            try {
+                // Split into exactly 6 parts by the first 5 pipe characters
+                const parts = [];
+                let remaining = line;
+                for (let i = 0; i < 5; i++) {
+                    const idx = remaining.indexOf('|');
+                    if (idx === -1)
+                        break;
+                    parts.push(remaining.slice(0, idx));
+                    remaining = remaining.slice(idx + 1);
+                }
+                parts.push(remaining);
+                if (parts.length < 5)
+                    continue;
+                const hash = parts[0] ?? '';
+                const shortHash = parts[1] ?? '';
+                const message = parts[2] ?? '';
+                const author = parts[3] ?? '';
+                const timeAgo = parts[4] ?? '';
+                const decorations = parts[5] ?? '';
+                if (!hash || !shortHash)
+                    continue;
+                const branches = decorations
+                    .split(',')
+                    .map((d) => d.trim())
+                    .filter((d) => d && !d.startsWith('tag:') && d !== 'HEAD')
+                    .map((d) => d.replace(/^HEAD -> /, '').replace(/^origin\//, ''));
+                entries.push({
+                    hash: hash.trim(),
+                    shortHash: shortHash.trim(),
+                    message: message.trim(),
+                    author: author.trim(),
+                    timeAgo: timeAgo.trim(),
+                    branches: [...new Set(branches)],
+                });
+            }
+            catch {
+                // Skip malformed lines
+                continue;
+            }
+        }
+        return entries;
+    }
+    catch {
+        return [];
+    }
+}
+async function switchBranch(repoPath, branch, options = {}) {
+    const run = options.exec || execFileAsync;
+    try {
+        await run('git', ['checkout', branch], { cwd: repoPath, timeout: 5000 });
+        return { success: true };
+    }
+    catch (err) {
+        if (err && typeof err === 'object') {
+            const errObj = err;
+            const errorText = errObj.stderr ?? errObj.message ?? 'Unknown error';
+            return { success: false, error: errorText.trim() };
+        }
+        return { success: false, error: 'Unknown error' };
+    }
+}
+async function getCommitsAhead(repoPath, branch, baseBranch, options = {}) {
+    const run = options.exec || execFileAsync;
+    try {
+        const { stdout } = await run('git', ['rev-list', '--count', `${baseBranch}..${branch}`], { cwd: repoPath, timeout: 5000 });
+        const count = parseInt(stdout.trim(), 10);
+        return Number.isFinite(count) ? count : 0;
+    }
+    catch {
+        return 0;
+    }
+}
+async function getWorkingTreeDiff(repoPath, exec = execFileAsync) {
+    try {
+        const { stdout } = await exec('git', ['diff', '--shortstat'], {
+            cwd: repoPath,
+            timeout: 5000,
+        });
+        // Output like: " 3 files changed, 55 insertions(+), 12 deletions(-)"
+        const insertions = stdout.match(/(\d+) insertion/);
+        const deletions = stdout.match(/(\d+) deletion/);
+        return {
+            additions: insertions?.[1] ? parseInt(insertions[1], 10) : 0,
+            deletions: deletions?.[1] ? parseInt(deletions[1], 10) : 0,
+        };
+    }
+    catch {
+        return { additions: 0, deletions: 0 };
+    }
+}
+/**
+ * Convert a git branch name to a human-readable display name.
+ * "fix-mobile-scroll-bug" → "Fix mobile scroll bug"
+ * "feature/add-auth"      → "Add auth"
+ */
+function branchToDisplayName(branch) {
+    const stripped = branch.replace(/^(feature|fix|chore|refactor|docs|test|ci|build)\//i, '');
+    const words = stripped.replace(/[-_]/g, ' ').trim();
+    if (!words)
+        return branch;
+    return words.charAt(0).toUpperCase() + words.slice(1);
+}
+async function isBranchStale(repoPath, branch, options = {}) {
+    const run = options.exec || execFileAsync;
+    try {
+        for (const base of ['main', 'master']) {
+            try {
+                const { stdout } = await run('git', ['rev-list', '--count', `${base}..${branch}`], { cwd: repoPath, timeout: 5000 });
+                const count = parseInt(stdout.trim(), 10);
+                if (count === 0)
+                    return true;
+                return false;
+            }
+            catch {
+                continue;
+            }
+        }
+        return false;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Extracts "owner/repo" from a git remote URL.
+ * Handles both SSH (git@github.com:owner/repo.git) and HTTPS (https://github.com/owner/repo.git) forms.
+ */
+function extractOwnerRepo(remoteUrl) {
+    // SSH: git@github.com:owner/repo.git
+    const sshMatch = remoteUrl.match(/git@[^:]+:([^/]+\/[^/]+?)(?:\.git)?$/);
+    if (sshMatch)
+        return sshMatch[1] ?? null;
+    // HTTPS: https://github.com/owner/repo.git
+    const httpsMatch = remoteUrl.match(/https?:\/\/[^/]+\/([^/]+\/[^/]+?)(?:\.git)?$/);
+    if (httpsMatch)
+        return httpsMatch[1] ?? null;
+    return null;
+}
+/**
+ * Returns a map of "owner/repo" → workspace path for all git workspaces.
+ * Workspaces that are not git repos or have no remote are omitted.
+ */
+async function buildRepoMap(workspacePaths, exec) {
+    const map = new Map();
+    await Promise.all(workspacePaths.map(async (wsPath) => {
+        try {
+            const { stdout } = await exec('git', ['remote', 'get-url', 'origin'], {
+                cwd: wsPath,
+                timeout: 10_000,
+            });
+            const ownerRepo = extractOwnerRepo(stdout.trim());
+            if (ownerRepo) {
+                map.set(ownerRepo.toLowerCase(), wsPath);
+            }
+        }
+        catch {
+            // Not a git repo or no remote — skip
+        }
+    }));
+    return map;
+}
+async function listBranchesEnriched(repoPath, options = {}) {
+    const run = options.exec || execFileAsync;
+    if (options.refresh) {
+        try {
+            await run('git', ['fetch', '--all', '--prune'], { cwd: repoPath });
+        }
+        catch {
+            // Best effort — still return the locally-known refs below.
+        }
+    }
+    // Get local branches
+    let localBranches = [];
+    try {
+        const { stdout } = await run('git', ['branch', '--format=%(refname:short)'], { cwd: repoPath });
+        localBranches = stdout
+            .split('\n')
+            .map((b) => b.trim())
+            .filter((b) => b.length > 0);
+    }
+    catch {
+        // continue with empty list
+    }
+    // Get remote branches (strip origin/ prefix, skip HEAD)
+    let remoteBranches = [];
+    try {
+        const { stdout } = await run('git', ['branch', '-r', '--format=%(refname:short)'], { cwd: repoPath });
+        remoteBranches = stdout
+            .split('\n')
+            .map((b) => b.trim())
+            .filter((b) => b.length > 0 && !b.includes('HEAD') && b.startsWith('origin/'))
+            .map((b) => b.replace(/^origin\//, ''));
+    }
+    catch {
+        // continue with empty list
+    }
+    // Get worktree → branch mapping via porcelain output
+    const worktreeBranchMap = new Map(); // worktreePath → branchName
+    try {
+        const { stdout } = await run('git', ['worktree', 'list', '--porcelain'], {
+            cwd: repoPath,
+        });
+        const blocks = stdout.split(/\n\n+/);
+        for (const block of blocks) {
+            const lines = block
+                .split('\n')
+                .map((l) => l.trim())
+                .filter((l) => l.length > 0);
+            let worktreePath = null;
+            let branchName = null;
+            for (const line of lines) {
+                if (line.startsWith('worktree ')) {
+                    worktreePath = line.slice('worktree '.length);
+                }
+                else if (line.startsWith('branch ')) {
+                    // "branch refs/heads/branchname"
+                    branchName = line
+                        .slice('branch '.length)
+                        .replace(/^refs\/heads\//, '');
+                }
+            }
+            if (worktreePath && branchName) {
+                worktreeBranchMap.set(worktreePath, branchName);
+            }
+        }
+    }
+    catch {
+        // continue without worktree data
+    }
+    // Build reverse map: branchName → worktree info
+    const branchWorktreeMap = new Map();
+    for (const [wtPath, branchName] of worktreeBranchMap) {
+        const worktreeName = wtPath.split('/').at(-1) ?? wtPath;
+        const matchingSession = (options.sessions ?? []).find((s) => s.worktreePath === wtPath);
+        const entry = {
+            worktreePath: wtPath,
+            worktreeName,
+        };
+        if (matchingSession?.id !== undefined) {
+            entry.sessionId = matchingSession.id;
+        }
+        branchWorktreeMap.set(branchName, entry);
+    }
+    // Deduplicate by name across local + remote
+    const allNames = new Set([...localBranches, ...remoteBranches]);
+    const localSet = new Set(localBranches);
+    const remoteSet = new Set(remoteBranches);
+    const result = [...allNames].sort().map((name) => {
+        const checkedOutIn = branchWorktreeMap.get(name);
+        return {
+            name,
+            isLocal: localSet.has(name),
+            isRemote: remoteSet.has(name),
+            ...(checkedOutIn ? { checkedOutIn } : {}),
+        };
+    });
+    return result;
+}
+async function renameBranch(repoPath, newName, options = {}) {
+    const run = options.exec || execFileAsync;
+    try {
+        // Get current branch name first
+        const { stdout: currentStdout } = await run('git', ['rev-parse', '--abbrev-ref', 'HEAD'], { cwd: repoPath });
+        const oldName = currentStdout.trim();
+        if (!oldName)
+            return { success: false, error: 'Could not determine current branch' };
+        if (oldName === 'HEAD')
+            return {
+                success: false,
+                error: 'Cannot rename: not on a branch (detached HEAD)',
+            };
+        await run('git', ['branch', '-m', '--', newName], {
+            cwd: repoPath,
+            timeout: 5000,
+        });
+        return { success: true, oldName, newName };
+    }
+    catch (err) {
+        const errObj = err;
+        return {
+            success: false,
+            error: (errObj.stderr ?? errObj.message ?? 'Unknown error').trim(),
+        };
+    }
+}
+async function createBranch(repoPath, branchName, options = {}) {
+    const run = options.exec || execFileAsync;
+    try {
+        await run('git', ['checkout', '-b', '--', branchName], {
+            cwd: repoPath,
+            timeout: 5000,
+        });
+        return { success: true, branch: branchName };
+    }
+    catch (err) {
+        const errObj = err;
+        return {
+            success: false,
+            error: (errObj.stderr ?? errObj.message ?? 'Unknown error').trim(),
+        };
+    }
+}
+async function pushBranch(repoPath, branch, deleteOldBranch, options = {}) {
+    const run = options.exec || execFileAsync;
+    try {
+        await run('git', ['push', 'origin', branch], {
+            cwd: repoPath,
+            timeout: 30000,
+        });
+    }
+    catch (err) {
+        const errObj = err;
+        return {
+            success: false,
+            error: (errObj.stderr ?? errObj.message ?? 'Unknown error').trim(),
+        };
+    }
+    if (deleteOldBranch) {
+        try {
+            await run('git', ['push', 'origin', '--delete', deleteOldBranch], {
+                cwd: repoPath,
+                timeout: 10000,
+            });
+        }
+        catch (err) {
+            const errObj = err;
+            return {
+                success: true,
+                deleteError: (errObj.stderr ??
+                    errObj.message ??
+                    'Failed to delete old branch').trim(),
+            };
+        }
+    }
+    return { success: true };
+}
+function parseStatus(code) {
+    switch (code.trim()) {
+        case 'M':
+            return 'modified';
+        case 'A':
+            return 'added';
+        case 'D':
+            return 'deleted';
+        case '??':
+            return 'untracked';
+        default:
+            if (code.startsWith('R'))
+                return 'renamed';
+            return 'modified';
+    }
+}
+function fileDirectory(filePath) {
+    const dir = filePath.lastIndexOf('/');
+    return dir === -1 ? '.' : filePath.slice(0, dir);
+}
+function normalizeNumstatPath(filePath) {
+    if (!filePath.includes(' => '))
+        return filePath;
+    const arrow = ' => ';
+    // Handle brace-style paths like "{old/dir => new/dir}/file.ts"
+    if (filePath.startsWith('{')) {
+        const braceMatch = filePath.match(/^\{([^{}]+)\}(.*)$/);
+        if (braceMatch) {
+            const inner = braceMatch[1];
+            const suffix = braceMatch[2] ?? '';
+            const idx = inner.lastIndexOf(arrow);
+            if (idx !== -1) {
+                const newPart = inner.slice(idx + arrow.length) || inner.slice(0, idx);
+                return newPart + suffix;
+            }
+        }
+    }
+    // Simple "old => new" form
+    const idx = filePath.lastIndexOf(arrow);
+    if (idx !== -1)
+        return filePath.slice(idx + arrow.length);
+    return filePath;
+}
+async function getChangedFiles(repoPath, base, exec = execFileAsync) {
+    let statusEntries;
+    if (base === 'cached') {
+        // Staged files
+        const { stdout } = await exec('git', ['diff', '--cached', '--name-status', '--find-renames'], { cwd: repoPath, timeout: 10000 });
+        statusEntries = stdout
+            .split('\n')
+            .filter(Boolean)
+            .map((line) => {
+            const parts = line.split('\t');
+            const code = parts[0] ?? '';
+            if (code.startsWith('R')) {
+                return {
+                    path: parts[2] ?? '',
+                    oldPath: parts[1] ?? '',
+                    status: 'renamed',
+                };
+            }
+            return { path: parts[1] ?? '', status: parseStatus(code) };
+        });
+    }
+    else if (base) {
+        // Branch comparison
+        const { stdout } = await exec('git', ['diff', '--name-status', '--find-renames', `${base}...HEAD`], { cwd: repoPath, timeout: 10000 });
+        statusEntries = stdout
+            .split('\n')
+            .filter(Boolean)
+            .map((line) => {
+            const parts = line.split('\t');
+            const code = parts[0] ?? '';
+            if (code.startsWith('R')) {
+                return {
+                    path: parts[2] ?? '',
+                    oldPath: parts[1] ?? '',
+                    status: 'renamed',
+                };
+            }
+            return { path: parts[1] ?? '', status: parseStatus(code) };
+        });
+    }
+    else {
+        // Working tree: git status --porcelain=v1 -z
+        const { stdout } = await exec('git', ['status', '--porcelain=v1', '-z'], {
+            cwd: repoPath,
+            timeout: 10000,
+        });
+        statusEntries = [];
+        const parts = stdout.split('\0').filter(Boolean);
+        for (let i = 0; i < parts.length; i++) {
+            const entry = parts[i];
+            const code = entry.slice(0, 2);
+            const filePath = entry.slice(3);
+            if (code.startsWith('R')) {
+                // porcelain=v1 -z: rename record is XY <newname>\0<origname>\0
+                // filePath (entry.slice(3)) is the new name, parts[i+1] is the old name
+                const oldPath = parts[++i] ?? filePath;
+                statusEntries.push({ path: filePath, oldPath, status: 'renamed' });
+            }
+            else {
+                statusEntries.push({ path: filePath, status: parseStatus(code) });
+            }
+        }
+    }
+    if (statusEntries.length === 0)
+        return [];
+    // Get per-file stats via numstat
+    const numstatArgs = base
+        ? ['diff', '--numstat', '--find-renames', `${base}...HEAD`]
+        : ['diff', '--numstat', '--find-renames', 'HEAD'];
+    const numstatMap = new Map();
+    try {
+        const { stdout: numstat } = await exec('git', numstatArgs, {
+            cwd: repoPath,
+            timeout: 10000,
+        });
+        for (const line of numstat.split('\n').filter(Boolean)) {
+            const [add, del, ...pathParts] = line.split('\t');
+            const filePath = pathParts.join('\t');
+            const actualPath = normalizeNumstatPath(filePath);
+            numstatMap.set(actualPath, {
+                additions: add === '-' ? 0 : parseInt(add ?? '0', 10),
+                deletions: del === '-' ? 0 : parseInt(del ?? '0', 10),
+            });
+        }
+    }
+    catch (err) {
+        logger.warn('[git] numstat failed for', repoPath, err instanceof Error ? err.message : String(err));
+    }
+    const files = [];
+    for (const entry of statusEntries) {
+        if (!entry.path)
+            continue;
+        const stats = numstatMap.get(entry.path);
+        let additions = stats?.additions ?? 0;
+        let deletions = stats?.deletions ?? 0;
+        if (entry.status === 'untracked' && additions === 0) {
+            try {
+                const { stdout: wcOut } = await exec('wc', ['-l', '--', entry.path], {
+                    cwd: repoPath,
+                    timeout: 5000,
+                });
+                const match = wcOut.trim().match(/^\s*(\d+)/);
+                if (match)
+                    additions = parseInt(match[1], 10);
+            }
+            catch {
+                // best effort
+            }
+        }
+        files.push({
+            path: entry.path,
+            status: entry.status,
+            additions,
+            deletions,
+            directory: fileDirectory(entry.path),
+            ...(entry.oldPath ? { oldPath: entry.oldPath } : {}),
+        });
+    }
+    return files;
+}
+async function getFileDiff(repoPath, filePath, base, exec = execFileAsync) {
+    let args;
+    if (!base) {
+        args = ['diff', '--unified=3', '--find-renames', '--', filePath];
+    }
+    else if (base === 'cached') {
+        args = ['diff', '--cached', '--unified=3', '--', filePath];
+    }
+    else {
+        args = [
+            'diff',
+            `${base}...HEAD`,
+            '--unified=3',
+            '--find-renames',
+            '--',
+            filePath,
+        ];
+    }
+    const { stdout } = await exec('git', args, { cwd: repoPath, timeout: 10000 });
+    // If empty (no changes or untracked), try --no-index for new files
+    if (!stdout.trim()) {
+        try {
+            const { stdout: noIndexOut } = await exec('git', ['diff', '--no-index', '--', '/dev/null', filePath], { cwd: repoPath, timeout: 10000 });
+            return noIndexOut;
+        }
+        catch (err) {
+            // git diff --no-index exits with code 1 when there ARE differences
+            const e = err;
+            if (e.stdout)
+                return e.stdout;
+        }
+    }
+    return stdout;
+}
+async function getDefaultBranch(repoPath, exec = execFileAsync) {
+    // Try symbolic-ref first (most repos have this set)
+    try {
+        const { stdout } = await exec('git', ['symbolic-ref', 'refs/remotes/origin/HEAD'], { cwd: repoPath, timeout: 5000 });
+        const ref = stdout.trim();
+        const prefix = 'refs/remotes/origin/';
+        if (ref.startsWith(prefix))
+            return ref.slice(prefix.length);
+    }
+    catch {
+        // Not set — fall through to heuristic
+    }
+    // Check if main or master exists locally
+    for (const candidate of ['main', 'master']) {
+        try {
+            await exec('git', ['rev-parse', '--verify', `refs/heads/${candidate}`], {
+                cwd: repoPath,
+                timeout: 5000,
+            });
+            return candidate;
+        }
+        catch {
+            // Not found — try next
+        }
+    }
+    return 'main'; // ultimate fallback
+}
+function isGitRefNotFoundError(error) {
+    if (!error || typeof error !== 'object')
+        return false;
+    const stderr = error.stderr ?? '';
+    const message = error.message ?? '';
+    const text = stderr || message;
+    return (text.includes('Needed a single revision') ||
+        text.includes('unknown revision or path not in the working tree') ||
+        text.includes('ambiguous argument') ||
+        text.includes("couldn't find remote ref") ||
+        text.includes('could not find remote ref') ||
+        text.includes('not something we can merge') ||
+        text.includes('fatal: bad revision'));
+}
+/**
+ * Ensure a branch ref exists locally. If not, fetch it from origin.
+ * Returns { found: true } if the branch is now available locally,
+ * { found: false, reason: 'not_found' } if it doesn't exist anywhere,
+ * or { found: false, reason: 'fetch_failed' } if the fetch failed unexpectedly.
+ * Rethrows non-git errors (permissions, timeouts, corrupt repo) so callers
+ * can distinguish "branch doesn't exist" from "git is broken".
+ */
+async function ensureBranchLocal(repoPath, branch, options = {}) {
+    const run = options.exec || execFileAsync;
+    // Check if branch exists locally
+    try {
+        await run('git', ['rev-parse', '--verify', '--', branch], {
+            cwd: repoPath,
+            timeout: 5000,
+        });
+        return { found: true };
+    }
+    catch (error) {
+        if (!isGitRefNotFoundError(error)) {
+            throw error; // permissions, timeout, corrupt repo — surface to caller
+        }
+        // Not found locally — try fetching
+    }
+    // Fetch from origin
+    try {
+        await run('git', ['fetch', 'origin', '--', `${branch}:${branch}`], {
+            cwd: repoPath,
+            timeout: 30000,
+        });
+        return { found: true };
+    }
+    catch (error) {
+        if (isGitRefNotFoundError(error)) {
+            return { found: false, reason: 'not_found' };
+        }
+        // Network failures, auth errors, DNS issues — distinct from "branch doesn't exist"
+        return { found: false, reason: 'fetch_failed' };
+    }
+}
+/** Check if a PR is in MERGED state (immediate check, no 24h delay like isStalePr). */
+function isPrMerged(pr) {
+    return pr.state === 'MERGED';
+}
+/**
+ * Compute branch lifecycle state from authoritative sources.
+ * Main branch can be active/stale but never merged.
+ */
+function computeBranchLifecycleState(input) {
+    const { pr, isBranchStale: stale, hasActiveSessions, isMainBranch } = input;
+    // Merged: PR is merged AND not the main branch
+    if (pr && isPrMerged(pr) && !isMainBranch) {
+        return { state: 'merged', prNumber: pr.number, prTitle: pr.title };
+    }
+    // Active: has sessions OR branch is not stale
+    if (hasActiveSessions || !stale) {
+        return { state: 'active' };
+    }
+    // Stale: no sessions AND branch is stale (0 commits ahead of main)
+    return { state: 'stale' };
+}
+export { listBranches, listBranchesEnriched, normalizeBranchNames, getActivityFeed, switchBranch, getCommitsAhead, getCurrentBranch, getWorkingTreeDiff, branchToDisplayName, isBranchStale, extractOwnerRepo, buildRepoMap, renameBranch, createBranch, pushBranch, getChangedFiles, getFileDiff, getDefaultBranch, ensureBranchLocal, isPrMerged, computeBranchLifecycleState, };