@straiffi/archon 1.11.8 → 1.11.9

package/dist/server/lib/git.js

@@ -7,6 +7,7 @@ import { dirname, isAbsolute, join, relative, resolve } from 'path';
 import db from '../db.js';
 import { runBoundedProcess } from './boundedProcess.js';
 import { getProjectWorktreeSync } from './projects.js';
+import { selectUnifiedDiffFiles } from './unifiedDiff.js';
 import { createWorkspaceProcessEnvironment } from './workspaceProcessEnvironment.js';
 export class UnpushedCommitDiffSelectionError extends Error {
 }
@@ -239,6 +240,39 @@ const parseNumstatOutput = (output) => {
             }];
     });
 };
+const parseNulNumstatOutput = (output) => {
+    const records = output.split('\0');
+    const parsed = [];
+    for (let index = 0; index < records.length; index += 1) {
+        const record = records[index] ?? '';
+        if (!record) {
+            continue;
+        }
+        const firstTabIndex = record.indexOf('\t');
+        const secondTabIndex = firstTabIndex === -1 ? -1 : record.indexOf('\t', firstTabIndex + 1);
+        if (firstTabIndex === -1 || secondTabIndex === -1) {
+            continue;
+        }
+        const additionsToken = record.slice(0, firstTabIndex);
+        const deletionsToken = record.slice(firstTabIndex + 1, secondTabIndex);
+        let path = record.slice(secondTabIndex + 1);
+        if (!path) {
+            index += 2;
+            path = records[index] ?? '';
+        }
+        if (!path) {
+            continue;
+        }
+        const additions = additionsToken === '-' ? 0 : Number.parseInt(additionsToken, 10);
+        const deletions = deletionsToken === '-' ? 0 : Number.parseInt(deletionsToken, 10);
+        parsed.push({
+            path,
+            additions: Number.isFinite(additions) ? additions : 0,
+            deletions: Number.isFinite(deletions) ? deletions : 0,
+        });
+    }
+    return parsed;
+};
 const normalizeNoIndexPath = (path) => {
     const renamedPrefix = '/dev/null => ';
     if (path.startsWith(renamedPrefix)) {
@@ -794,7 +828,25 @@ const parseUnpushedCommitsOutput = (output) => {
     return commits.filter(commit => commit.hash && commit.short_hash && commit.subject);
 };
 const resolveDefaultBranchRef = (cwd) => {
-    const candidates = ['refs/remotes/origin/HEAD', 'refs/remotes/origin/main', 'refs/remotes/origin/master', 'refs/heads/main', 'refs/heads/master'];
+    try {
+        const remoteDefault = runGitText(['symbolic-ref', '--quiet', 'refs/remotes/origin/HEAD'], cwd).trim();
+        if (remoteDefault) {
+            return remoteDefault;
+        }
+    }
+    catch {
+        // Fall back to conventional branch names below.
+    }
+    try {
+        const resolvedRemoteDefault = runGitText(['rev-parse', '--symbolic-full-name', 'refs/remotes/origin/HEAD'], cwd).trim();
+        if (resolvedRemoteDefault && resolvedRemoteDefault !== 'refs/remotes/origin/HEAD') {
+            return resolvedRemoteDefault;
+        }
+    }
+    catch {
+        // Ignore direct or unavailable origin/HEAD refs.
+    }
+    const candidates = ['refs/remotes/origin/main', 'refs/remotes/origin/master', 'refs/heads/main', 'refs/heads/master'];
     for (const candidate of candidates) {
         try {
             const resolved = runGitText(['rev-parse', '--symbolic-full-name', candidate], cwd).trim();
@@ -826,6 +878,21 @@ const resolveNamedBranchRef = (branch, cwd) => {
     }
     return null;
 };
+const resolveReviewBranchRef = (branch, cwd) => {
+    const candidates = [`refs/remotes/origin/${branch}`, `refs/heads/${branch}`];
+    for (const candidate of candidates) {
+        try {
+            const resolved = runGitText(['rev-parse', '--symbolic-full-name', '--verify', candidate], cwd).trim();
+            if (resolved) {
+                return resolved;
+            }
+        }
+        catch {
+            // Try the local branch only when its remote tracking ref is unavailable.
+        }
+    }
+    return null;
+};
 const resolveCommitBaseFromBaseRef = (baseRef, cwd) => {
     if (!baseRef) {
         return null;
@@ -850,6 +917,34 @@ const resolveCommitBaseFromBaseRef = (baseRef, cwd) => {
     }
     return null;
 };
+const branchNameFromRef = (ref) => ref
+    .replace(/^refs\/heads\//, '')
+    .replace(/^refs\/remotes\/[^/]+\//, '');
+export const resolveGitHeadCommit = (cwd) => {
+    try {
+        return resolveHeadCommit(cwd);
+    }
+    catch {
+        return null;
+    }
+};
+export const resolveGitCommit = (cwd, revision) => {
+    const normalizedRevision = revision.trim();
+    return normalizedRevision ? resolveCommitSha(normalizedRevision, cwd) : null;
+};
+export const resolveGitReviewBaseForBranch = (cwd, baseBranch) => {
+    const normalizedBranch = baseBranch.trim();
+    const baseRef = resolveReviewBranchRef(normalizedBranch, cwd);
+    const baseCommit = resolveCommitBaseFromBaseRef(baseRef, cwd);
+    return baseCommit ? { baseBranch: normalizedBranch, baseCommit } : null;
+};
+export const resolveGitRepositoryDefaultReviewBase = (cwd) => {
+    const baseRef = resolveDefaultBranchRef(cwd);
+    const baseCommit = resolveCommitBaseFromBaseRef(baseRef, cwd);
+    return baseRef && baseCommit
+        ? { baseBranch: branchNameFromRef(baseRef), baseCommit }
+        : null;
+};
 const resolveRecordedBaseCommit = (cwd, baseBranch = null, baseCommit = null) => {
     const baseBranchCommit = resolveCommitBaseFromBaseRef(resolveNamedBranchRef(baseBranch, cwd), cwd);
     if (baseBranchCommit) {
@@ -897,23 +992,20 @@ const resolveUnpushedCommitRange = (cwd, branch, baseBranch = null, baseCommit =
         baseCommit: null,
     };
 };
-export const resolveBundleReviewBase = ({ cwd, branch, project, pullRequestBaseBranch = null, }) => {
-    const normalizedPullRequestBaseBranch = pullRequestBaseBranch?.trim() || null;
-    if (normalizedPullRequestBaseBranch) {
-        const baseCommit = resolveCommitBaseFromBaseRef(resolveNamedBranchRef(normalizedPullRequestBaseBranch, cwd), cwd);
-        if (baseCommit) {
-            return {
-                baseBranch: normalizedPullRequestBaseBranch,
-                baseCommit,
-                source: 'pull_request',
-            };
-        }
-    }
+export const resolveBundleReviewBase = ({ cwd, branch, project, pullRequestBaseBranch: _pullRequestBaseBranch = null, }) => {
     const recordedBase = project ? resolveRecordedBaseForCwd(cwd, branch, project) : null;
     if (!recordedBase) {
         return null;
     }
+    const recordedCommit = recordedBase.baseCommit?.trim() || null;
     const baseBranch = recordedBase.baseBranch?.trim() || null;
+    if (recordedCommit) {
+        return {
+            baseBranch,
+            baseCommit: recordedCommit,
+            source: 'worktree_base',
+        };
+    }
     if (baseBranch) {
         const baseCommit = resolveCommitBaseFromBaseRef(resolveNamedBranchRef(baseBranch, cwd), cwd);
         if (baseCommit) {
@@ -924,24 +1016,54 @@ export const resolveBundleReviewBase = ({ cwd, branch, project, pullRequestBaseB
             };
         }
     }
-    const baseCommit = recordedBase.baseCommit?.trim() || null;
-    if (!baseCommit) {
-        return null;
+    return null;
+};
+const getExactDiffPath = (path) => {
+    const normalizedPath = path.trim();
+    const segments = normalizedPath.split(/[\\/]/);
+    if (!normalizedPath
+        || normalizedPath.includes('\0')
+        || isAbsolute(normalizedPath)
+        || /^[A-Za-z]:[\\/]/.test(normalizedPath)
+        || segments.some(segment => segment === '' || segment === '.' || segment === '..')) {
+        throw new Error('Diff file path must be a valid repository-relative path');
+    }
+    return { path: normalizedPath };
+};
+const selectExactDiffData = (data, exactPath) => {
+    if (!exactPath) {
+        return data;
+    }
+    const selection = selectUnifiedDiffFiles(data.diff, [exactPath.path]);
+    if (!selection.ok) {
+        return { files: [], diff: '' };
     }
+    const aliases = new Set(selection.files.flatMap(file => file.aliases));
     return {
-        baseBranch,
-        baseCommit,
-        source: 'worktree_base',
+        files: data.files.filter(file => aliases.has(file.path)),
+        diff: selection.diff,
     };
 };
-const getDiffDataForBaseRef = (cwd, baseRef) => {
+const getDiffDataForBaseRef = (cwd, baseRef, exactFilePath = null, suppressErrors = true) => {
+    const exactPath = exactFilePath === null ? null : getExactDiffPath(exactFilePath);
     try {
-        const trackedNumstat = parseNumstatOutput(runGitText(['diff', '--numstat', '--find-renames', '--no-ext-diff', baseRef], cwd));
-        const untrackedPaths = listUntrackedFiles(cwd);
+        const trackedNumstatOutput = runGitText([
+            'diff',
+            '--numstat',
+            ...(suppressErrors ? [] : ['-z']),
+            '--find-renames',
+            '--no-ext-diff',
+            baseRef,
+        ], cwd);
+        const trackedNumstat = suppressErrors
+            ? parseNumstatOutput(trackedNumstatOutput)
+            : parseNulNumstatOutput(trackedNumstatOutput);
+        const untrackedPaths = (suppressErrors ? listUntrackedFiles(cwd) : listUntrackedFilesNul(cwd))
+            .filter(path => !exactPath || path === exactPath.path);
         const untrackedNumstat = untrackedPaths
-            .map(path => getUntrackedNumstatEntry(path, cwd))
+            .map(path => suppressErrors ? getUntrackedNumstatEntry(path, cwd) : getUntrackedNumstatEntryNul(path, cwd))
             .filter((entry) => entry !== null);
-        return {
+        return selectExactDiffData({
             files: [...trackedNumstat, ...untrackedNumstat].map(entry => ({
                 path: entry.path,
                 additions: entry.additions,
@@ -951,10 +1073,10 @@ const getDiffDataForBaseRef = (cwd, baseRef) => {
                 runGitText(['diff', '-U3', '--find-renames', '--no-ext-diff', baseRef], cwd),
                 ...untrackedPaths.map(path => getUntrackedUnifiedDiff(path, cwd)),
             ].join(''),
-        };
+        }, exactPath);
     }
     catch (error) {
-        if (isGitOutputLimitError(error)) {
+        if (!suppressErrors || isGitOutputLimitError(error)) {
             throw error;
         }
         return {
@@ -981,25 +1103,41 @@ const getCommittedDiffData = (cwd, baseCommit, headCommit) => {
         diff: runGitText(['diff', '-U3', '--find-renames', '--no-ext-diff', ...revisions], cwd),
     };
 };
-const getDiffDataForBaseRefAsync = async (cwd, baseRef) => {
+const getDiffDataForBaseRefAsync = async (cwd, baseRef, exactFilePath = null, suppressErrors = true) => {
+    const exactPath = exactFilePath === null ? null : getExactDiffPath(exactFilePath);
     try {
-        const trackedNumstat = parseNumstatOutput((await runGitTextAsync(['diff', '--numstat', '--find-renames', '--no-ext-diff', baseRef], cwd)).stdout);
-        const untrackedPaths = await listUntrackedFilesAsync(cwd);
-        const untrackedNumstat = (await Promise.all(untrackedPaths.map(path => getUntrackedNumstatEntryAsync(path, cwd))))
+        const trackedNumstatOutput = (await runGitTextAsync([
+            'diff',
+            '--numstat',
+            ...(suppressErrors ? [] : ['-z']),
+            '--find-renames',
+            '--no-ext-diff',
+            baseRef,
+        ], cwd)).stdout;
+        const trackedNumstat = suppressErrors
+            ? parseNumstatOutput(trackedNumstatOutput)
+            : parseNulNumstatOutput(trackedNumstatOutput);
+        const untrackedPaths = (suppressErrors ? await listUntrackedFilesAsync(cwd) : await listUntrackedFilesNulAsync(cwd))
+            .filter(path => !exactPath || path === exactPath.path);
+        const untrackedNumstat = (await mapWithConcurrency(untrackedPaths, MAX_CONCURRENT_DIFF_PROCESSES, path => suppressErrors
+            ? getUntrackedNumstatEntryAsync(path, cwd)
+            : getUntrackedNumstatEntryNulAsync(path, cwd)))
             .filter((entry) => entry !== null);
-        const trackedDiff = (await runGitTextAsync(['diff', '-U3', '--find-renames', '--no-ext-diff', baseRef], cwd)).stdout;
-        const untrackedDiffs = await Promise.all(untrackedPaths.map(path => getUntrackedUnifiedDiffAsync(path, cwd)));
-        return {
+        const trackedDiff = (await runGitTextAsync([
+            'diff', '-U3', '--find-renames', '--no-ext-diff', baseRef,
+        ], cwd)).stdout;
+        const untrackedDiffs = await mapWithConcurrency(untrackedPaths, MAX_CONCURRENT_DIFF_PROCESSES, path => getUntrackedUnifiedDiffAsync(path, cwd));
+        return selectExactDiffData({
             files: [...trackedNumstat, ...untrackedNumstat].map(entry => ({
                 path: entry.path,
                 additions: entry.additions,
                 deletions: entry.deletions,
             })),
             diff: [trackedDiff, ...untrackedDiffs].join(''),
-        };
+        }, exactPath);
     }
     catch (error) {
-        if (isGitOutputLimitError(error)) {
+        if (!suppressErrors || isGitOutputLimitError(error)) {
             throw error;
         }
         return {
@@ -1258,6 +1396,13 @@ const listUntrackedFiles = (cwd) => {
         .map(line => line.trim())
         .filter(Boolean);
 };
+const listUntrackedFilesNul = (cwd) => {
+    const paths = runGitText(['ls-files', '--others', '--exclude-standard', '-z'], cwd).split('\0');
+    if (paths.at(-1) === '') {
+        paths.pop();
+    }
+    return paths.filter(Boolean);
+};
 export const listGitSnapshotPaths = (cwd) => {
     const output = runGitText(['ls-files', '--cached', '--others', '--exclude-standard', '-z'], cwd);
     const paths = output.split('\0');
@@ -1272,6 +1417,15 @@ const listUntrackedFilesAsync = async (cwd) => {
         .map(line => line.trim())
         .filter(Boolean);
 };
+const listUntrackedFilesNulAsync = async (cwd) => {
+    const paths = (await runGitTextAsync([
+        'ls-files', '--others', '--exclude-standard', '-z',
+    ], cwd, { timeoutMs: GIT_READ_TIMEOUT_MS })).stdout.split('\0');
+    if (paths.at(-1) === '') {
+        paths.pop();
+    }
+    return paths.filter(Boolean);
+};
 const getUntrackedNumstatEntry = (path, cwd) => {
     const output = runGitDiffText(['diff', '--no-index', '--numstat', '--', '/dev/null', path], cwd);
     const entry = parseNumstatOutput(output)[0];
@@ -1283,6 +1437,11 @@ const getUntrackedNumstatEntry = (path, cwd) => {
         path: normalizeNoIndexPath(entry.path),
     };
 };
+const getUntrackedNumstatEntryNul = (path, cwd) => {
+    const output = runGitDiffText(['diff', '--no-index', '--numstat', '-z', '--', '/dev/null', path], cwd);
+    const entry = parseNulNumstatOutput(output)[0];
+    return entry ? { ...entry, path } : null;
+};
 const getUntrackedNumstatEntryAsync = async (path, cwd) => {
     const output = await runGitDiffTextAsync(['diff', '--no-index', '--numstat', '--', '/dev/null', path], cwd, { timeoutMs: GIT_READ_TIMEOUT_MS });
     const entry = parseNumstatOutput(output)[0];
@@ -1294,6 +1453,13 @@ const getUntrackedNumstatEntryAsync = async (path, cwd) => {
         path: normalizeNoIndexPath(entry.path),
     };
 };
+const getUntrackedNumstatEntryNulAsync = async (path, cwd) => {
+    const output = await runGitDiffTextAsync([
+        'diff', '--no-index', '--numstat', '-z', '--', '/dev/null', path,
+    ], cwd, { timeoutMs: GIT_READ_TIMEOUT_MS });
+    const entry = parseNulNumstatOutput(output)[0];
+    return entry ? { ...entry, path } : null;
+};
 const getUntrackedUnifiedDiff = (path, cwd) => {
     return runGitDiffText(['diff', '--no-index', '-U3', '--', '/dev/null', path], cwd);
 };
@@ -1994,6 +2160,10 @@ export const getGitDiffFiles = (cwd) => {
 export const getGitDiffData = (cwd) => {
     return getDiffDataForCwd(cwd);
 };
+export const getGitDiffDataAgainstBase = (cwd, baseCommit, exactFilePath = null) => getDiffDataForBaseRef(cwd, baseCommit, exactFilePath, false);
+export const getGitDiffDataAgainstBaseAsync = (cwd, baseCommit, exactFilePath = null) => getDiffDataForBaseRefAsync(cwd, baseCommit, exactFilePath, false);
+export const getGitUncommittedDiffData = (cwd, exactFilePath = null) => getDiffDataForBaseRef(cwd, 'HEAD', exactFilePath, false);
+export const getGitUncommittedDiffDataAsync = (cwd, exactFilePath = null) => getDiffDataForBaseRefAsync(cwd, 'HEAD', exactFilePath, false);
 export const getGitDiffDataAsync = (cwd) => {
     return getDiffDataForCwdAsync(cwd);
 };