@henryqw/pi-pr 4.0.3 → 4.0.5

package/extensions/pr-merge.ts

@@ -1,12 +1,14 @@
-import { inspectWorktree, type Exec, type ExecResult } from "./pr-execution.ts";
+import {
+	inspectWorktree,
+	readHead,
+	requiredOid,
+	requiredText,
+	runChecked,
+	type Exec,
+} from "./pr-execution.ts";
 import type { LocalMergeSafety } from "./pr-routing.ts";
 
-export type { Exec, ExecResult } from "./pr-execution.ts";
-
-export type MergeMethod = "merge" | "rebase" | "squash";
-
 const MERGE_PULL_REQUEST_MUTATION = "mutation($pullRequestId:ID!,$expectedHeadOid:GitObjectID!,$mergeMethod:PullRequestMergeMethod!){mergePullRequest(input:{pullRequestId:$pullRequestId,expectedHeadOid:$expectedHeadOid,mergeMethod:$mergeMethod}){pullRequest{id state}}}";
-const OID = /^(?:[0-9a-f]{40}|[0-9a-f]{64})$/;
 
 export type InspectLocalMergeSafetyInput = {
 	exec: Exec;
@@ -15,16 +17,11 @@ export type InspectLocalMergeSafetyInput = {
 	headFetchSource: string;
 };
 
-export type MergeMethodSelectionInput = {
-	allowedMergeMethods: readonly MergeMethod[];
-	viewerDefaultMergeMethod?: MergeMethod | null;
-};
-
 export type InspectedLocalMergeSafety = LocalMergeSafety & {
 	headOid: string;
 };
 
-export type ExecuteGitHubMergeInput = MergeMethodSelectionInput & InspectLocalMergeSafetyInput & {
+export type ExecuteGitHubMergeInput = InspectLocalMergeSafetyInput & {
 	pullRequestId: string;
 	hostname: string;
 	expectedBase: {
@@ -35,62 +32,10 @@ export type ExecuteGitHubMergeInput = MergeMethodSelectionInput & InspectLocalMe
 	revalidateReadiness: (local: InspectedLocalMergeSafety) => Promise<void>;
 };
 
-function commandText(command: string, args: string[]): string {
-	return [command, ...args].join(" ");
-}
-
-function errorText(error: unknown): string {
-	return error instanceof Error ? error.message : String(error);
-}
-
-function commandFailure(command: string, args: string[], detail: string): Error {
-	return new Error(`${commandText(command, args)} failed: ${detail}`);
-}
-
-async function runCommand(
-	exec: Exec,
-	cwd: string,
-	command: string,
-	args: string[],
-	allowedCodes: readonly number[] = [0],
-): Promise<ExecResult> {
-	let result: ExecResult;
-	try {
-		result = await exec(command, args, { cwd });
-	} catch (error) {
-		throw commandFailure(command, args, errorText(error));
-	}
-
-	if (result.killed || !allowedCodes.includes(result.code)) {
-		const detail = result.stderr.trim() || result.stdout.trim() || (result.killed ? "command was killed" : `exit code ${result.code}`);
-		throw commandFailure(command, args, detail);
-	}
-	return result;
-}
-
-function requiredText(value: unknown, label: string): string {
-	if (typeof value !== "string" || !value || value.trim() !== value || /[\u0000-\u001f\u007f]/.test(value)) {
-		throw new TypeError(`${label} must be a non-empty string`);
-	}
-	return value;
-}
-
-function requiredOid(value: unknown, label: string): string {
-	const parsed = requiredText(value, label);
-	if (!OID.test(parsed)) throw new TypeError(`${label} must be a full Git OID`);
-	return parsed;
-}
-
 function isRecord(value: unknown): value is Record<string, unknown> {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
-function requiredOutput(result: ExecResult, label: string): string {
-	const output = result.stdout.trim();
-	if (!output) throw new Error(`${label} returned no output`);
-	return output;
-}
-
 function validateInspectionInput(input: InspectLocalMergeSafetyInput): void {
 	requiredText(input.cwd, "cwd");
 	requiredOid(input.expectedHead, "expected PR head");
@@ -98,76 +43,43 @@ function validateInspectionInput(input: InspectLocalMergeSafetyInput): void {
 	if (typeof input.exec !== "function") throw new TypeError("exec must be a function");
 }
 
-async function readLocalHead(exec: Exec, cwd: string): Promise<string> {
-	return requiredOid(
-		requiredOutput(await runCommand(exec, cwd, "git", ["rev-parse", "--verify", "HEAD^{commit}"]), "local HEAD"),
-		"local HEAD",
-	);
-}
-
 /** Inspect local state without changing branches, the index, or the worktree. */
 export async function inspectLocalMergeSafety(input: InspectLocalMergeSafetyInput): Promise<InspectedLocalMergeSafety> {
 	validateInspectionInput(input);
 
 	const worktree = await inspectWorktree(input.exec, { cwd: input.cwd });
-	await runCommand(input.exec, input.cwd, "git", [
+	await runChecked(input.exec, "git", [
 		"fetch",
 		"--no-write-fetch-head",
 		"--no-tags",
 		"--no-recurse-submodules",
 		input.headFetchSource,
 		input.expectedHead,
-	]);
-	await runCommand(input.exec, input.cwd, "git", ["cat-file", "-e", `${input.expectedHead}^{commit}`]);
+	], { cwd: input.cwd });
+	await runChecked(input.exec, "git", ["cat-file", "-e", `${input.expectedHead}^{commit}`], { cwd: input.cwd });
 
-	const headOid = await readLocalHead(input.exec, input.cwd);
+	const headOid = await readHead(input.exec, { cwd: input.cwd });
 	if (headOid === input.expectedHead) return { worktree, head: "equal", headOid };
 
-	const localAncestor = await runCommand(
+	const localAncestor = await runChecked(
 		input.exec,
-		input.cwd,
 		"git",
 		["merge-base", "--is-ancestor", headOid, input.expectedHead],
+		{ cwd: input.cwd },
 		[0, 1],
 	);
 	if (localAncestor.code === 0) return { worktree, head: "behind", headOid };
 
-	const expectedAncestor = await runCommand(
+	const expectedAncestor = await runChecked(
 		input.exec,
-		input.cwd,
 		"git",
 		["merge-base", "--is-ancestor", input.expectedHead, headOid],
+		{ cwd: input.cwd },
 		[0, 1],
 	);
 	return { worktree, head: expectedAncestor.code === 0 ? "ahead" : "diverged", headOid };
 }
 
-function validateMergeMethods(input: MergeMethodSelectionInput): void {
-	if (!Array.isArray(input.allowedMergeMethods)) throw new TypeError("allowedMergeMethods must be an array");
-	if (input.allowedMergeMethods.some((method) => method !== "merge" && method !== "rebase" && method !== "squash")) {
-		throw new TypeError("allowedMergeMethods contains an unsupported method");
-	}
-	if (
-		input.viewerDefaultMergeMethod !== undefined &&
-		input.viewerDefaultMergeMethod !== null &&
-		input.viewerDefaultMergeMethod !== "merge" &&
-		input.viewerDefaultMergeMethod !== "rebase" &&
-		input.viewerDefaultMergeMethod !== "squash"
-	) throw new TypeError("viewerDefaultMergeMethod is unsupported");
-}
-
-export function selectMergeMethod(input: MergeMethodSelectionInput): MergeMethod {
-	validateMergeMethods(input);
-	if (input.allowedMergeMethods.length === 1) return input.allowedMergeMethods[0]!;
-	if (input.allowedMergeMethods.includes("squash")) return "squash";
-	if (
-		input.viewerDefaultMergeMethod !== undefined &&
-		input.viewerDefaultMergeMethod !== null &&
-		input.allowedMergeMethods.includes(input.viewerDefaultMergeMethod)
-	) return input.viewerDefaultMergeMethod;
-	throw new Error("No deterministic GitHub merge method is available");
-}
-
 function validateExecuteInput(input: ExecuteGitHubMergeInput): void {
 	validateInspectionInput(input);
 	requiredText(input.pullRequestId, "pullRequestId");
@@ -216,7 +128,6 @@ function parseMergeResponse(output: string, expectedId: string): void {
 
 export async function executeGitHubMerge(input: ExecuteGitHubMergeInput): Promise<void> {
 	validateExecuteInput(input);
-	const method = selectMergeMethod(input);
 	const local = await inspectLocalMergeSafety(input);
 	if (local.worktree !== "clean" || (local.head !== "equal" && local.head !== "behind")) {
 		throw new Error(`Local merge safety check failed: worktree is ${local.worktree}, HEAD is ${local.head}`);
@@ -226,11 +137,11 @@ export async function executeGitHubMerge(input: ExecuteGitHubMergeInput): Promis
 	if (finalWorktree !== "clean") {
 		throw new Error("Final local merge safety check failed: worktree is dirty");
 	}
-	const finalHead = await readLocalHead(input.exec, input.cwd);
+	const finalHead = await readHead(input.exec, { cwd: input.cwd });
 	if (finalHead !== local.headOid) {
 		throw new Error(`Final local merge safety check failed: HEAD changed from ${local.headOid} to ${finalHead}`);
 	}
-	const merged = await runCommand(input.exec, input.cwd, "gh", [
+	const merged = await runChecked(input.exec, "gh", [
 		"api",
 		"graphql",
 		"--hostname",
@@ -242,7 +153,9 @@ export async function executeGitHubMerge(input: ExecuteGitHubMergeInput): Promis
 		"-F",
 		`expectedHeadOid=${input.expectedHead}`,
 		"-F",
-		`mergeMethod=${method.toUpperCase()}`,
-	]);
-	parseMergeResponse(requiredOutput(merged, "GitHub merge"), input.pullRequestId);
+		"mergeMethod=SQUASH",
+	], { cwd: input.cwd });
+	const output = merged.stdout.trim();
+	if (!output) throw new Error("GitHub merge returned no output");
+	parseMergeResponse(output, input.pullRequestId);
 }

package/extensions/pr-update-branch.ts

@@ -17,7 +17,6 @@ import {
 	runChecked,
 	spawnBounded,
 	withWorktreeLock,
-	type AttemptState,
 	type Exec,
 	type ExecOptions,
 } from "./pr-execution.ts";
@@ -26,13 +25,6 @@ export type UpdateBranchPhase = "ready" | "conflict-awaiting-user" | "verified"
 
 export type UpdateBranchState = {
 	phase: UpdateBranchPhase;
-	attempts: {
-		fetchBase: AttemptState;
-		merge: AttemptState;
-		stage: AttemptState;
-		continueMerge: AttemptState;
-		push: AttemptState;
-	};
 	verifiedHead?: string;
 	conflict?: { paths: string[]; statusBaseline: string };
 };
@@ -62,7 +54,6 @@ function cloneAuthority(value: CurrentPullRequest): CurrentPullRequest {
 		base: { ...value.base },
 		head: { ...value.head },
 		target: { ...value.target },
-		merge: value.merge ? { ...value.merge, allowedMergeMethods: [...value.merge.allowedMergeMethods] } : null,
 	};
 }
 
@@ -89,10 +80,7 @@ function validateDeclaredPaths(paths: readonly string[], expected: readonly stri
 }
 
 export class PullRequestBranchUpdater {
-	readonly state: UpdateBranchState = {
-		phase: "ready",
-		attempts: { fetchBase: "none", merge: "none", stage: "none", continueMerge: "none", push: "none" },
-	};
+	readonly state: UpdateBranchState = { phase: "ready" };
 
 	private readonly cwd: string;
 	private readonly authority: CurrentPullRequest;
@@ -188,26 +176,18 @@ export class PullRequestBranchUpdater {
 	}
 
 	async merge(): Promise<UpdateBranchResult> {
-		if (this.state.phase !== "ready" || this.state.attempts.fetchBase !== "none" || this.state.attempts.merge !== "none") {
-			throw new Error("Branch update merge action was already consumed");
-		}
+		if (this.state.phase !== "ready") throw new Error("Branch update merge action was already consumed");
 		return await withWorktreeLock(this.cwd, async () => {
 			await this.freshAuthority(this.authority.head.oid, true);
 			const source = await resolveRepositoryFetchSource(this.exec, this.execOptions(), {
 				host: this.authority.host,
 				repository: this.authority.base.repository,
 			});
-			this.state.attempts.fetchBase = "attempting";
-			try {
-				await runChecked(this.exec, "git", [
-					"fetch", "--no-write-fetch-head", "--no-tags", "--no-recurse-submodules", source, this.authority.base.oid,
-				], this.execOptions());
-				await runChecked(this.exec, "git", ["cat-file", "-e", `${this.authority.base.oid}^{commit}`], this.execOptions());
-				this.state.attempts.fetchBase = "applied";
-			} catch (error) {
-				this.state.attempts.fetchBase = "unknown";
-				throw error;
-			}
+			this.state.phase = "blocked";
+			await runChecked(this.exec, "git", [
+				"fetch", "--no-write-fetch-head", "--no-tags", "--no-recurse-submodules", source, this.authority.base.oid,
+			], this.execOptions());
+			await runChecked(this.exec, "git", ["cat-file", "-e", `${this.authority.base.oid}^{commit}`], this.execOptions());
 			await this.freshAuthority(this.authority.head.oid, true);
 			if (await isAncestor(this.exec, this.execOptions(), this.authority.base.oid, this.authority.head.oid)) {
 				this.state.phase = "verified";
@@ -215,35 +195,16 @@ export class PullRequestBranchUpdater {
 				return { kind: "verified", head: this.authority.head.oid, fastForward: false };
 			}
 
-			this.state.attempts.merge = "attempting";
-			let result;
-			try {
-				result = await this.exec("git", ["merge", "--no-edit", this.authority.base.oid], this.execOptions());
-			} catch (error) {
-				this.state.attempts.merge = "unknown";
-				throw error;
-			}
-			if (result.killed) {
-				this.state.attempts.merge = "unknown";
-				throw new Error("git merge was killed; its outcome is unknown");
-			}
+			const result = await this.exec("git", ["merge", "--no-edit", this.authority.base.oid], this.execOptions());
+			if (result.killed) throw new Error("git merge was killed; its outcome is unknown");
 			if (result.code === 0) {
-				try {
-					const verified = await this.verifyMerge(this.authority.head.oid);
-					this.state.attempts.merge = "applied";
-					return { kind: "verified", ...verified };
-				} catch (error) {
-					this.state.attempts.merge = "unknown";
-					throw error;
-				}
+				const verified = await this.verifyMerge(this.authority.head.oid);
+				return { kind: "verified", ...verified };
 			}
 			try {
 				const paths = await this.captureConflict();
-				this.state.attempts.merge = "applied";
 				return { kind: "conflict", paths: [...paths] };
 			} catch (error) {
-				this.state.attempts.merge = "blocked";
-				this.state.phase = "blocked";
 				const detail = result.stderr.trim() || result.stdout.trim() || `exit code ${result.code}`;
 				throw new Error(`git merge failed: ${detail}; ${error instanceof Error ? error.message : String(error)}`);
 			}
@@ -262,36 +223,19 @@ export class PullRequestBranchUpdater {
 			const status = await runChecked(this.exec, "git", ["status", "--porcelain=v2", "-z", "--untracked-files=all"], this.execOptions());
 			assertOnlyDeclaredStatusChanged(this.state.conflict!.statusBaseline, status.stdout, paths);
 
-			if (this.state.attempts.stage !== "none") throw new Error("Conflict staging action was already consumed");
-			this.state.attempts.stage = "attempting";
-			try {
-				await runChecked(this.exec, "git", ["add", "--", ...paths], this.execOptions());
-				this.state.attempts.stage = "applied";
-			} catch (error) {
-				this.state.attempts.stage = "unknown";
-				throw error;
-			}
+			this.state.phase = "blocked";
+			await runChecked(this.exec, "git", ["add", "--", ...paths], this.execOptions());
 			const unmerged = parseNulPaths((await runChecked(this.exec, "git", ["diff", "--name-only", "-z", "--diff-filter=U"], this.execOptions())).stdout, "Unmerged paths");
-			if (unmerged.length) {
-				this.state.phase = "blocked";
-				throw new Error(`Conflict paths remain unresolved: ${unmerged.join(", ")}`);
-			}
+			if (unmerged.length) throw new Error(`Conflict paths remain unresolved: ${unmerged.join(", ")}`);
 
-			this.state.attempts.continueMerge = "attempting";
-			try {
-				await runChecked(this.exec, "git", ["-c", "core.editor=true", "merge", "--continue"], this.execOptions());
-				const verified = await this.verifyMerge(this.authority.head.oid);
-				this.state.attempts.continueMerge = "applied";
-				return { kind: "verified", ...verified };
-			} catch (error) {
-				this.state.attempts.continueMerge = "unknown";
-				throw error;
-			}
+			await runChecked(this.exec, "git", ["-c", "core.editor=true", "merge", "--continue"], this.execOptions());
+			const verified = await this.verifyMerge(this.authority.head.oid);
+			return { kind: "verified", ...verified };
 		}, { agentDir: this.agentDir, signal: this.signal });
 	}
 
 	async publish(): Promise<UpdateBranchResult> {
-		if (this.state.phase !== "verified" || !this.state.verifiedHead || this.state.attempts.push !== "none") {
+		if (this.state.phase !== "verified" || !this.state.verifiedHead) {
 			throw new Error("Branch update is not ready to publish");
 		}
 		const head = this.state.verifiedHead;
@@ -306,22 +250,16 @@ export class PullRequestBranchUpdater {
 				throw new Error("Published branch would not be a fast-forward of the frozen remote OID");
 			}
 			await this.freshAuthority(head, true);
-			this.state.attempts.push = "attempting";
-			try {
-				await runChecked(this.exec, "git", [
-					"push", "--porcelain", `--force-with-lease=refs/heads/${this.authority.target.ref}:${original}`,
-					"--recurse-submodules=no", "--", this.authority.target.fetchSource,
-					`${head}:refs/heads/${this.authority.target.ref}`,
-				], this.execOptions());
-				const remote = await readRemoteOid(this.exec, this.execOptions(), this.authority.target.fetchSource, this.authority.target.ref);
-				if (remote !== head) throw new Error("Published remote ref did not match verified HEAD");
-				this.state.attempts.push = "applied";
-				this.state.phase = "published";
-				return { kind: "published", head };
-			} catch (error) {
-				this.state.attempts.push = "unknown";
-				throw error;
-			}
+			this.state.phase = "blocked";
+			await runChecked(this.exec, "git", [
+				"push", "--porcelain", `--force-with-lease=refs/heads/${this.authority.target.ref}:${original}`,
+				"--recurse-submodules=no", "--", this.authority.target.fetchSource,
+				`${head}:refs/heads/${this.authority.target.ref}`,
+			], this.execOptions());
+			const remote = await readRemoteOid(this.exec, this.execOptions(), this.authority.target.fetchSource, this.authority.target.ref);
+			if (remote !== head) throw new Error("Published remote ref did not match verified HEAD");
+			this.state.phase = "published";
+			return { kind: "published", head };
 		}, { agentDir: this.agentDir, signal: this.signal });
 	}
 }

package/extensions/pr.ts

@@ -5,7 +5,7 @@ import {
 	type ExtensionAPI,
 	type ExtensionContext,
 } from "@earendil-works/pi-coding-agent";
-import { truncateToWidth, type Component, type TUI } from "@earendil-works/pi-tui";
+import { truncateToWidth } from "@earendil-works/pi-tui";
 import { createHerdrClient } from "@henryqw/pi-herdr";
 import { Type } from "typebox";
 import { PullRequestCiFixer, type PullRequestCiFixOptions } from "./pr-ci.ts";
@@ -298,14 +298,10 @@ export default function pullRequestExtension(
 	let widgetKind: "presentation" | "routing" = "presentation";
 	let routingSpinnerFrame = 0;
 	let routingSpinnerTimer: ReturnType<typeof setInterval> | undefined;
-	let routingSpinnerTui: TUI | undefined;
-	let routingSpinnerComponent: (Component & { dispose(): void }) | undefined;
 
 	const stopRoutingSpinner = (): void => {
 		if (routingSpinnerTimer !== undefined) clearInterval(routingSpinnerTimer);
 		routingSpinnerTimer = undefined;
-		routingSpinnerTui = undefined;
-		routingSpinnerComponent = undefined;
 	};
 
 	const clearWorkflow = (selected: WorkflowContext | undefined): void => {
@@ -526,42 +522,30 @@ export default function pullRequestExtension(
 		stopRoutingSpinner();
 		widgetKind = "routing";
 		routingSpinnerFrame = 0;
-		if (ctx.mode !== "tui") {
-			ctx.ui.setWidget(UI_KEY, [`${ROUTING_SPINNER_FRAMES[0]} ${ROUTING_WIDGET_TEXT}`]);
-			return;
-		}
+		const update = (): void => {
+			const frame = ROUTING_SPINNER_FRAMES[routingSpinnerFrame]!;
+			if (ctx.mode === "tui") {
+				ctx.ui.setWidget(UI_KEY, (_tui, theme) => ({
+					invalidate() {},
+					render(width) {
+						if (width <= 0) return [];
+						return [truncateToWidth(`${theme.fg("accent", frame)} ${ROUTING_WIDGET_TEXT}`, width)];
+					},
+				}));
+				return;
+			}
+			ctx.ui.setWidget(UI_KEY, [`${frame} ${ROUTING_WIDGET_TEXT}`]);
+		};
+		update();
+		if (ctx.mode !== "tui") return;
 
-		ctx.ui.setWidget(UI_KEY, (tui, theme) => {
-			let cachedWidth: number | undefined;
-			let cachedLines: string[] | undefined;
-			const component: Component & { dispose(): void } = {
-				invalidate() {
-					cachedWidth = undefined;
-					cachedLines = undefined;
-				},
-				render(width) {
-					if (width <= 0) return [];
-					if (cachedLines !== undefined && cachedWidth === width) return cachedLines;
-					const line = `${theme.fg("accent", ROUTING_SPINNER_FRAMES[routingSpinnerFrame]!)} ${ROUTING_WIDGET_TEXT}`;
-					cachedWidth = width;
-					cachedLines = [truncateToWidth(line, Math.max(1, width))];
-					return cachedLines;
-				},
-				dispose() {
-					if (routingSpinnerComponent !== component) return;
-					stopRoutingSpinner();
-					widgetKind = "presentation";
-				},
-			};
-			routingSpinnerTui = tui;
-			routingSpinnerComponent = component;
-			return component;
-		});
-		routingSpinnerTimer = setInterval(() => {
+		let spinnerTimer: ReturnType<typeof setInterval>;
+		spinnerTimer = setInterval(() => {
+			if (routingSpinnerTimer !== spinnerTimer || widgetKind !== "routing") return;
 			routingSpinnerFrame = (routingSpinnerFrame + 1) % ROUTING_SPINNER_FRAMES.length;
-			routingSpinnerComponent?.invalidate();
-			routingSpinnerTui?.requestRender();
+			update();
 		}, ROUTING_SPINNER_INTERVAL_MS);
+		routingSpinnerTimer = spinnerTimer;
 	};
 
 	const reconcileWidget = (ctx: ExtensionContext): void => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@henryqw/pi-pr",
-  "version": "4.0.3",
+  "version": "4.0.5",
   "description": "Run /pr to safely discover or link the current pull request, then create, update, address feedback, fix CI, or merge when ready.",
   "keywords": [
     "pi-package",
@@ -33,7 +33,11 @@
   },
   "dependencies": {
     "@henryqw/pi-config-store": "^1.1.0",
-    "@henryqw/pi-herdr": "^0.4.5"
+    "@henryqw/pi-herdr": "^0.4.5",
+    "proper-lockfile": "^4.1.2"
+  },
+  "devDependencies": {
+    "@types/proper-lockfile": "^4.1.4"
   },
   "repository": {
     "type": "git",