prreviewbuddy 0.12.0

package/dist/main.js

@@ -0,0 +1,873 @@
+#!/usr/bin/env node
+import { $ as agentById, A as WORK_PHASES, F as loadJob, G as saveWorkspace, H as positionInLineage, K as summarise, L as displayRef, O as relativeTime, P as isTerminal, Q as AGENT_IDS, V as loadWorkspace, W as recentWorkspaces, X as resolveTarget, Z as withBase, d as ensureServer, f as readServerRecord, g as BUILD_VERSION, i as updateReview, k as checkFreshness, l as LANDING_PAGE, m as workspaceUrl, n as record, nt as AgentUnavailableError, p as reviewsUrl, tt as defaultAgent, v as runJob, w as isClaimed, x as forgeResolver, y as startJob, z as groupByLineage } from "./log-DdPaO6Wo.js";
+import { basename } from "node:path";
+import { spawn } from "node:child_process";
+import { platform } from "node:process";
+//#region src/args.ts
+/** Flags that take the next argument as their value, per command. */
+var VALUED = {
+	review: ["--base", "--agent"],
+	open: [],
+	update: []
+};
+/** Flags that stand alone, per command. */
+var BARE = {
+	review: ["--fresh"],
+	open: [],
+	update: []
+};
+function parse(argv) {
+	if (argv.length === 0) return { name: "help" };
+	const [head, ...rest] = argv;
+	if (head === "--help" || head === "-h" || head === "help") return { name: "help" };
+	if (head === "--version" || head === "-v") return { name: "version" };
+	if (head === void 0 || !(head in VALUED)) return {
+		name: "error",
+		message: unknownCommand(head)
+	};
+	const values = {};
+	const flags = /* @__PURE__ */ new Set();
+	const positional = [];
+	for (let index = 0; index < rest.length; index += 1) {
+		const argument = rest[index];
+		if (!argument.startsWith("--")) {
+			positional.push(argument);
+			continue;
+		}
+		const equals = argument.indexOf("=");
+		const name = equals === -1 ? argument : argument.slice(0, equals);
+		if (VALUED[head]?.includes(name)) {
+			const value = equals === -1 ? rest[index + 1] : argument.slice(equals + 1);
+			if (!value) return {
+				name: "error",
+				message: `${name} needs a value after it.`
+			};
+			values[name] = value;
+			if (equals === -1) index += 1;
+			continue;
+		}
+		if (BARE[head]?.includes(name) && equals === -1) {
+			flags.add(name);
+			continue;
+		}
+		return {
+			name: "error",
+			message: `\`${head}\` does not take ${name}. Run \`prreviewbuddy --help\` to see what it takes.`
+		};
+	}
+	if (positional.length > 1) return {
+		name: "error",
+		message: `\`${head}\` takes one argument at most, and was given ${positional.length}.`
+	};
+	const first = positional[0];
+	if (head === "review") return {
+		name: "review",
+		...first ? { argument: first } : {},
+		...values["--base"] ? { base: values["--base"] } : {},
+		...values["--agent"] ? { agentId: values["--agent"] } : {},
+		fresh: flags.has("--fresh")
+	};
+	return {
+		name: head,
+		...first ? { id: first } : {}
+	};
+}
+function unknownCommand(head) {
+	return `There is no \`${head}\` command. This does three things: review, open and update. Run \`prreviewbuddy --help\` for what each one takes.`;
+}
+//#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 a separate, deliberate command.
+*
+* 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.
+*
+* **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".
+*/
+async function findExistingReview(target) {
+	const group = groupByLineage(recentWorkspaces(Number.MAX_SAFE_INTEGER)).find((entry) => entry.latest.repoPath === target.originRepoPath && entry.latest.branch === target.branch);
+	if (!group) return null;
+	const history = target.base ? group.history.filter(madeAgainst(target.base)) : group.history;
+	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,
+		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 code = (await checkFreshness(workspace)).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. */
+function isRunning(jobId) {
+	if (!jobId) return false;
+	const job = loadJob(jobId);
+	return !!job && !isTerminal(job);
+}
+/**
+* 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.
+*/
+function describeMovement(existing) {
+	if (existing.baselineGone) return "The branch has been rebuilt since, so that commit is no longer on it.";
+	if (existing.commitsBehind === null) return "How far the branch has moved since could not be worked out.";
+	if (existing.commitsBehind === 0) return "It is of the commit currently checked out.";
+	return `The checkout has moved ${existing.commitsBehind} commit${existing.commitsBehind === 1 ? "" : "s"} since.`;
+}
+//#endregion
+//#region src/progress.ts
+/**
+* What the review is doing, while it does it.
+*
+* The job record is the source of truth, and it is the same one the workspace page polls over
+* HTTP. Read here directly from the store rather than through the server, because this process is
+* the one driving the job and a loopback request to ask itself what it is doing would be a strange
+* way to find out.
+*
+* This used to print `job.progress ?? job.phase` whenever it changed, which meant the raw phase
+* enum reached the terminal as a bare `preparing` before the first progress note arrived, and every
+* later note appended a line to a growing log. A reviewer could not tell what had finished, what
+* was running, or how much was left.
+*
+* It now renders one block: a header, then a line per phase with a mark for its state, and the
+* agent's own notes indented under whichever phase is currently running. On a terminal the block is
+* redrawn in place, so the review reads as one task progressing rather than as a transcript. Where
+* stderr is not a terminal (a pipe, a CI log, a file) it falls back to appending only the lines
+* that changed, because cursor movement written into a log is worse than a plain list.
+*
+* Progress goes to stderr and the review's link goes to stdout, so `prreviewbuddy review | pbcopy`
+* copies a URL rather than a transcript.
+*/
+var POLL_INTERVAL_MS = 500;
+/**
+* Two forms per phase, because a finished step and a running one are different sentences.
+*
+* The page says these differently again (`job_view.ts`), and deliberately: it is describing a
+* review to someone who arrived after the fact, while this is narrating one to someone watching it
+* happen. Sharing the strings would force one of the two to read wrongly.
+*/
+var PHASES = {
+	preparing: {
+		doing: "Preparing isolated checkout",
+		done: "Prepared isolated checkout"
+	},
+	context: {
+		doing: "Reading what changed",
+		done: "Read what changed"
+	},
+	conversation: {
+		doing: "Reading pull request conversation",
+		done: "Read pull request conversation"
+	},
+	analysing: {
+		doing: "Analysing the change",
+		done: "Analysed the change"
+	},
+	done: {
+		doing: "Finishing",
+		done: "Finished"
+	},
+	failed: {
+		doing: "Stopped",
+		done: "Stopped"
+	}
+};
+/**
+* Colour only where it means something, and never where it cannot be seen.
+*
+* `NO_COLOR` is honoured because this writes to stderr, which people redirect into files and CI
+* logs where escape codes are noise rather than emphasis.
+*/
+function styling(stream) {
+	return stream.isTTY === true && !process.env.NO_COLOR;
+}
+var DIM = "\x1B[2m";
+var GREEN = "\x1B[32m";
+var RED = "\x1B[31m";
+var RESET = "\x1B[0m";
+/** The header above the phases: what is being reviewed, and the facts about how. */
+function header(target, colour) {
+	const meta = `${target.sha.slice(0, 7)} · isolated checkout · ${target.originRepoPath}`;
+	return [
+		`Reviewing ${target.branch}`,
+		colour ? `${DIM}${meta}${RESET}` : meta,
+		""
+	];
+}
+/**
+* One line per phase, marked with its state, and the agent's note under the running one.
+*
+* Completed phases stay visible because they are the part that says how far along this is. Their
+* detail does not: a note about a file read two phases ago is history, and history is what the
+* transcript was made of.
+*/
+function phaseLines(job, colour) {
+	const lines = [];
+	const failedAt = job.phase === "failed" ? job.failure?.phase : void 0;
+	for (const phase of WORK_PHASES) {
+		const complete = job.completed.includes(phase) || job.phase === "done";
+		const failed = failedAt === phase;
+		const current = !complete && !failed && job.phase === phase;
+		const mark = failed ? "✕" : complete ? "✓" : current ? "⟳" : " ";
+		const label = complete || failed ? PHASES[phase].done : PHASES[phase].doing;
+		const paint = failed ? RED : complete ? GREEN : "";
+		if (!complete && !current && !failed) {
+			lines.push(colour ? `${DIM}  ${mark} ${label}${RESET}` : `  ${mark} ${label}`);
+			continue;
+		}
+		lines.push(colour && paint ? `${paint}${mark}${RESET} ${label}` : `${mark} ${label}`);
+		if (current && job.progress && !restates(job.progress, label)) lines.push(colour ? `${DIM}    ${job.progress}${RESET}` : `    ${job.progress}`);
+	}
+	return lines;
+}
+/** Same words as the phase heading, give or take the articles and the trailing full stop. */
+function restates(note, label) {
+	const bare = (text) => text.toLowerCase().replace(/\bthe\b/g, "").replace(/[^a-z]/g, "");
+	return bare(note) === bare(label);
+}
+/**
+* Watch a job and keep one block on the screen describing it.
+*
+* Returns the stop function the caller must call: nothing here may outlive the command, and a
+* stray interval would make `review` hang after the review finished.
+*/
+function followJob(jobId, target, options = {}) {
+	const stream = options.stream ?? process.stderr;
+	const read = options.read ?? loadJob;
+	const colour = styling(stream);
+	const inPlace = stream.isTTY === true;
+	let drawn = 0;
+	let last = "";
+	const paint = () => {
+		const job = read(jobId);
+		if (!job) return;
+		const lines = [...header(target, colour), ...phaseLines(job, colour)];
+		const block = lines.join("\n");
+		if (block === last) return;
+		if (inPlace && drawn > 0) stream.write(`\u001b[${drawn}A\u001b[0J`);
+		stream.write(`${block}\n`);
+		last = block;
+		drawn = lines.length;
+	};
+	const timer = setInterval(paint, POLL_INTERVAL_MS);
+	timer.unref();
+	paint();
+	return () => {
+		clearInterval(timer);
+		paint();
+	};
+}
+//#endregion
+//#region src/text.ts
+/**
+* Everything this binary says, in one place.
+*
+* Kept out of the commands for the same reason `review_tool_text.ts` is kept out of the MCP
+* server: copy is the part worth testing and the hardest part to reach through a command that
+* spawns processes and writes to a store. It is also the part the house style rule applies to, and
+* a rule that depends on everybody remembering is a rule that decays.
+*
+* The audience here is a person at a terminal, which is why almost none of it is shared with the
+* plugin's strings. Those are addressed to a session that has to decide not to analyse anything
+* itself, and carry instructions a person would find baffling.
+*/
+var HELP = `PR Review Buddy reviews a branch in an isolated checkout and opens the result
+in your browser. The review runs in a separate process against a worktree pinned to one commit, so
+your own checkout is never read or written while it works.
+
+  prreviewbuddy review               review the current branch
+  prreviewbuddy review <url>         review the change on a pull request URL
+  prreviewbuddy review --base main   compare against a base branch of your choosing
+  prreviewbuddy review --fresh       review this branch again, keeping the existing review
+  prreviewbuddy review --agent <id>  review with a named agent rather than the default
+
+  prreviewbuddy open                 list your reviews and open the index
+  prreviewbuddy open <id>            open one review
+  prreviewbuddy update               bring the newest review of this repository up to date
+  prreviewbuddy update <id>          bring one review up to date
+
+There is no account, no API key and no configuration. The analysis runs through the agent you have
+already installed and signed in to, and nothing here ever asks you for a credential.
+
+Reviews are kept in ~/.prreviewbuddy for thirty days. The workspace server outlives this command,
+so a review stays open after the terminal that started it has closed. There is no command to stop
+it, on purpose: open any review and use "Stop server" in the left rail. One server serves all of
+them, and the page says so before it asks.
+
+The isolated checkout a review was made in is kept for six hours after it finishes, because that is
+what the assistant reads when you ask it questions, and is then removed along with the rest.`;
+/**
+* An agent asked for by name that this build does not have.
+*
+* Its own sentence rather than the registry's, because the registry's is written for the other
+* direction: reading a stored job whose agent this version no longer knows how to run. Told to
+* somebody who just typed the name, "this review was made with" describes a review that does not
+* exist. What they need is the list.
+*/
+function unknownAgent(id, known) {
+	return `There is no agent called \`${id}\`. This version can run: ${known.join(", ")}.`;
+}
+/** Said before anything expensive happens, so nobody waits on a worktree to be told this. */
+function agentMissing(reason) {
+	return `${reason}\n\nNothing was started. PR Review Buddy runs the analysis through an agent you install and sign in to yourself, so there is no key to set here instead.`;
+}
+/**
+* The link, labelled, and one sentence about what it is.
+*
+* What was reviewed and where now belongs to the live progress block in `progress.ts`, which draws
+* it as a header above the phases. This is the part that goes to stdout and survives a pipe, so it
+* is the link and nothing that would be strange to find in a paste buffer.
+*
+* Labelled because the same URL is printed again when the review finishes. Two bare URLs read as a
+* mistake; `Open workspace now` and `Review ready` read as a beginning and an end.
+*/
+function startedReview(url, _target) {
+	return [`Open workspace now  ${url}`, "The review continues if this terminal closes."].join("\n");
+}
+/**
+* The one-review-per-branch rule, said to a person rather than to a session.
+*
+* The plugin's version of this is a set of instructions about what not to do next. A person does
+* not need to be told not to run the command again; they need the link, its age, and the two ways
+* out, one of which is a flag on the command they just typed.
+*
+* Both ways out are wrong for a review that has not finished, which is why the first thing this
+* asks is whether there is anything to be done to it yet. Offering to update an analysis that has
+* never produced a result is offering to reconcile something against itself.
+*/
+function existingReview(existing, url) {
+	if (existing.inProgress) return [
+		url,
+		"",
+		`A review of ${existing.branch} is being made right now, so here it is rather than a second one.`,
+		`Started ${relativeTime(existing.createdAt)}${describeSubject(existing)}. The link works now and fills in as it goes.`,
+		"",
+		"There is nothing to do but wait. If it stops before it finishes, running this command again picks it up from the phase it reached."
+	].join("\n");
+	const made = `Made ${relativeTime(existing.createdAt)}${describeSubject(existing)}. ${describeMovement(existing)}`;
+	return [
+		url,
+		"",
+		`A review of ${existing.branch} already exists, so here it is rather than a second one.`,
+		made,
+		"",
+		existing.baselineGone ? "This branch has been rebuilt since, so the commit the review was made from is no longer on it. There is nothing left to update it against, so this one needs starting fresh: `prreviewbuddy review --fresh`." : "To update the review in place, keeping your transcript and your place in it, run `prreviewbuddy update`. To start fresh alongside it, run `prreviewbuddy review --fresh`."
+	].join("\n");
+}
+function reviewFinished(url, summary, conversation) {
+	const facts = [
+		summary.overallRisk === "unknown" ? "Risk not rated" : `${cap(summary.overallRisk)} risk`,
+		count(summary.issues, "finding"),
+		count(summary.questions, "question")
+	];
+	const missing = conversation ? conversationMissing(conversation) : "";
+	return `\nReview ready · ${facts.join(" · ")}${missing ? `\n${missing}` : ""}\n${url}`;
+}
+function cap(word) {
+	return word.charAt(0).toUpperCase() + word.slice(1);
+}
+/**
+* An input the review did not get, said to the person who just waited for it.
+*
+* Until now this line existed only on the page, so somebody who ran the command, read the counts
+* and clicked nothing was told a review had been made and not what it had been made from. The
+* counts are the same either way, which is exactly why the silence was dangerous: a review with no
+* conversation cannot know what a colleague already raised, and it looks identical to one that can.
+*
+* Two of the six outcomes stay silent, for the reasons `conversationNote` gives on the page. The
+* other four differ from the page's wording in one respect that matters here: the way out is a
+* command this person can type, not a button they would have to go and find.
+*/
+function conversationMissing(outcome) {
+	const without = "Made without the pull request conversation";
+	switch (outcome.kind) {
+		case "attached":
+		case "no-request": return "";
+		case "unsupported-forge": return outcome.host ? `${without}: PR Review Buddy does not read it on ${outcome.host} yet. This is a review of the code alone.` : `${without}: this repository has no remote to look a pull request up on. This is a review of the code alone.`;
+		case "cli-missing": return `${without}: \`${outcome.cli}\` is not installed. Install it and run \`prreviewbuddy update\` to read it in.`;
+		case "not-authenticated": return `${without}: \`${outcome.cli}\` is not signed in. Run \`${outcome.cli} auth login\`, then \`prreviewbuddy update\` to read it in.`;
+		case "failed": return `${without}. ${outcome.detail} Run \`prreviewbuddy update\` to try again.`;
+	}
+}
+/**
+* A review that stopped, and the one thing worth knowing about it: nothing has to be redone. The
+* worktree is pinned to a commit, so a resumed phase reads byte-identical code, which is what makes
+* resuming and restarting the same thing.
+*/
+function reviewFailed(message, url) {
+	return [
+		"",
+		`Review paused. ${message}`,
+		"",
+		"Nothing was lost. Run the same command again and it carries on from the phase that stopped rather than starting over.",
+		url
+	].join("\n");
+}
+/** Said when the command is picking up a review that stopped, rather than making a second one. */
+function resumingReview(failure) {
+	return `A review of this branch is paused: ${failure}\nCarrying on from where it stopped.`;
+}
+function noReviews() {
+	return "No reviews stored yet. Run `prreviewbuddy review` in a repository to make one.";
+}
+/**
+* Every stored review, with the facts that tell two of them apart.
+*
+* The row used to be the branch, the title, the age and the link, which is enough right up until
+* two rows say the same thing. That happens more readily than it sounds. The title of a branch
+* review is the subject of its oldest commit, so a branch cut from the tip of another inherits
+* that branch's title and both derive it legitimately. This list is machine-wide, so two
+* repositories contribute to it side by side. And reviewing one branch twice, which is a supported
+* thing to do, produced two rows identical but for their age.
+*
+* The first time that happened it was read as contamination and cost an investigation, which is
+* the whole argument for the second line. None of it is new information: the repository, the base
+* and the size are already on the review, and the index page in the browser has shown them since
+* it was rebuilt around branches rather than runs. The terminal never asked for them.
+*
+* The position appears only where there is something to position against. "Review 1 of 1" on the
+* common case is noise dressed as precision.
+*/
+function reviewList(reviews) {
+	return reviews.map((review) => `${review.summary.branch}  ${review.summary.title}\n  ${describeListed(review)}\n  ${review.url}`).join("\n\n");
+}
+/**
+* Answered in the order the questions get asked, which is the order the browser's card answers
+* them in: where is it, what was it compared against, how big, how long ago, and which analysis of
+* it this is.
+*/
+function describeListed({ summary, position, total }) {
+	return [
+		basename(summary.repoPath),
+		...summary.baseRef ? [`against ${summary.baseRef}`] : [],
+		count(summary.changedFiles, "file"),
+		relativeTime(summary.createdAt),
+		...total > 1 ? [`review ${position} of ${total}`] : []
+	].join(", ");
+}
+/**
+* The index and the bookmark, in that order and both of them.
+*
+* The index is one page that stays correct for as long as the server runs. The bookmark is the
+* version of it that survives a restart, and it is rewritten every time the server starts or
+* stops, so it is right afterwards without anyone maintaining it. A person told only the index URL
+* learns the wrong thing to keep.
+*/
+function indexLinks(index, landingPage) {
+	if (!index) return "";
+	return [`All reviews: ${index}`, `Bookmark this instead, it survives a restart: file://${landingPage}`].join("\n");
+}
+function noSuchReview(id) {
+	return `There is no review called ${id}. Run \`prreviewbuddy open\` to see the ones there are.`;
+}
+function nothingToUpdate(repoPath) {
+	return `No review of ${repoPath} to bring up to date. Run \`prreviewbuddy review\` to make one.`;
+}
+/**
+* The update's own sentence, which the harness already wrote for the workspace strip, plus the
+* link. Not rephrased here: an update that stopped early has a specific reason and the reviewer
+* gets the same reason whichever surface asked for it.
+*/
+function updateFinished(outcome, url) {
+	return `${outcome.message}\n${url}`;
+}
+function count(value, noun) {
+	return `${value} ${noun}${value === 1 ? "" : "s"}`;
+}
+//#endregion
+//#region src/write.ts
+/**
+* Where the two kinds of output go, decided once.
+*
+* Links and results to stdout, everything else to stderr, so `prreviewbuddy review | pbcopy`
+* copies a URL and progress still reaches the terminal it was meant for.
+*/
+function out(text) {
+	process.stdout.write(`${text}\n`);
+}
+function err(text) {
+	process.stderr.write(`${text}\n`);
+}
+//#endregion
+//#region src/commands/review.ts
+/**
+* `prreviewbuddy review`.
+*
+* The same four calls `prb_review` makes, in the same order and through the same functions:
+* resolve the target, check whether a review of it already exists, mint the job, start the
+* workspace server. That is what makes this a second surface on one engine rather than a second
+* implementation of the review workflow.
+*
+* One thing differs, and it is a property of the surface rather than of the review. An MCP tool
+* returns to a session that must not sit and wait, so it fires `runJob` and returns the link at
+* once. A person who typed a command is already waiting, so this awaits the job and reports what
+* it is doing. Either way the job is durable and either way the link works from the moment it is
+* printed, so a terminal closed halfway through loses nothing.
+*/
+async function review(command, repoPath) {
+	let agent;
+	try {
+		agent = command.agentId ? agentById(command.agentId) : defaultAgent();
+	} catch (error) {
+		if (!(error instanceof AgentUnavailableError)) throw error;
+		err(unknownAgent(command.agentId, AGENT_IDS));
+		return 1;
+	}
+	const availability = await agent.available(agent.captureEnv());
+	if (!availability.ok) {
+		err(agentMissing(availability.reason));
+		return 1;
+	}
+	const target = withBase(await resolveTarget({
+		repoPath,
+		argument: command.argument,
+		resolveRequest: forgeResolver
+	}), command.base);
+	if (!command.fresh) {
+		const existing = await findExistingReview(target);
+		if (existing) {
+			const port = await ensureServer();
+			const url = workspaceUrl(port, existing.id, existing.token);
+			const failed = failureOf(existing.id);
+			if (!failed) {
+				out(existingReview(existing, url));
+				return 0;
+			}
+			err(resumingReview(failed));
+			return drive(existing.id, url);
+		}
+	}
+	const workspaceId = await startJob({
+		target,
+		...command.agentId ? { agentId: command.agentId } : {}
+	});
+	const port = await ensureServer();
+	const workspace = loadWorkspace(workspaceId);
+	const url = workspaceUrl(port, workspaceId, workspace.token);
+	out(startedReview(url, target));
+	return drive(workspaceId, url);
+}
+/**
+* Why this review's job stopped, if it stopped badly. Null for a review that finished, and for one
+* still being made.
+*
+* A job can read as failed and still be driven: the sweep calls a job stopped after half an hour
+* without a write, and an analysis that streams nothing is silent while entirely alive. Resuming
+* that one would start a second driver against the worktree the first is still standing in, so the
+* claim is asked as well as the phase. `runJob` would refuse anyway, but by then this command has
+* printed that it is picking the review up, and would report the refusal as a failed review.
+*/
+function failureOf(workspaceId) {
+	const workspace = loadWorkspace(workspaceId);
+	if (!workspace?.jobId) return null;
+	const job = loadJob(workspace.jobId);
+	if (!job || !isTerminal(job) || job.phase !== "failed") return null;
+	if (isClaimed(job.id)) return null;
+	return job.failure?.message ?? "The reason was not recorded.";
+}
+/**
+* Run the job to its end, saying what it is doing while it does it.
+*
+* The one place a review is awaited, whether it was just minted or is being resumed, so the two
+* cannot drift into reporting the same outcome differently.
+*/
+async function drive(workspaceId, url) {
+	const workspace = loadWorkspace(workspaceId);
+	const job = loadJob(workspace.jobId);
+	const stop = followJob(workspace.jobId, job?.target ?? {
+		branch: "",
+		sha: "",
+		originRepoPath: ""
+	});
+	let finished;
+	try {
+		finished = await runJob(workspaceId);
+		if (finished.phase === "failed") {
+			err(reviewFailed(finished.failure?.message ?? "The reason was not recorded.", await linkNow(workspace, url)));
+			return 1;
+		}
+	} catch (error) {
+		err(reviewFailed(error instanceof Error ? error.message : String(error), await linkNow(workspace, url)));
+		return 1;
+	} finally {
+		stop();
+	}
+	out(reviewFinished(await linkNow(workspace, url), summarise(loadWorkspace(workspaceId)), finished.conversation));
+	return 0;
+}
+/**
+* The link to this workspace as it is now, rather than as it was when the review started.
+*
+* The port is the one part of that link which is not durable. A review takes minutes, one server
+* serves every review, and every workspace page carries "Stop server", so the server this command
+* printed a link to at the start can be a different server by the time it finishes. Found doing
+* exactly that: a nine minute review ended on a connection-refused link while the review itself sat
+* healthy on the port that had replaced it.
+*
+* `ensureServer` starts one if none is running, which is what makes this the right call to make at
+* the end rather than a check: the reviewer is being handed somewhere to go.
+*
+* Falls back to the opening link rather than failing. A link that might be stale is worth more than
+* no link at all beside a result that has just been produced and cannot otherwise be reached.
+*/
+async function linkNow(workspace, fallback) {
+	try {
+		return workspaceUrl(await ensureServer(), workspace.id, workspace.token);
+	} catch {
+		return fallback;
+	}
+}
+//#endregion
+//#region src/browser.ts
+/**
+* Opening a URL, which is what `open` promises and what a person typing it expects.
+*
+* Best effort on purpose. The URL is printed before this is called, so a machine with no browser,
+* a container, or an SSH session all still get the working link; a failure here is worth nothing
+* more than silence. Nothing is read back from the process and nothing waits for it.
+*/
+var LAUNCHERS = {
+	darwin: {
+		command: "open",
+		args: []
+	},
+	win32: {
+		command: "cmd",
+		args: [
+			"/c",
+			"start",
+			""
+		]
+	}
+};
+function launchBrowser(url) {
+	const launcher = LAUNCHERS[platform] ?? {
+		command: "xdg-open",
+		args: []
+	};
+	try {
+		const child = spawn(launcher.command, [...launcher.args, url], {
+			stdio: "ignore",
+			detached: true
+		});
+		child.on("error", () => {});
+		child.unref();
+	} catch {}
+}
+//#endregion
+//#region src/commands/open.ts
+/**
+* `prreviewbuddy open`.
+*
+* With an id, one review. Without, the index, which is the page worth having: it lists every
+* stored review with a working link into each and stays correct for as long as the server runs.
+*
+* Starting the server is the point of this command as much as opening anything is. A workspace URL
+* carries a port, the server takes a new one every time it starts, and stopping it leaves every
+* review intact on disk with every bookmark to it dead. This is how a review is got back.
+*/
+async function open(command) {
+	const port = await ensureServer();
+	if (command.id) {
+		const workspace = loadWorkspace(command.id);
+		if (!workspace) {
+			err(noSuchReview(command.id));
+			return 1;
+		}
+		const url = workspaceUrl(port, workspace.id, workspace.token);
+		out(url);
+		launchBrowser(url);
+		return 0;
+	}
+	const index = reviewsUrl(port, readServerRecord()?.token);
+	const all = recentWorkspaces(Number.MAX_SAFE_INTEGER);
+	const links = indexLinks(index, LANDING_PAGE);
+	if (links) out(links);
+	err(all.length === 0 ? noReviews() : reviewList(listed(port, all)));
+	if (index) launchBrowser(index);
+	return 0;
+}
+/**
+* How many rows a terminal gets. The browser index takes the whole store and gives it a search
+* box; a list printed into a scrollback wants to end.
+*/
+var LISTED = 10;
+function listed(port, all) {
+	return all.slice(0, LISTED).map((summary) => ({
+		summary,
+		url: workspaceUrl(port, summary.id, summary.token),
+		...positionInLineage(summary, [...all])
+	}));
+}
+//#endregion
+//#region src/commands/update.ts
+/**
+* `prreviewbuddy update`.
+*
+* The same call the workspace's Update review button makes, through the same function, with the
+* same saving afterwards. `updateReview` computes and mutates in memory and leaves persistence to
+* its caller, which is what lets the whole path be driven in a test without writing into anyone's
+* store, so the two lines after it here are the whole difference between this and the HTTP route.
+*
+* Without an id it updates the newest review of the repository you are standing in, which is the
+* one you meant. Picking the newest of all reviews everywhere would silently update somebody
+* else's branch from the wrong directory.
+*/
+async function update(command, repoPath) {
+	const workspace = command.id ? loadWorkspace(command.id) : newestOf(repoPath);
+	if (!workspace) {
+		err(command.id ? noSuchReview(command.id) : nothingToUpdate(repoPath));
+		return 1;
+	}
+	const outcome = await updateReview(workspace);
+	workspace.lastUpdate = outcome;
+	saveWorkspace(workspace);
+	record({
+		event: "review_updated",
+		reviewId: workspace.id,
+		ok: outcome.ok,
+		stop: outcome.stop,
+		moved: outcome.moved,
+		resolved: outcome.counts?.resolved ?? 0,
+		stillOpen: outcome.counts?.stillOpen ?? 0,
+		affected: outcome.counts?.affected ?? 0,
+		newIssues: outcome.counts?.newIssues ?? 0,
+		questionsAnswered: outcome.counts?.questionsAnswered ?? 0
+	});
+	const port = await ensureServer();
+	out(updateFinished(outcome, workspaceUrl(port, workspace.id, workspace.token)));
+	return 0;
+}
+function newestOf(repoPath) {
+	const mine = recentWorkspaces(Number.MAX_SAFE_INTEGER).find((summary) => summary.repoPath === repoPath);
+	return mine ? loadWorkspace(mine.id) : null;
+}
+//#endregion
+//#region src/main.ts
+/**
+* PR Review Buddy at the command line.
+*
+* One of two surfaces over the same engine. Everything below the three commands here is the
+* harness, in process rather than shelled out to, which is the arrangement that makes this a
+* caller of the review workflow rather than a second copy of it.
+*
+* No account, no API key and no configuration, which is a product decision the code has to keep:
+* the analysis runs through the agent the developer has already installed and signed in to, and
+* authentication stays between them and whoever makes it. There is nowhere in this binary to put
+* a credential and nothing in it that asks for one.
+*/
+async function main(argv) {
+	const command = parse(argv);
+	switch (command.name) {
+		case "help":
+			out(HELP);
+			return 0;
+		case "version":
+			out(BUILD_VERSION);
+			return 0;
+		case "error":
+			err(command.message);
+			return 1;
+		case "review": return review(command, process.cwd());
+		case "open": return open(command);
+		case "update": return update(command, process.cwd());
+	}
+}
+process.exitCode = await main(process.argv.slice(2)).catch((error) => {
+	err(error instanceof Error ? error.message : String(error));
+	return 1;
+});
+//#endregion
+export {};