prreviewbuddy 0.64.2 → 0.70.2

package/dist/main.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { $n as loadWorkspace, $r as detectAgents, $t as bootstrapUrl, A as reanalyseReview, B as telemetryUploadEnabled, Bn as clearClaim, En as checkReview, F as record$1, Fn as PHASES, Gn as groupByLineage, Gr as readAgentPreference, Hn as isClaimed, Hr as resolveAgent, I as stamp, Ir as WITHHELD_REASON, Jr as STORE_ROOT, Kr as writeAgentPreference, Kt as modelHelpLines, L as deliver, Lr as kissOutcome, M as startJob, Mn as isTerminal, N as append, Nn as loadJob, Qt as readIndexToken, R as recordTelemetryUploadConsent, Rn as progressSteps, Rr as resolveTarget, Ur as resolveModel, Ut as readMarker, Vn as driverGone, Vr as git, Wn as followedRefName, Wt as removeWorktree, Xr as DEFAULT_AGENT_ID, Xt as queueForReview, Yr as AGENT_IDS, Zn as lineageKeyFor, Zr as agentById, _ as liveUpdateFor, a as wasBlocked, ar as recentWorkspaces, b as recordKissRun, cn as workspaceUrl, cr as summarise, d as mergeUpdateInto, dn as PACKAGE_NAME, er as matchingWorkspaceIds, f as updateReview, g as UpdateAlreadyRunningError, gn as parseWorkspacePort, hn as MIN_WORKSPACE_PORT, i as liveJobsFor, j as runJob, kn as allJobs, mn as MAX_WORKSPACE_PORT, n as deleteReview$1, nr as positionInLineage, pn as DEFAULT_WORKSPACE_PORT, qr as CONFIG_PATH, qt as relativeTime, rn as reviewsUrl, sn as stopServer, sr as reviewedRepositories, tn as ensureServer, tr as mutateWorkspace, un as BUILD_VERSION, v as runningJobs, vn as statedWorkspacePort, xn as forgeResolver, yn as writePortPreference, z as telemetryUploadConsent, zn as purposeOf, zr as displayRef, zt as MANAGED_ROOT } from "./delete_review-l4p_p6oh.js";
+import { $ as MAX_WORKSPACE_PORT, $r as resolveAgent, A as relativeTime, B as readIndexToken, Dn as MANAGED_ROOT, F as runBatch, Fn as describeSubject, G as reviewsUrl, Gn as loadJob, In as findExistingReview, Jr as resolveTarget, Kr as WITHHELD_REASON, Mn as removeWorktree, Pn as describeMovement, Q as DEFAULT_WORKSPACE_PORT, Qn as clearClaim, Qr as git, R as queueForReview, Tn as modelHelpLines, U as ensureServer, V as bootstrapUrl, Vn as allJobs, X as workspaceUrl, Xn as progressSteps, Y as stopServer, Zn as purposeOf, _ as liveUpdateFor, _r as reviewedRepositories, _t as telemetryUploadConsent, a as wasBlocked, ai as STORE_ROOT, b as recordKissRun, bn as forgeResolver, bt as PACKAGE_NAME, ct as reanalyseReview, d as mergeUpdateInto, dr as mutateWorkspace, dt as append, ei as resolveModel, et as MIN_WORKSPACE_PORT, f as updateReview, fr as positionInLineage, g as UpdateAlreadyRunningError, gt as recordTelemetryUploadConsent, hr as recentWorkspaces, ht as deliver, i as liveJobsFor, ii as CONFIG_PATH, it as writePortPreference, j as batchIdentity, jn as readMarker, li as detectAgents, lr as loadWorkspace, mt as stamp, n as deleteReview$1, ni as readAgentPreference, oi as AGENT_IDS, ot as prepareReview, pt as record$1, qn as PHASES, qr as kissOutcome, ri as writeAgentPreference, rt as statedWorkspacePort, si as agentById, st as settleReview, tr as followedRefName, tt as parseWorkspacePort, ur as matchingWorkspaceIds, ut as startJob, v as runningJobs, vr as summarise, vt as telemetryUploadEnabled, yt as BUILD_VERSION } from "./delete_review-CRPRIRKg.js";
 import { basename, dirname, join, resolve } from "node:path";
 import { spawn } from "node:child_process";
 import { existsSync, mkdirSync, readdirSync, realpathSync, rmSync, statSync, writeFileSync } from "node:fs";
