@straiffi/archon 1.8.4 → 1.8.6

package/dist/server/lib/git.js

@@ -251,6 +251,15 @@ const resolveHeadCommit = (cwd) => {
     const output = runGitText(['rev-parse', 'HEAD'], cwd).trim();
     return output || null;
 };
+const resolveCommitSha = (revision, cwd) => {
+    try {
+        const output = runGitText(['rev-parse', '--verify', `${revision}^{commit}`], cwd).trim();
+        return output || null;
+    }
+    catch {
+        return null;
+    }
+};
 const countCommitRange = (range, cwd) => {
     const output = runGitText(['rev-list', '--count', range], cwd).trim();
     const count = Number.parseInt(output || '0', 10);
@@ -318,6 +327,35 @@ const resolveBranchUpstreamFetchSpec = (branch, cwd) => {
     const upstreamRef = resolveBranchUpstreamRef(branch, cwd);
     return parseRemoteBranchRef(upstreamRef);
 };
+const refreshSquashUpstream = async (branch, cwd) => {
+    const upstreamRef = resolveBranchUpstreamRef(branch, cwd);
+    if (!upstreamRef) {
+        return null;
+    }
+    const fetchSpec = parseRemoteBranchRef(upstreamRef);
+    if (!fetchSpec) {
+        const localUpstreamCommitSha = resolveCommitSha(upstreamRef, cwd);
+        if (!localUpstreamCommitSha) {
+            throw new Error('Unable to resolve the local upstream before squashing commits. Refresh and try again.');
+        }
+        return localUpstreamCommitSha;
+    }
+    try {
+        await runGitTextAsync(['fetch', '--quiet', fetchSpec.remote, fetchSpec.branch], cwd);
+    }
+    catch {
+        throw new Error('Unable to refresh the upstream branch before squashing commits. Pull or reconcile the branch and try again.');
+    }
+    const refreshedUpstreamRef = resolveBranchUpstreamRef(branch, cwd);
+    if (refreshedUpstreamRef !== upstreamRef) {
+        throw new Error('The upstream branch changed while preparing the squash. Refresh and try again.');
+    }
+    const upstreamCommitSha = resolveCommitSha(refreshedUpstreamRef, cwd);
+    if (!upstreamCommitSha) {
+        throw new Error('Unable to resolve the refreshed upstream commit before squashing commits. Refresh and try again.');
+    }
+    return upstreamCommitSha;
+};
 const resolveGitDir = (cwd) => {
     const gitDir = runGitText(['rev-parse', '--git-dir'], cwd).trim();
     if (!gitDir) {
@@ -343,6 +381,26 @@ const getGitOperationState = (cwd) => {
     }
     return 'idle';
 };
+const hasActiveGitOperation = (cwd) => {
+    if (getGitOperationState(cwd) !== 'idle') {
+        return true;
+    }
+    try {
+        const gitDir = resolveGitDir(cwd);
+        if (!gitDir) {
+            return false;
+        }
+        return [
+            'CHERRY_PICK_HEAD',
+            'REVERT_HEAD',
+            'BISECT_LOG',
+            'sequencer',
+        ].some(marker => existsSync(join(gitDir, marker)));
+    }
+    catch {
+        return true;
+    }
+};
 const getBranchTrackingState = (branch, cwd) => {
     if (!resolveBranchUpstreamRef(branch, cwd)) {
         try {
@@ -500,6 +558,13 @@ const resolveCommitBaseFromBaseRef = (baseRef, cwd) => {
     }
     return null;
 };
+const resolveRecordedBaseCommit = (cwd, baseBranch = null, baseCommit = null) => {
+    const baseBranchCommit = resolveCommitBaseFromBaseRef(resolveNamedBranchRef(baseBranch, cwd), cwd);
+    if (baseBranchCommit) {
+        return baseBranchCommit;
+    }
+    return baseCommit?.trim() || null;
+};
 const resolveCommitRangeFromBaseRef = (baseRef, cwd) => {
     const baseCommit = resolveCommitBaseFromBaseRef(baseRef, cwd);
     return baseCommit ? `${baseCommit}..HEAD` : null;
@@ -508,25 +573,37 @@ const resolveBranchUniqueRange = (cwd) => {
     return resolveCommitRangeFromBaseRef(resolveDefaultBranchRef(cwd), cwd);
 };
 const resolveRecordedBaseRange = (cwd, baseBranch = null, baseCommit = null) => {
-    const baseBranchRange = resolveCommitRangeFromBaseRef(resolveNamedBranchRef(baseBranch, cwd), cwd);
-    if (baseBranchRange) {
-        return baseBranchRange;
-    }
-    if (baseCommit) {
-        return `${baseCommit}..HEAD`;
-    }
-    return null;
+    const resolvedBaseCommit = resolveRecordedBaseCommit(cwd, baseBranch, baseCommit);
+    return resolvedBaseCommit ? `${resolvedBaseCommit}..HEAD` : null;
 };
 const resolveUnpushedCommitRange = (cwd, branch, baseBranch = null, baseCommit = null) => {
     const upstreamRef = resolveBranchUpstreamRef(branch, cwd);
     if (upstreamRef) {
-        return `${upstreamRef}..HEAD`;
+        const upstreamCommit = resolveCommitSha(upstreamRef, cwd) ?? upstreamRef;
+        return {
+            range: `${upstreamCommit}..HEAD`,
+            baseCommit: upstreamCommit,
+        };
+    }
+    const recordedBaseCommit = resolveRecordedBaseCommit(cwd, baseBranch, baseCommit);
+    if (recordedBaseCommit) {
+        return {
+            range: `${recordedBaseCommit}..HEAD`,
+            baseCommit: recordedBaseCommit,
+        };
     }
-    const recordedBaseRange = resolveRecordedBaseRange(cwd, baseBranch, baseCommit);
-    if (recordedBaseRange) {
-        return recordedBaseRange;
+    const defaultBaseRef = resolveDefaultBranchRef(cwd);
+    const defaultBaseCommit = resolveCommitBaseFromBaseRef(defaultBaseRef, cwd);
+    if (defaultBaseCommit) {
+        return {
+            range: `${defaultBaseCommit}..HEAD`,
+            baseCommit: defaultBaseCommit,
+        };
     }
-    return resolveBranchUniqueRange(cwd);
+    return {
+        range: null,
+        baseCommit: null,
+    };
 };
 export const resolveBundleReviewBase = ({ cwd, branch, project, pullRequestBaseBranch = null, }) => {
     const normalizedPullRequestBaseBranch = pullRequestBaseBranch?.trim() || null;
@@ -639,18 +716,31 @@ const getDiffDataForBaseRefAsync = async (cwd, baseRef) => {
         };
     }
 };
+const getUnpushedRangeArgs = (resolvedRange) => {
+    return resolvedRange.range ? [resolvedRange.range] : ['HEAD', '--not', '--remotes'];
+};
+const getUnpushedCommitSummary = (cwd, branch, baseBranch = null, baseCommit = null) => {
+    const resolvedRange = resolveUnpushedCommitRange(cwd, branch, baseBranch, baseCommit);
+    const rangeArgs = getUnpushedRangeArgs(resolvedRange);
+    const countOutput = runGitText(['rev-list', '--count', ...rangeArgs], cwd).trim();
+    const totalCount = Number.parseInt(countOutput || '0', 10);
+    const output = runGitText([
+        'log',
+        '--format=%H%x00%h%x00%s%x00%cI%x00',
+        '--no-show-signature',
+        '-n',
+        '20',
+        ...rangeArgs,
+    ], cwd);
+    return {
+        commits: parseUnpushedCommitsOutput(output),
+        totalCount: Number.isFinite(totalCount) ? totalCount : 0,
+        baseCommit: resolvedRange.baseCommit,
+    };
+};
 const listUnpushedCommitRecords = (cwd, branch, baseBranch = null, baseCommit = null, options = {}) => {
     try {
-        const branchUniqueRange = resolveUnpushedCommitRange(cwd, branch, baseBranch, baseCommit);
-        const output = runGitText([
-            'log',
-            '--format=%H%x00%h%x00%s%x00%cI%x00',
-            '--no-show-signature',
-            '-n',
-            '20',
-            ...(branchUniqueRange ? [branchUniqueRange] : ['HEAD', '--not', '--remotes']),
-        ], cwd);
-        return parseUnpushedCommitsOutput(output);
+        return getUnpushedCommitSummary(cwd, branch, baseBranch, baseCommit).commits;
     }
     catch (error) {
         if (options.throwOnError) {
@@ -1874,10 +1964,25 @@ export const pushWorktreeBranch = async (branch, project = null, options = {}) =
     const cwd = resolveWorktreePath(branch, project);
     await pushCurrentBranch(cwd, branch, options);
 };
+export const getUnpushedCommitSummaryForCwd = (cwd, branch, project = null, options = {}) => {
+    try {
+        const recordedBase = project ? resolveRecordedBaseForCwd(cwd, branch, project) : null;
+        const fallbackBase = recordedBase ?? (project ? resolveFallbackBase(branch, project) : null);
+        return getUnpushedCommitSummary(cwd, branch, fallbackBase?.baseBranch ?? null, fallbackBase?.baseCommit ?? null);
+    }
+    catch (error) {
+        if (options.throwOnError) {
+            throw error;
+        }
+        return {
+            commits: [],
+            totalCount: 0,
+            baseCommit: null,
+        };
+    }
+};
 export const listUnpushedCommitsForCwd = (cwd, branch, project = null, options = {}) => {
-    const recordedBase = project ? resolveRecordedBaseForCwd(cwd, branch, project) : null;
-    const fallbackBase = recordedBase ?? (project ? resolveFallbackBase(branch, project) : null);
-    return listUnpushedCommitRecords(cwd, branch, fallbackBase?.baseBranch ?? null, fallbackBase?.baseCommit ?? null, options);
+    return getUnpushedCommitSummaryForCwd(cwd, branch, project, options).commits;
 };
 const resolveFirstParentOrEmptyTree = (cwd, commitHash) => {
     const commitAndParents = runGitText(['rev-list', '--parents', '-n', '1', commitHash], cwd).trim().split(/\s+/);
@@ -1892,24 +1997,199 @@ export const getUnpushedCommitDiffForCwd = ({ cwd, branch, project = null, commi
     if (commitHash !== null && !/^(?:[0-9a-f]{40}|[0-9a-f]{64})$/.test(normalizedCommitHash ?? '')) {
         throw new UnpushedCommitDiffSelectionError('commit must be a full 40- or 64-character Git commit hash.');
     }
-    const commits = listUnpushedCommitsForCwd(cwd, branch, project, { throwOnError: true });
-    if (commits.length === 0) {
+    const summary = getUnpushedCommitSummaryForCwd(cwd, branch, project, { throwOnError: true });
+    if (summary.commits.length === 0) {
         throw new UnpushedCommitDiffSelectionError('There are no local commits to compare.');
     }
     const selectedCommit = normalizedCommitHash
-        ? commits.find(commit => commit.hash === normalizedCommitHash)
-        : commits[0];
+        ? summary.commits.find(commit => commit.hash === normalizedCommitHash)
+        : summary.commits[0];
     if (!selectedCommit) {
         throw new UnpushedCommitDiffSelectionError('The selected commit is no longer in the local commits list.');
     }
-    const oldestCommit = normalizedCommitHash ? selectedCommit : commits[commits.length - 1];
-    const baseCommit = resolveFirstParentOrEmptyTree(cwd, oldestCommit.hash);
+    const oldestCommit = normalizedCommitHash ? selectedCommit : summary.commits[summary.commits.length - 1];
+    const baseCommit = normalizedCommitHash
+        ? resolveFirstParentOrEmptyTree(cwd, oldestCommit.hash)
+        : (summary.baseCommit ?? resolveFirstParentOrEmptyTree(cwd, oldestCommit.hash));
     return getCommittedDiffData(cwd, baseCommit, selectedCommit.hash);
 };
 export const listUnpushedCommits = (branch, project = null) => {
     const cwd = resolveWorktreePath(branch, project);
     return listUnpushedCommitsForCwd(cwd, branch, project);
 };
+const assertSquashWorkspace = (cwd, branch, project) => {
+    if (hasActiveGitOperation(cwd)) {
+        throw new Error('Finish or abort the current Git operation before squashing commits.');
+    }
+    const status = getGitStatus(cwd, branch, project);
+    if (!status.branch) {
+        throw new Error('Unable to verify the current branch before squashing commits.');
+    }
+    if (status.branch !== branch) {
+        throw new Error(`The workspace branch changed to "${status.branch}". Refresh and try again.`);
+    }
+    if (status.operation_state !== 'idle') {
+        throw new Error('Finish or abort the current Git operation before squashing commits.');
+    }
+    if (status.files.some(file => file.conflicted)) {
+        throw new Error('Resolve conflicted files before squashing commits.');
+    }
+    if (status.is_dirty || status.has_staged_changes || status.has_unstaged_changes) {
+        throw new Error('Commit, stash, or discard workspace changes before squashing commits.');
+    }
+    return status;
+};
+const getSquashCommitSummary = (cwd, branch, project) => {
+    try {
+        return getUnpushedCommitSummaryForCwd(cwd, branch, project, { throwOnError: true });
+    }
+    catch {
+        throw new Error('Unable to resolve the complete unpushed commit range. Reconcile the branch and refresh before squashing commits.');
+    }
+};
+const assertSquashStateUnchanged = async ({ cwd, branch, project, branchRef, headSha, baseCommitSha, totalCount, }) => {
+    const currentBranchRef = runGitText(['symbolic-ref', '--quiet', 'HEAD'], cwd).trim();
+    const currentHeadSha = resolveHeadCommit(cwd);
+    if (currentBranchRef !== branchRef || currentHeadSha !== headSha) {
+        throw new Error('The branch or HEAD changed while preparing the squash. Refresh and try again.');
+    }
+    assertSquashWorkspace(cwd, branch, project);
+    const refreshedUpstreamCommitSha = await refreshSquashUpstream(branch, cwd);
+    const currentSummary = getSquashCommitSummary(cwd, branch, project);
+    const currentBaseCommitSha = currentSummary.baseCommit
+        ? resolveCommitSha(currentSummary.baseCommit, cwd)
+        : null;
+    if (currentSummary.totalCount !== totalCount
+        || currentBaseCommitSha !== baseCommitSha
+        || (refreshedUpstreamCommitSha !== null && refreshedUpstreamCommitSha !== baseCommitSha)) {
+        throw new Error('The unpushed commit range changed while preparing the squash. Refresh and try again.');
+    }
+};
+export const squashUnpushedCommitsForCwd = async (cwd, branch, project, message) => {
+    const normalizedMessage = message.trim();
+    if (!normalizedMessage) {
+        throw new Error('A commit message is required.');
+    }
+    const branchRef = runGitText(['symbolic-ref', '--quiet', 'HEAD'], cwd).trim();
+    if (branchRef !== `refs/heads/${branch}`) {
+        throw new Error(`The workspace is no longer on branch "${branch}". Refresh and try again.`);
+    }
+    const preActionHead = getGitHeadIdentity(cwd);
+    assertSquashWorkspace(cwd, branch, project);
+    const refreshedUpstreamCommitSha = await refreshSquashUpstream(branch, cwd);
+    const summary = getSquashCommitSummary(cwd, branch, project);
+    if (summary.totalCount < 2) {
+        throw new Error('At least two unpushed commits are required to squash.');
+    }
+    const baseCommitSha = summary.baseCommit
+        ? resolveCommitSha(summary.baseCommit, cwd)
+        : null;
+    if (!baseCommitSha) {
+        throw new Error('Unable to resolve the upstream or worktree base. Reconcile the branch before squashing commits.');
+    }
+    if (refreshedUpstreamCommitSha !== null && refreshedUpstreamCommitSha !== baseCommitSha) {
+        throw new Error('The upstream branch changed while preparing the squash. Refresh and try again.');
+    }
+    try {
+        runGitText(['merge-base', '--is-ancestor', baseCommitSha, preActionHead.headSha], cwd);
+    }
+    catch {
+        throw new Error('The resolved base is not an ancestor of HEAD. Pull or rebase the branch before squashing commits.');
+    }
+    const preActionIndexTreeSha = getGitIndexTreeSha(cwd);
+    if (preActionIndexTreeSha !== preActionHead.treeSha) {
+        throw new Error('The index changed while preparing the squash. Refresh and try again.');
+    }
+    await assertSquashStateUnchanged({
+        cwd,
+        branch,
+        project,
+        branchRef,
+        headSha: preActionHead.headSha,
+        baseCommitSha,
+        totalCount: summary.totalCount,
+    });
+    const commitOutput = await runGitTextAsync([
+        'commit-tree',
+        preActionHead.treeSha,
+        '-p',
+        baseCommitSha,
+        '-m',
+        normalizedMessage,
+    ], cwd);
+    const commitSha = commitOutput.stdout.trim().split(/\s+/)[0] ?? '';
+    if (!commitSha) {
+        throw new Error('Git did not return the new squash commit.');
+    }
+    const commitMetadata = runGitText(['show', '-s', '--format=%H%n%P%n%T', commitSha], cwd).trim().split('\n');
+    const observedCommitSha = commitMetadata[0]?.trim();
+    const observedParents = commitMetadata[1]?.trim().split(/\s+/).filter(Boolean) ?? [];
+    const observedTreeSha = commitMetadata[2]?.trim();
+    if (observedCommitSha !== commitSha
+        || observedParents.length !== 1
+        || observedParents[0] !== baseCommitSha
+        || observedTreeSha !== preActionHead.treeSha) {
+        throw new Error('The new squash commit did not match the expected tree and parent.');
+    }
+    try {
+        await assertSquashStateUnchanged({
+            cwd,
+            branch,
+            project,
+            branchRef,
+            headSha: preActionHead.headSha,
+            baseCommitSha,
+            totalCount: summary.totalCount,
+        });
+    }
+    catch {
+        throw new Error('The branch, workspace, or upstream changed while squashing commits. Refresh and try again.');
+    }
+    try {
+        await runGitTextAsync(['update-ref', branchRef, commitSha, preActionHead.headSha], cwd);
+    }
+    catch {
+        throw new Error('The branch or HEAD changed while squashing commits. No branch ref was overwritten; refresh and try again.');
+    }
+    try {
+        const finalHead = getGitHeadIdentity(cwd);
+        const finalIndexTreeSha = getGitIndexTreeSha(cwd);
+        const finalStatus = assertSquashWorkspace(cwd, branch, project);
+        const finalUpstreamCommitSha = await refreshSquashUpstream(branch, cwd);
+        const finalSummary = getSquashCommitSummary(cwd, branch, project);
+        const finalBaseCommitSha = finalSummary.baseCommit
+            ? resolveCommitSha(finalSummary.baseCommit, cwd)
+            : null;
+        if (finalHead.headSha !== commitSha
+            || finalHead.treeSha !== preActionHead.treeSha
+            || finalIndexTreeSha !== preActionIndexTreeSha
+            || finalStatus.is_dirty
+            || finalSummary.totalCount !== 1
+            || finalBaseCommitSha !== baseCommitSha
+            || (finalUpstreamCommitSha !== null && finalUpstreamCommitSha !== baseCommitSha)) {
+            throw new Error('The workspace or squash base changed while squashing commits.');
+        }
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error);
+        try {
+            await runGitTextAsync(['update-ref', branchRef, preActionHead.headSha, commitSha], cwd);
+        }
+        catch {
+            throw new Error(`${reason} The branch ref could not be rolled back safely; inspect the branch before retrying.`);
+        }
+        throw new Error(`${reason} The branch ref was rolled back safely; refresh the Changes view and try again.`);
+    }
+    return {
+        commitSha,
+        parentSha: baseCommitSha,
+        treeSha: preActionHead.treeSha,
+    };
+};
+export const squashUnpushedCommits = async (branch, project, message) => {
+    const cwd = resolveWorktreePath(branch, project);
+    return squashUnpushedCommitsForCwd(cwd, branch, project, message);
+};
 export const undoLatestUnpushedCommitForCwd = async (cwd, branch, project = null) => {
     const commits = listUnpushedCommitsForCwd(cwd, branch, project);
     if (commits.length === 0) {