@straiffi/archon 1.8.7 → 1.8.8

package/dist/server/lib/git.js

@@ -1,7 +1,7 @@
 import { execFile, execFileSync } from 'child_process';
 import { createHash } from 'crypto';
 import { cpSync, existsSync, lstatSync, mkdirSync, mkdtempSync, rmSync, statSync, symlinkSync } from 'fs';
-import { cp as cpAsync, lstat as lstatAsync, mkdir as mkdirAsync, symlink as symlinkAsync } from 'fs/promises';
+import { cp as cpAsync, lstat as lstatAsync, mkdir as mkdirAsync, stat as statAsync, symlink as symlinkAsync } from 'fs/promises';
 import { tmpdir } from 'os';
 import { dirname, isAbsolute, join, relative, resolve } from 'path';
 import db from '../db.js';
@@ -11,6 +11,8 @@ export class UnpushedCommitDiffSelectionError extends Error {
 }
 const PROJECT_BRANCH_REMOTE_REFRESH_TTL_MS = 30_000;
 const MAX_GIT_OUTPUT_BYTES = 512 * 1024 * 1024;
+const GIT_READ_TIMEOUT_MS = 15_000;
+const MAX_CONCURRENT_DIFF_PROCESSES = 8;
 const lastProjectBranchRemoteRefreshAt = new Map();
 const resolveCurrentBranchName = (cwd) => {
     try {
@@ -85,12 +87,13 @@ const runGitDiffText = (args, cwd) => {
         throw error;
     }
 };
-const runGitTextAsync = (args, cwd) => new Promise((resolvePromise, reject) => {
+const runGitTextAsync = (args, cwd, options = {}) => new Promise((resolvePromise, reject) => {
     execFile('git', args, {
         cwd,
         encoding: 'utf8',
         env: createWorkspaceProcessEnvironment(cwd),
         maxBuffer: MAX_GIT_OUTPUT_BYTES,
+        timeout: options.timeoutMs,
     }, (error, stdout, stderr) => {
         if (error) {
             const failed = error;
@@ -110,13 +113,26 @@ const runGitTextAsync = (args, cwd) => new Promise((resolvePromise, reject) => {
         });
     });
 });
+const mapWithConcurrency = async (inputs, concurrency, operation) => {
+    const results = new Array(inputs.length);
+    let nextIndex = 0;
+    const worker = async () => {
+        while (nextIndex < inputs.length) {
+            const index = nextIndex;
+            nextIndex += 1;
+            results[index] = await operation(inputs[index]);
+        }
+    };
+    await Promise.all(Array.from({ length: Math.min(concurrency, inputs.length) }, worker));
+    return results;
+};
 const isGitOutputLimitError = (error) => {
     const failed = error;
     return failed.code === 'ERR_CHILD_PROCESS_STDIO_MAXBUFFER' || failed.message.includes('maxBuffer');
 };
-const runGitDiffTextAsync = async (args, cwd) => {
+const runGitDiffTextAsync = async (args, cwd, options = {}) => {
     try {
-        return (await runGitTextAsync(args, cwd)).stdout;
+        return (await runGitTextAsync(args, cwd, options)).stdout;
     }
     catch (error) {
         const failed = error;
@@ -869,6 +885,33 @@ const getWorkspaceSignature = (output, cwd, entries) => {
         .join('\0');
     return createTextSignature(`${output}\0${fileFingerprints}`);
 };
+const getWorkspaceSignatureAsync = async (output, cwd, entries) => {
+    const sortedEntries = [...entries]
+        .sort((left, right) => left.path.localeCompare(right.path) || (left.originalPath ?? '').localeCompare(right.originalPath ?? ''));
+    const fileFingerprints = (await Promise.all(sortedEntries.map(async (entry) => {
+        try {
+            const entryPath = resolve(cwd, entry.path);
+            const stat = await statAsync(entryPath);
+            const kind = stat.isDirectory() ? 'dir' : 'file';
+            return `${entry.path}:${kind}:${stat.size}:${Math.trunc(stat.mtimeMs)}`;
+        }
+        catch {
+            return `${entry.path}:missing`;
+        }
+    }))).map((fingerprint, index) => {
+        const entry = sortedEntries[index];
+        return [
+            entry.path,
+            entry.originalPath ?? '',
+            entry.status,
+            entry.staged ? '1' : '0',
+            entry.unstaged ? '1' : '0',
+            entry.conflicted ? '1' : '0',
+            fingerprint,
+        ].join('\u0001');
+    }).join('\0');
+    return createTextSignature(`${output}\0${fileFingerprints}`);
+};
 const parseGitStatusOutput = (output) => {
     const entries = output.split('\0').filter(Boolean);
     const parsedEntries = [];
@@ -948,7 +991,7 @@ export const listGitSnapshotPaths = (cwd) => {
     return [...new Set(paths.filter(Boolean))];
 };
 const listUntrackedFilesAsync = async (cwd) => {
-    return (await runGitTextAsync(['ls-files', '--others', '--exclude-standard'], cwd)).stdout
+    return (await runGitTextAsync(['ls-files', '--others', '--exclude-standard'], cwd, { timeoutMs: GIT_READ_TIMEOUT_MS })).stdout
         .split('\n')
         .map(line => line.trim())
         .filter(Boolean);
@@ -965,7 +1008,7 @@ const getUntrackedNumstatEntry = (path, cwd) => {
     };
 };
 const getUntrackedNumstatEntryAsync = async (path, cwd) => {
-    const output = await runGitDiffTextAsync(['diff', '--no-index', '--numstat', '--', '/dev/null', path], cwd);
+    const output = await runGitDiffTextAsync(['diff', '--no-index', '--numstat', '--', '/dev/null', path], cwd, { timeoutMs: GIT_READ_TIMEOUT_MS });
     const entry = parseNumstatOutput(output)[0];
     if (!entry) {
         return null;
@@ -979,7 +1022,7 @@ const getUntrackedUnifiedDiff = (path, cwd) => {
     return runGitDiffText(['diff', '--no-index', '-U3', '--', '/dev/null', path], cwd);
 };
 const getUntrackedUnifiedDiffAsync = (path, cwd) => {
-    return runGitDiffTextAsync(['diff', '--no-index', '-U3', '--', '/dev/null', path], cwd);
+    return runGitDiffTextAsync(['diff', '--no-index', '-U3', '--', '/dev/null', path], cwd, { timeoutMs: GIT_READ_TIMEOUT_MS });
 };
 const getSelectedDiffDataForCwd = (cwd, selectedPaths) => {
     const normalizedPaths = [...new Set(selectedPaths.map(path => path.trim()).filter(Boolean))];
@@ -1065,12 +1108,12 @@ const getDiffDataForCwd = (cwd) => {
 };
 const getDiffDataForCwdAsync = async (cwd) => {
     try {
-        const trackedNumstat = parseNumstatOutput((await runGitTextAsync(['diff', '--numstat', '--find-renames', '--no-ext-diff', 'HEAD'], cwd)).stdout);
+        const trackedNumstat = parseNumstatOutput((await runGitTextAsync(['diff', '--numstat', '--find-renames', '--no-ext-diff', 'HEAD'], cwd, { timeoutMs: GIT_READ_TIMEOUT_MS })).stdout);
         const untrackedPaths = await listUntrackedFilesAsync(cwd);
-        const untrackedNumstat = (await Promise.all(untrackedPaths.map(path => getUntrackedNumstatEntryAsync(path, cwd))))
+        const untrackedNumstat = (await mapWithConcurrency(untrackedPaths, MAX_CONCURRENT_DIFF_PROCESSES, path => getUntrackedNumstatEntryAsync(path, cwd)))
             .filter((entry) => entry !== null);
-        const trackedDiff = (await runGitTextAsync(['diff', '-U3', '--find-renames', '--no-ext-diff', 'HEAD'], cwd)).stdout;
-        const untrackedDiffs = await Promise.all(untrackedPaths.map(path => getUntrackedUnifiedDiffAsync(path, cwd)));
+        const trackedDiff = (await runGitTextAsync(['diff', '-U3', '--find-renames', '--no-ext-diff', 'HEAD'], cwd, { timeoutMs: GIT_READ_TIMEOUT_MS })).stdout;
+        const untrackedDiffs = await mapWithConcurrency(untrackedPaths, MAX_CONCURRENT_DIFF_PROCESSES, path => getUntrackedUnifiedDiffAsync(path, cwd));
         return {
             files: [...trackedNumstat, ...untrackedNumstat].map(entry => ({
                 path: entry.path,
@@ -1392,6 +1435,9 @@ export const getGitDiffFiles = (cwd) => {
 export const getGitDiffData = (cwd) => {
     return getDiffDataForCwd(cwd);
 };
+export const getGitDiffDataAsync = (cwd) => {
+    return getDiffDataForCwdAsync(cwd);
+};
 export const getGitDiffFilesAsync = async (cwd) => {
     return (await getDiffDataForCwdAsync(cwd)).files;
 };
@@ -1580,6 +1626,209 @@ export const getGitStatus = (cwd, branch = null, project = null, options = {}) =
         };
     }
 };
+const resolveBranchUpstreamRefAsync = async (branch, cwd) => {
+    try {
+        const output = await runGitTextAsync(['rev-parse', '--symbolic-full-name', `${branch}@{upstream}`], cwd, { timeoutMs: GIT_READ_TIMEOUT_MS });
+        return output.stdout.trim() || null;
+    }
+    catch {
+        return null;
+    }
+};
+const getBranchSyncStateAsync = async (entries, cwd, recordedBase) => {
+    const branchState = entries
+        .filter(entry => entry.startsWith('# '))
+        .reduce((current, entry) => parseBranchHeader(entry, current), {
+        branch: null,
+        ahead: 0,
+        behind: 0,
+    });
+    if (!branchState.branch) {
+        return { branch: null, ahead: 0, behind: 0, hasUpstream: false, canPush: false };
+    }
+    const upstreamRef = await resolveBranchUpstreamRefAsync(branchState.branch, cwd);
+    let ahead = branchState.ahead;
+    if (!upstreamRef && ahead === 0 && branchState.behind === 0) {
+        const recordedBaseRef = recordedBase?.baseCommit ?? recordedBase?.baseBranch ?? null;
+        const args = recordedBaseRef
+            ? ['rev-list', '--count', `${recordedBaseRef}..HEAD`]
+            : ['rev-list', '--count', 'HEAD', '--not', '--remotes'];
+        try {
+            const output = await runGitTextAsync(args, cwd, { timeoutMs: GIT_READ_TIMEOUT_MS });
+            const parsedAhead = Number.parseInt(output.stdout.trim() || '0', 10);
+            ahead = Number.isFinite(parsedAhead) ? parsedAhead : 0;
+        }
+        catch {
+            ahead = 0;
+        }
+    }
+    return {
+        branch: branchState.branch,
+        ahead,
+        behind: branchState.behind,
+        hasUpstream: upstreamRef !== null,
+        canPush: upstreamRef !== null || ahead > 0,
+    };
+};
+const getGitOperationStateAsync = async (cwd) => {
+    try {
+        const output = await runGitTextAsync(['rev-parse', '--git-dir'], cwd, { timeoutMs: GIT_READ_TIMEOUT_MS });
+        const gitDir = output.stdout.trim();
+        if (!gitDir) {
+            return 'idle';
+        }
+        const resolvedGitDir = resolve(cwd, gitDir);
+        if (existsSync(join(resolvedGitDir, 'MERGE_HEAD'))) {
+            return 'merge';
+        }
+        if (existsSync(join(resolvedGitDir, 'rebase-merge')) || existsSync(join(resolvedGitDir, 'rebase-apply'))) {
+            return 'rebase';
+        }
+    }
+    catch {
+        return 'idle';
+    }
+    return 'idle';
+};
+const resolveFallbackBaseAsync = async (branch, project) => {
+    const repoPath = getRepoPath(project);
+    try {
+        const branchOutput = await runGitTextAsync(['branch', '--show-current'], repoPath, { timeoutMs: GIT_READ_TIMEOUT_MS });
+        const baseBranch = branchOutput.stdout.trim();
+        if (!baseBranch || baseBranch === branch) {
+            return null;
+        }
+        const mergeBaseOutput = await runGitTextAsync(['merge-base', baseBranch, branch], repoPath, { timeoutMs: GIT_READ_TIMEOUT_MS });
+        return {
+            baseBranch,
+            baseCommit: mergeBaseOutput.stdout.trim() || null,
+        };
+    }
+    catch {
+        return null;
+    }
+};
+const refreshProjectBranchTrackingAsync = async (cwd, branch) => {
+    try {
+        const upstreamRef = await resolveBranchUpstreamRefAsync(branch, cwd);
+        const fetchSpec = parseRemoteBranchRef(upstreamRef);
+        const args = fetchSpec
+            ? ['fetch', '--quiet', fetchSpec.remote, fetchSpec.branch]
+            : ['fetch', '--quiet', 'origin', branch];
+        await runGitTextAsync(args, cwd, { timeoutMs: GIT_READ_TIMEOUT_MS });
+    }
+    catch {
+        // Keep the last known tracking state when fetch is unavailable.
+    }
+};
+const getUnreadableGitStatus = () => ({
+    branch: null,
+    ahead: 0,
+    behind: 0,
+    has_upstream: false,
+    operation_state: 'idle',
+    can_abort: false,
+    can_force_push_with_lease: false,
+    base_branch: null,
+    pull_disabled_reason: 'Unable to read git status for this worktree.',
+    rebase_disabled_reason: 'Unable to read git status for this worktree.',
+    workspace_signature: null,
+    is_dirty: false,
+    has_staged_changes: false,
+    has_unstaged_changes: false,
+    files: [],
+    can_commit: false,
+    can_push: false,
+    blocked_reason: 'Unable to read git status for this worktree.',
+});
+export const getGitStatusAsync = async (cwd, branch = null, project = null, options = {}) => {
+    const recordedBase = branch && project ? resolveRecordedBaseForCwd(cwd, branch, project) : null;
+    try {
+        if (branch && options.refreshRemote && shouldRefreshProjectBranchTracking(getProjectBranchRefreshCacheKey(cwd, branch), true)) {
+            await refreshProjectBranchTrackingAsync(cwd, branch);
+        }
+        const output = (await runGitTextAsync(['status', '--porcelain=v2', '--branch', '--untracked-files=all', '-z'], cwd, { timeoutMs: GIT_READ_TIMEOUT_MS })).stdout;
+        const parsedOutput = parseGitStatusOutput(output);
+        const branchState = await getBranchSyncStateAsync(parsedOutput.entries, cwd, recordedBase);
+        const resolvedBranch = branchState.branch ?? branch;
+        const fallbackBase = !recordedBase && resolvedBranch && project
+            ? await resolveFallbackBaseAsync(resolvedBranch, project)
+            : null;
+        const effectiveBase = recordedBase ?? fallbackBase;
+        const includeFiles = options.includeFiles ?? true;
+        const files = includeFiles
+            ? parsedOutput.parsedEntries.map(entry => ({
+                path: entry.path,
+                original_path: entry.originalPath,
+                status: entry.status,
+                staged: entry.staged,
+                unstaged: entry.unstaged,
+                conflicted: entry.conflicted,
+            }))
+            : [];
+        const blockedReason = includeFiles ? getCommitBlockedReason(files) : null;
+        const operationState = await getGitOperationStateAsync(cwd);
+        const baseBranch = effectiveBase?.baseBranch && effectiveBase.baseBranch !== resolvedBranch
+            ? effectiveBase.baseBranch
+            : null;
+        const workspaceSignature = options.includeWorkspaceSignature === false
+            ? null
+            : await getWorkspaceSignatureAsync(output, cwd, parsedOutput.parsedEntries);
+        const status = {
+            branch: resolvedBranch,
+            ahead: branchState.ahead,
+            behind: branchState.behind,
+            has_upstream: branchState.hasUpstream,
+            operation_state: operationState,
+            can_abort: operationState !== 'idle',
+            can_force_push_with_lease: branchState.hasUpstream && branchState.ahead > 0 && branchState.behind > 0 && operationState === 'idle',
+            base_branch: baseBranch,
+            pull_disabled_reason: null,
+            rebase_disabled_reason: null,
+            workspace_signature: workspaceSignature,
+            is_dirty: parsedOutput.parsedEntries.length > 0,
+            has_staged_changes: parsedOutput.parsedEntries.some(entry => entry.staged),
+            has_unstaged_changes: parsedOutput.parsedEntries.some(entry => entry.unstaged || entry.status === 'untracked'),
+            files,
+            can_commit: includeFiles && files.length > 0 && blockedReason === null,
+            can_push: branchState.canPush,
+            blocked_reason: blockedReason,
+        };
+        return {
+            ...status,
+            pull_disabled_reason: !status.branch
+                ? 'Select a named branch before pulling.'
+                : operationState !== 'idle' || status.is_dirty || !status.has_upstream
+                    ? getPullDisabledReasonWithoutGit(status)
+                    : null,
+            rebase_disabled_reason: getRebaseDisabledReason(status),
+        };
+    }
+    catch {
+        return getUnreadableGitStatus();
+    }
+};
+const getPullDisabledReasonWithoutGit = (status) => {
+    if (!status.branch) {
+        return 'Select a named branch before pulling.';
+    }
+    if (status.operation_state === 'merge') {
+        return 'Abort the current merge before pulling again.';
+    }
+    if (status.operation_state === 'rebase') {
+        return 'Abort the current rebase before pulling again.';
+    }
+    if (status.files.some(file => file.conflicted)) {
+        return 'Resolve conflicted files before pulling from the UI.';
+    }
+    if (status.is_dirty) {
+        return 'Commit or stash changes before pulling from the UI.';
+    }
+    if (!status.has_upstream) {
+        return `Branch "${status.branch}" has no configured upstream.`;
+    }
+    return null;
+};
 export const getWorktreeGitStatus = (branch, project = null) => {
     const cwd = resolveWorktreePath(branch, project);
     return getGitStatus(cwd, branch, project);
@@ -1981,6 +2230,48 @@ export const getUnpushedCommitSummaryForCwd = (cwd, branch, project = null, opti
         };
     }
 };
+export const getUnpushedCommitSummaryForCwdAsync = async (cwd, branch, project = null) => {
+    const recordedBase = project ? resolveRecordedBaseForCwd(cwd, branch, project) : null;
+    const upstreamRef = await resolveBranchUpstreamRefAsync(branch, cwd);
+    const baseRef = upstreamRef ?? recordedBase?.baseBranch ?? recordedBase?.baseCommit ?? null;
+    let baseCommit = null;
+    if (baseRef) {
+        try {
+            const output = await runGitTextAsync(['rev-parse', '--verify', `${baseRef}^{commit}`], cwd, { timeoutMs: GIT_READ_TIMEOUT_MS });
+            baseCommit = output.stdout.trim() || null;
+        }
+        catch {
+            baseCommit = recordedBase?.baseCommit?.trim() || null;
+        }
+    }
+    if (!baseCommit && project && resolve(cwd) === getRepoPath(project)) {
+        try {
+            const output = await runGitTextAsync(['rev-parse', 'HEAD'], cwd, { timeoutMs: GIT_READ_TIMEOUT_MS });
+            baseCommit = output.stdout.trim() || null;
+        }
+        catch {
+            baseCommit = null;
+        }
+    }
+    const rangeArgs = baseCommit ? [`${baseCommit}..HEAD`] : ['HEAD', '--not', '--remotes'];
+    const [countOutput, logOutput] = await Promise.all([
+        runGitTextAsync(['rev-list', '--count', ...rangeArgs], cwd, { timeoutMs: GIT_READ_TIMEOUT_MS }),
+        runGitTextAsync([
+            'log',
+            '--format=%H%x00%h%x00%s%x00%cI%x00',
+            '--no-show-signature',
+            '-n',
+            '20',
+            ...rangeArgs,
+        ], cwd, { timeoutMs: GIT_READ_TIMEOUT_MS }),
+    ]);
+    const totalCount = Number.parseInt(countOutput.stdout.trim() || '0', 10);
+    return {
+        commits: parseUnpushedCommitsOutput(logOutput.stdout),
+        totalCount: Number.isFinite(totalCount) ? totalCount : 0,
+        baseCommit,
+    };
+};
 export const listUnpushedCommitsForCwd = (cwd, branch, project = null, options = {}) => {
     return getUnpushedCommitSummaryForCwd(cwd, branch, project, options).commits;
 };