@@ -605,217 +605,6 @@ async function pick(ask, options) {
 	return null;
 }
 //#endregion
-//#region ../../packages/review-harness/src/workspace/existing_review.ts
-/**
-* Is there already a review of what I am standing in?
-*
-* `prreviewbuddy review` used to mean "make another review", every time, which made the most-typed
-* command in the product the one way to end up with two reviews of one branch and no idea which was
-* which. It now means **"give me the review of this branch"**: it creates one the first time and
-* hands back the existing one afterwards. Starting again is `--fresh`, deliberately its own flag.
-*
-* Three properties matter here and all of them are about the answer being trustworthy rather than
-* merely fast:
-*
-* - **It runs before the change set is built.** Building one reads every changed file and its
-*   patch, which on a large change is seconds of work thrown away the moment the answer turns out
-*   to be "you already have this". The lookup is a branch name and a directory.
-* - **It says how old the answer is.** Reviews are kept for thirty days, so on a long-lived branch
-*   the honest answer is often "yes, from three weeks and fifty commits ago". Handing back a link
-*   with no age attached would turn a helpful reply into a trap.
-* - **It answers the question that was asked.** A branch is not the whole of what a review is of:
-*   `--base develop` and `--base main` are two different comparisons of the same commits. Keying
-*   only on the branch meant a reviewer who named a base was handed a review made against a
-*   different one, under a sentence saying it was a review of what they asked for. See
-*   `findExistingReview`.
-*/
-/**
-* The latest review of a resolved target, or null.
-*
-* Takes a target rather than a path because the current branch stopped being the answer the
-* moment a review could run in a worktree. Reviewing `!45` from `main` must find the lineage of
-* `app-1276`, and file into it, or the one-review-per-branch rule holds only for reviewers who
-* happen to be standing in the right place.
-*
-* **The ref is part of the question, not a detail of the answer.** `--branch feat/foo` and
-* `--branch origin/feat/foo` name one branch and can be two different commits, and a review
-* follows exactly one of them for the rest of its life. So the review of the local branch is not
-* an answer to a command that named the remote ref, even on the day they are level. A target with
-* no ref is read as `refs/heads/<branch>`, which is both the pull request case and every review
-* stored before 0.15.0; see `lineageKeyFor`.
-*
-* **An explicit base narrows the lineage.** A base the reviewer named is part of what they asked
-* for, so only a review made against that same base can be the answer to it; the newest review of
-* this branch against some other base is a different comparison wearing the right branch name. A
-* base nobody named narrows nothing, because the command claimed nothing about it: any review of
-* the branch is a truthful answer to "give me the review of this branch".
-*
-* **A pull request number narrows it too.** A request target has no ref, so its lineage key is the
-* head branch name, and two fork requests both called `patch-1` share one. Only a review recording
-* the same number answers a named request. One recording no number is unknown rather than a
-* match, the same strictness as an empty base: the cost is one redundant review, never the wrong one.
-*/
-async function findExistingReview(target) {
-	const groups = groupByLineage(recentWorkspaces(Number.MAX_SAFE_INTEGER));
-	const wanted = target.commit ? lineageKeyFor({
-		kind: "commit",
-		repoPath: target.originRepoPath,
-		sha: target.commit.sha
-	}) : lineageKeyFor({
-		kind: "branch",
-		repoPath: target.originRepoPath,
-		branch: target.branch,
-		followedRef: target.ref
-	});
-	const group = groups.find((entry) => entry.key === wanted);
-	if (!group) return null;
-	const requested = target.pullRequest?.number;
-	const history = target.commit ? group.history : group.history.filter((review) => target.base ? madeAgainst(target.base)(review) : true).filter((review) => requested ? review.prNumber === requested : true);
-	if (history.length === 0) return null;
-	const summary = history[0];
-	const found = {
-		id: summary.id,
-		token: summary.token,
-		title: summary.title,
-		branch: summary.branch,
-		baseRef: summary.baseRef,
-		...summary.headResolvedRef ? { headResolvedRef: summary.headResolvedRef } : {},
-		...summary.targetType === "commit" ? { targetType: "commit" } : {},
-		createdAt: summary.createdAt,
-		commitSha: summary.commitSha ?? null,
-		commitsBehind: null,
-		baselineGone: false,
-		total: history.length,
-		inProgress: false
-	};
-	const workspace = loadWorkspace(summary.id);
-	if (!workspace) return found;
-	const inProgress = isRunning(workspace.jobId);
-	try {
-		const { freshness, availability } = await checkReview(workspace);
-		if (availability) return {
-			...found,
-			inProgress,
-			commitAvailable: availability.state === "available"
-		};
-		const code = freshness.code;
-		const baselineGone = code.rewritten || code.reason === "missing-commit";
-		return {
-			...found,
-			inProgress,
-			commitSha: code.reviewedSha ?? found.commitSha,
-			commitsBehind: baselineGone ? null : code.state === "current" ? 0 : code.newCommits,
-			baselineGone
-		};
-	} catch {
-		return {
-			...found,
-			inProgress
-		};
-	}
-}
-/**
-* Was this review made against the base the reviewer named?
-*
-* Compared in `displayRef`'s short form, which is the form the store holds, so `--base origin/main`
-* and a review made against the default remote branch recognise each other. Anything else is
-* compared as typed: a tag or a sha is a base like any other, and two different spellings of one
-* commit read here as two comparisons, which costs a redundant review rather than a wrong answer.
-*
-* An empty `baseRef` is a review that stopped before it worked out what it was comparing against,
-* and it never matches. Unknown is not the same as "the one you asked for", and this is the one
-* place where guessing would put a review of some other base behind a sentence naming this one.
-* The cost of being strict is small and bounded: a second review starts, of the comparison that
-* was actually requested.
-*/
-function madeAgainst(requested) {
-	const wanted = displayRef(requested);
-	return (review) => review.baseRef !== "" && displayRef(review.baseRef) === wanted;
-}
-/**
-* Whether the job behind a stored review is still working. A review with no job never was.
-*
-* A job whose driver has gone is not working, whatever phase its record was left at. Calling it in
-* progress told the reviewer who had just closed a terminal that there was "nothing to do but wait",
-* for a process that no longer existed, until the sweep called it failed half an hour later.
-*/
-function isRunning(jobId) {
-	if (!jobId) return false;
-	const job = loadJob(jobId);
-	return !!job && !isTerminal(job) && !driverGone(job.id);
-}
-/**
-* What the review is of, as the clause both surfaces hang off "Made two hours ago".
-*
-* The base is in it because a review is of a comparison rather than of a branch, and the one thing
-* a reviewer cannot see from the outside is which comparison they are being handed. The command
-* that named a base now gets one made against it, but the far commoner case is the command that
-* named none, and there this clause is the only thing that says what was compared.
-*
-* Each half is dropped when it is not known, rather than rendered as a placeholder: a review made
-* before commits were recorded, or one that stopped before it resolved its base, says less rather
-* than saying something untrue.
-*/
-function describeSubject(existing) {
-	const parts = [...existing.commitSha ? [`of commit ${existing.commitSha.slice(0, 7)}`] : [], ...existing.baseRef ? [`against ${existing.baseRef}`] : []];
-	return parts.length ? `, ${parts.join(" ")}` : "";
-}
-/**
-* How far the branch has moved since the review was made, in one sentence.
-*
-* Exported because both surfaces say it and they say the same thing. The sentences around it
-* differ, because one is addressed to a session that must decide not to review anything and the
-* other to a person deciding whether to press update, but this fact reads identically to both.
-*
-* It names the branch rather than the reader's checkout, which 0.15.0 corrected rather than
-* changed. `commitsBehind` comes from `codeFreshness`, which measures by ref name and never reads
-* HEAD, so the fact underneath was always about the branch and the sentence merely called it
-* something else. `--branch` turns that from loose into wrong: a review of `feat/foo` made while
-* standing on `main` would report `feat/foo`'s movement in a sentence claiming it was the
-* reviewer's own working tree.
-*/
-function describeMovement(existing) {
-	if (existing.targetType === "commit") return existing.commitAvailable === false ? "That commit is no longer in this repository, so the review can be read but not analysed again." : "A commit does not move, so the review still describes exactly that commit.";
-	const subject = followedRefName(existing.branch, existing.headResolvedRef) ?? existing.branch;
-	if (existing.baselineGone) return `${subject} has been rebuilt since, so that commit is no longer on it.`;
-	if (existing.commitsBehind === null) return `How far ${subject} has moved since could not be worked out.`;
-	if (existing.commitsBehind === 0) return `It is of the latest commit on ${subject}.`;
-	return `${subject} has moved ${existing.commitsBehind} commit${existing.commitsBehind === 1 ? "" : "s"} since.`;
-}
-//#endregion
-//#region src/batch_schedule.ts
-/**
-* Run `run` over every item, at most `concurrency` at once, and report each one's ending.
-*
-* Never throws for an item: one that rejects is recorded and the rest carry on. Once `signal` is
-* aborted nothing more starts, and what is already running is waited for, because it is the work's
-* own job to notice the abort and stop.
-*/
-async function runBatch(items, options) {
-	const outcomes = items.map(() => ({ kind: "not-started" }));
-	let next = 0;
-	const lane = async () => {
-		while (next < items.length && !options.signal?.aborted) {
-			const index = next;
-			next += 1;
-			try {
-				outcomes[index] = {
-					kind: "done",
-					value: await options.run(items[index], index)
-				};
-			} catch (error) {
-				outcomes[index] = {
-					kind: "threw",
-					error
-				};
-			}
-		}
-	};
-	const lanes = Math.max(1, Math.min(options.concurrency, items.length));
-	await Promise.all(Array.from({ length: lanes }, lane));
-	return outcomes;
-}
-//#endregion
 //#region src/progress.ts
 /**
 * What the review is doing, while it does it.
@@ -2023,7 +1812,7 @@ async function reviewBatch(command, repoPath, deps = realDeps()) {
 			row.state = { kind: "not-started" };
 			return;
 		}
-		const identity = `${target.originRepoPath}\n${target.pullRequest?.number ?? target.sha}`;
+		const identity = batchIdentity(target);
 		const first = claimed.get(identity);
 		if (first !== void 0) {
 			row.state = {
@@ -2636,109 +2425,6 @@ function makeCommandFor(command) {
 	if (command.commitRef) return `prreviewbuddy review --commit ${command.commitRef}`;
 	return "prreviewbuddy review";
 }
-/** Why an unfinished review is being picked up, when nothing recorded a failure because nothing could. */
-var DRIVER_GONE = "the command that was running it ended before it finished, most often because its terminal closed.";
-function failureOf(workspaceId) {
-	const workspace = loadWorkspace(workspaceId);
-	if (!workspace?.jobId) return null;
-	const job = loadJob(workspace.jobId);
-	if (!job) return null;
-	const abandoned = !isTerminal(job) && driverGone(job.id);
-	if (!abandoned && (!isTerminal(job) || job.phase !== "failed")) return null;
-	if (isClaimed(job.id)) return null;
-	return {
-		message: abandoned ? DRIVER_GONE : job.failure?.message ?? "The reason was not recorded.",
-		stopped: !abandoned && job.failure?.stopped === true,
-		agentId: job.env.agentId ?? DEFAULT_AGENT_ID,
-		...job.requestedModel ? { requestedModel: job.requestedModel } : {}
-	};
-}
-/**
-* What to run for a resolved target, decided and started, with nothing printed.
-*
-* The first half of `review`, and the half a batch shares: a batch says all of it in one summary
-* at the end rather than as it goes, so the deciding and the saying have to be apart.
-*
-* A review that exists is usually a review that finished, and handing it back rather than making a
-* second one is the whole rule. A review whose job failed is the exception, and handing that one
-* back is worse than useless: the reviewer typed a command and would get a link to a page reporting
-* the failure they just caused, with the way out being a button in a browser. It is the same resume
-* the workspace's Retry offers, taken here because this is where the person is.
-*
-* The target is the one already resolved, not re-derived. A request reference is resolved by
-* spawning an agent, and resolving it twice risks pinning the job to a different commit than the one
-* the existing-review check just looked at. It carries the base too, which is why none is passed
-* alongside it: two copies of one answer make one of them the authority without saying which.
-*
-* The agent is the resolved one, not the flag. They are the same string only when somebody typed
-* one: a machine default, a review's own agent and the first-run picker all reach a decision the
-* flag never held, and passing the flag threw all three away. The harness reads an absent id as
-* "whatever the default is", so a configured default of Codex announced Codex and then analysed
-* with Claude, and nothing said so until the failure named the wrong tool.
-*/
-async function prepareReview(target, agentId, fresh, requestedModel) {
-	if (!fresh) {
-		const existing = await findExistingReview(target);
-		if (existing) {
-			const failure = failureOf(existing.id);
-			return failure ? {
-				kind: "resume",
-				existing,
-				failure
-			} : {
-				kind: "existing",
-				existing
-			};
-		}
-	}
-	return {
-		kind: "new",
-		workspaceId: await startJob({
-			target,
-			agentId,
-			...requestedModel ? { requestedModel } : {}
-		})
-	};
-}
-/**
-* Run a review's job to its end and say whether a review came out of it, with nothing printed.
-*
-* Any ending that is not `done`, not only the one that says `failed`. A run that stopped without
-* recording why still stopped, and reading "not failed" as "finished" is what let a job left at
-* `analysing` print `Review ready` over a review that does not exist.
-*
-* The standard review is also checked for a result. A finished analysis always leaves one -- a
-* reply that could not be read is a failure and never reaches here -- so a null one is a bug, and
-* `Review ready . Risk not rated . 0 findings` is the one sentence it must never be reported as:
-* that reads as a clean bill of health, which is the opposite of what happened. A KISS run's
-* answer is checked by `drive`, which knows which run it is.
-*/
-async function settleReview(workspaceId, reviewType = "standard", signal) {
-	let job;
-	try {
-		job = await runJob(workspaceId, {}, reviewType, signal ? { signal } : {});
-	} catch (error) {
-		return {
-			ok: false,
-			reason: error instanceof Error ? error.message : String(error),
-			stopped: false
-		};
-	}
-	if (job.phase !== "done") return {
-		ok: false,
-		reason: failureMessage(job),
-		stopped: job.failure?.stopped === true
-	};
-	if (reviewType === "standard" && !loadWorkspace(workspaceId)?.session?.result) return {
-		ok: false,
-		reason: "The analysis finished without recording a review.",
-		stopped: false
-	};
-	return {
-		ok: true,
-		job
-	};
-}
 /**
 * Run the job to its end, saying what it is doing while it does it.
 *
@@ -2787,18 +2473,6 @@ async function drive(workspaceId, url, kissRun) {
 	return 0;
 }
 /**
-* Why a run ended, when it did not end by finishing.
-*
-* A job that recorded a failure says so in its own words. One that did not is a driver that went
-* away mid-phase -- killed, or crashed past the point where it could write -- and the honest thing
-* to say is which phase it was in, because that is the phase the next run picks up from.
-*/
-function failureMessage(job) {
-	if (job.failure?.message) return job.failure.message;
-	const doing = PHASES[job.phase].doing;
-	return `The reason was not recorded. It was ${doing.charAt(0).toLowerCase()}${doing.slice(1)} when it stopped.`;
-}
-/**
 * Every link this command prints, and the reason they are not plain workspace URLs.
 *
 * A reviewer who only ever runs this command was never sent to the reviews index, so their browser