prreviewbuddy 0.18.0 → 0.19.0

package/dist/main.js

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
-import { $ as agentIdOf, B as MANAGED_ROOT, C as LANDING_PAGE, Ct as agentById, D as updateReview, G as allJobs, H as removeWorktree, I as forgeResolver, J as loadJob, M as reanalyseReview, N as runJob, P as startJob, Q as git, R as clearClaim, St as AGENT_IDS, Tt as detectAgents, U as checkFreshness, V as readMarker, W as WORK_PHASES, X as resolveTarget, Z as displayRef, a as liveJobsFor, at as positionInLineage, bt as STORE_ROOT, dt as summarise, et as followedRefName, f as ensureServer, g as workspaceUrl, h as stopServer, it as loadWorkspace, l as record, lt as reviewedRepositories, m as reviewsUrl, nt as lineageKeyFor, o as runningJobs, p as readServerRecord, q as isTerminal, r as deleteReview$1, st as recentWorkspaces, t as relativeTime, tt as groupByLineage, u as bootstrapUrl, ut as saveWorkspace, v as BUILD_VERSION, y as PACKAGE_NAME, z as isClaimed } from "./relative_time-Ckbb4Srd.js";
+import { A as startJob, C as updateReview, Ct as git, Dt as STORE_ROOT, Et as writeConfigValues, F as BUILD_VERSION, G as readMarker, H as clearClaim, I as PACKAGE_NAME, J as WORK_PHASES, K as removeWorktree, M as record, N as recordTelemetryUploadConsent, O as reanalyseReview, Ot as AGENT_IDS, P as telemetryUploadConsent, Q as loadJob, St as displayRef, Tt as readConfigFile, U as isClaimed, W as MANAGED_ROOT, Y as allJobs, Z as isTerminal, a as liveJobsFor, at as positionInLineage, d as ensureServer, dt as summarise, et as followedRefName, f as readServerRecord, h as workspaceUrl, it as loadWorkspace, jt as detectAgents, k as runJob, kt as agentById, l as bootstrapUrl, lt as reviewedRepositories, m as stopServer, nt as lineageKeyFor, o as wasBlocked, p as reviewsUrl, q as checkFreshness, r as deleteReview$1, s as runningJobs, st as recentWorkspaces, t as relativeTime, tt as groupByLineage, ut as saveWorkspace, wt as agentIdOf, xt as resolveTarget, y as LANDING_PAGE, z as forgeResolver } from "./relative_time-BdTOYOad.js";
 import { basename, dirname, join, resolve } from "node:path";
 import { spawn } from "node:child_process";
-import { existsSync, mkdirSync, readFileSync, readdirSync, realpathSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, readdirSync, realpathSync, rmSync, statSync, writeFileSync } from "node:fs";
 import { hostname } from "node:os";
 import { createInterface } from "node:readline";
 import { platform } from "node:process";
@@ -250,18 +250,13 @@ function unknownCommand(head) {
 * No validation of the id here, deliberately. A person may configure an agent before installing it,
 * and this module has no business knowing which ids exist: the registry does, and the CLI edge is
 * where an unknown one is refused with a list of the real ones.
+*
+* The read-modify-write that keeps everybody else's keys used to live here. It is in
+* `config_file.ts` now, because being the only careful writer of a shared file is not a property
+* one module can hold.
 */
-var CONFIG_PATH = join(STORE_ROOT, "config.json");
 /** The key this module owns. Everything else in the file belongs to somebody else and is kept. */
 var KEY = "agent";
-function readConfig() {
-	try {
-		const parsed = JSON.parse(readFileSync(CONFIG_PATH, "utf8"));
-		return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
-	} catch {
-		return {};
-	}
-}
 /**
 * The configured default, or nothing.
 *
@@ -271,25 +266,11 @@ function readConfig() {
 * lie if this invented one.
 */
 function readAgentPreference() {
-	const value = readConfig()[KEY];
+	const value = readConfigFile()[KEY];
 	return typeof value === "string" && value !== "" ? value : null;
 }
-/**
-* Remember an agent, keeping every setting this module does not own.
-*
-* Read-modify-write rather than a bare write. `config.json` holds `editor` and whatever else the
-* reviewer has put there, and a preference that quietly dropped their editor while saving their
-* agent would be a worse bargain than not remembering anything.
-*/
 function writeAgentPreference(id) {
-	save({
-		...readConfig(),
-		[KEY]: id
-	});
-}
-function save(config) {
-	mkdirSync(STORE_ROOT, { recursive: true });
-	writeFileSync(CONFIG_PATH, `${JSON.stringify(config, null, 2)}\n`, { mode: 384 });
+	writeConfigValues({ [KEY]: id });
 }
 //#endregion
 //#region ../../packages/review-harness/src/agents/resolve.ts
@@ -665,6 +646,10 @@ your own checkout is never read or written while it works.
   prreviewbuddy agents <agent>            show details for ${AGENT_NAMES}
   prreviewbuddy config get agent          the coding agent used when you do not name one
   prreviewbuddy config set agent <agent>  remember ${AGENT_NAMES}
+  prreviewbuddy config get telemetry-upload
+                                          whether anonymous usage counts are sent
+  prreviewbuddy config set telemetry-upload on|off
+                                          send them, or stop
 
   prreviewbuddy uninstall                 remove everything this put on your machine
   prreviewbuddy uninstall --keep-reviews  keep your reviews and settings, clear the rest
@@ -773,6 +758,53 @@ function unknownSetting(key, known) {
 	return `There is no setting called \`${key}\`. This can read and set: ${known.join(", ")}.`;
 }
 /**
+* The first-run question about transmission, in three lines.
+*
+* Three because a first run is not the place for a privacy policy, and the policy is one line
+* away. What it names is what a person would otherwise have to assume: the list of things that are
+* never sent is longer than the list of things that are, and printing the longer one is the honest
+* way round.
+*/
+function telemetryUploadQuestion() {
+	return [
+		"",
+		"Help improve PR Review Buddy by sending anonymous usage counts?",
+		"Never your code, diffs, file paths, repository names, prompts or review content.",
+		"https://prreviewbuddy.com/privacy lists every field, exactly.",
+		""
+	].join("\n");
+}
+function telemetryUploadUnclear() {
+	return "Please answer y or n.\n";
+}
+function telemetryUploadGranted() {
+	return "Thank you. Turn it off whenever you like with `prreviewbuddy config set telemetry-upload off`.";
+}
+function telemetryUploadDeclined() {
+	return "Nothing will be sent. Turn it on with `prreviewbuddy config set telemetry-upload on`.";
+}
+/**
+* What `config get telemetry-upload` says, including for the machine that has not been asked.
+*
+* Three answers rather than two, because "off" and "never asked" are different facts and only one
+* of them is a decision somebody made.
+*/
+function telemetryUploadIs(consent) {
+	if (consent === null) return [
+		"Anonymous usage counts are not being sent, and nobody has been asked yet.",
+		"",
+		"The question is asked the first time you run PR Review Buddy in a terminal.",
+		"Answer it now with `prreviewbuddy config set telemetry-upload on` or `off`."
+	].join("\n");
+	return consent ? "Anonymous usage counts are being sent. Turn them off with `prreviewbuddy config set telemetry-upload off`." : "Anonymous usage counts are not being sent.";
+}
+function telemetryUploadSet(on) {
+	return on ? "Anonymous usage counts will be sent. Never your code, diffs, file paths, repository names, prompts or review content." : "Nothing will be sent. The usage log on this machine is unchanged; `PRB_TELEMETRY=off` turns that off too.";
+}
+function unknownSettingValue(key, value, known) {
+	return `\`${key}\` cannot be set to \`${value}\`. It takes: ${known.join(", ")}.`;
+}
+/**
 * What to say when `resolveAgent` could not resolve one.
 *
 * Each outcome gets its own sentence rather than a shared "could not choose an agent", because the
@@ -1087,6 +1119,17 @@ var DELETE_QUESTION = "Delete it?";
 function deleteUnattended(id) {
 	return `Deleting a review asks for confirmation, and there is nothing here to ask. Run \`prreviewbuddy review --review ${id} --delete --yes\` if you meant it.`;
 }
+/**
+* Something else held the review for the moment the deletion asked for it.
+*
+* Not `deleteRunning`, which names a branch and an analysis, because this is the case where there
+* is nothing to name: another surface deleting the same card, or a job being created in the same
+* instant. "Try again" is honest here and would not be there -- an analysis takes minutes and this
+* takes milliseconds.
+*/
+function deleteBusy() {
+	return "This review is being worked on right now, so nothing was deleted. Try again in a moment.";
+}
 function deleteCancelled() {
 	return "Nothing was deleted.";
 }
@@ -1234,7 +1277,12 @@ async function deleteReview(command, deps = REAL$1) {
 			return 1;
 		}
 	}
-	out(deleteFinished(await deps.remove(id)));
+	const report = await deps.remove(id);
+	if (wasBlocked(report)) {
+		err(report.live.length > 0 ? deleteRunning(report.live[0]?.job.target.branch ?? workspace.changeSet.headRef) : deleteBusy());
+		return 1;
+	}
+	out(deleteFinished(report));
 	return 0;
 }
 //#endregion
@@ -1328,6 +1376,7 @@ function phaseLines(job, colour) {
 	const lines = [];
 	const failedAt = job.phase === "failed" ? job.failure?.phase : void 0;
 	for (const phase of WORK_PHASES) {
+		if (!applies(job, phase)) continue;
 		const complete = job.completed.includes(phase) || job.phase === "done";
 		const failed = failedAt === phase;
 		const current = !complete && !failed && job.phase === phase;
@@ -1343,6 +1392,31 @@ function phaseLines(job, colour) {
 	}
 	return lines;
 }
+/**
+* Whether a phase is part of *this* review, rather than part of the pipeline in general.
+*
+* Only `conversation` is ever optional, and reviewing a branch with no pull request is an ordinary
+* supported thing to do rather than a degraded version of something else. Ticking "Read pull
+* request conversation" on such a review claims a step that did not happen and makes a complete
+* review look like an incomplete one; printing "No pull request found" instead is no better,
+* because a line in a checklist reads as something missing whatever words are in it.
+*
+* So the rule is that an optional stage which did not apply is not rendered at all:
+*
+* - A pull request review always shows it. It is the point of that review, and it is known before
+*   the phase runs, so the line never appears late.
+* - A branch review shows it only once a conversation was actually attached, which happens when the
+*   branch turns out to have a request on a forge we read. Real work, worth saying.
+* - Everything else — no request, an unsupported host, `gh` missing — shows nothing.
+*
+* The absent cases are still explained, once, at the end: the closing summary says the review was
+* made without the conversation and why. That is the right place for it, because by then it is a
+* fact about the finished review rather than a gap in a list of things still happening.
+*/
+function applies(job, phase) {
+	if (phase !== "conversation") return true;
+	return job.target.pullRequest !== void 0 || job.conversation?.kind === "attached";
+}
 /** 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, "");
@@ -1787,19 +1861,27 @@ async function agents(command) {
 //#endregion
 //#region src/commands/config.ts
 /**
-* `prreviewbuddy config get agent` and `config set agent <agent>`.
+* `prreviewbuddy config get <key>` and `config set <key> <value>`.
 *
-* One setting, which is the whole of it today. The command is general because the file is: reading
-* and writing one key by name is a shape that survives a second setting, and a `default-agent`
-* command would not.
+* Two settings now, which is what the shape was always for: reading and writing one key by name
+* survives a second setting, and a `default-agent` command would not have.
+*
+* The keys are hyphenated at the command line and camel-cased in `config.json`, and the difference
+* is deliberate rather than an oversight. `telemetryUpload` is the storage key and stays put; what
+* somebody types is `telemetry-upload`, because that is how every other flag on this binary reads.
 */
 /** The keys this command owns. Anything else is refused by name rather than silently stored. */
-var KEYS = ["agent"];
+var KEYS = ["agent", "telemetry-upload"];
+/** What the second one takes. A boolean setting, so a closed pair rather than anything truthy. */
+var SWITCH_VALUES = ["on", "off"];
 function config(command) {
 	if (!KEYS.includes(command.key)) {
 		err(unknownSetting(command.key, KEYS));
 		return 1;
 	}
+	return command.key === "agent" ? agent(command) : telemetryUpload(command);
+}
+function agent(command) {
 	if (command.action === "get") {
 		const preferred = readAgentPreference();
 		out(preferred ? agentPreferenceIs(preferred) : noAgentPreference());
@@ -1814,6 +1896,28 @@ function config(command) {
 	out(agentPreferenceSet(id));
 	return 0;
 }
+/**
+* The answer to the first-run question, readable and changeable afterwards.
+*
+* This is the only way to say yes without being asked, and the only way to change the answer
+* without editing a file by hand. Both directions matter: a person who declined at a prompt they
+* were half reading needs a way back, and a person who agreed needs one out.
+*/
+function telemetryUpload(command) {
+	if (command.action === "get") {
+		out(telemetryUploadIs(telemetryUploadConsent()));
+		return 0;
+	}
+	const value = command.value.toLowerCase();
+	if (!SWITCH_VALUES.includes(value)) {
+		err(unknownSettingValue("telemetry-upload", command.value, SWITCH_VALUES));
+		return 1;
+	}
+	const on = value === "on";
+	recordTelemetryUploadConsent(on);
+	out(telemetryUploadSet(on));
+	return 0;
+}
 //#endregion
 //#region ../../packages/review-harness/src/workspace/uninstall.ts
 /**
@@ -2008,10 +2112,12 @@ function isInside(path, root) {
 * round deletes somebody's data to satisfy a list written before the data existed.
 *
 * So what stays is everything else, and today that means their reviews (`workspaces`,
-* `reviews.html`), their settings (`config.json`, `prompts.json`) and the two records of having
-* been told something once (`onboarding-shown`, `telemetry-notice-shown`). Those last two are not
-* runtime state: it is the same person on the same machine, they have read both notices, and
-* showing either again would be this product forgetting a conversation rather than clearing one.
+* `reviews.html`), their settings (`config.json`, `prompts.json`) and the record of having been
+* greeted once (`onboarding-shown`). That last one is not runtime state: it is the same person on
+* the same machine, they have read the banner, and showing it again would be this product
+* forgetting a conversation rather than clearing one. The answer to the telemetry question is in
+* `config.json` with the rest of the settings, for the same reason and a stronger one: re-asking a
+* question somebody has already answered is worse than repeating a notice they have already read.
 * The usage log itself (`events.jsonl`) does go, because that is data about them rather than a note
 * to ourselves.
 */
@@ -2174,6 +2280,65 @@ function recordGreeting() {
 	} catch {}
 }
 //#endregion
+//#region src/telemetry_consent.ts
+/**
+* The one question this product asks about itself, asked once per machine.
+*
+* `packages/review-harness/src/telemetry/` has recorded usage events to a local file since it
+* existed, disclosed and on by default. Sending a subset of them to a server we run is a different
+* act, and `apps/website/src/pages/Privacy.tsx` promised in as many words that if it ever happened
+* it would be opt in and off by default. This is how that promise is kept.
+*
+* Hand-rolled on `node:readline` beside `select.ts` and `confirm.ts`, for the reason they both
+* give: this binary has no runtime dependencies and one question is not worth acquiring one. The io
+* is injected for the same reason theirs is, so what the answer means is testable without a shell.
+*
+* **A bare Return re-asks rather than declining.** `confirm.ts` next door defaults to no on Return,
+* which is right there because every one of its callers is about to delete something. Here it would
+* be wrong in a subtler way: "no default" was the decision, and a capitalised `N` in the brackets
+* turns it into opt-out-by-keystroke, which is a different thing wearing the same words. Somebody
+* who has not read the question has not answered it.
+*
+* **No terminal means no question and no answer.** A durable job, a CI run and a piped invocation
+* must not block on a question nobody can see, and must not be recorded as having declined one:
+* the setting stays unset, nothing is sent, and the same machine is asked properly the first time
+* a person runs this interactively.
+*/
+async function askTelemetryUpload(options) {
+	const stored = telemetryUploadConsent();
+	if (stored !== null) return { kind: stored ? "granted" : "declined" };
+	if (!options.isTTY) return { kind: "unanswered" };
+	const reader = createInterface({ input: options.input });
+	const lines = reader[Symbol.asyncIterator]();
+	try {
+		options.write(`${telemetryUploadQuestion()}\n`);
+		for (let attempt = 0; attempt < 3; attempt += 1) {
+			options.write("[y/n] ");
+			const next = await lines.next();
+			if (next.done) return { kind: "unanswered" };
+			const answer = next.value.trim().toLowerCase();
+			if (answer === "y" || answer === "yes") return settle(options, true);
+			if (answer === "n" || answer === "no") return settle(options, false);
+			options.write(telemetryUploadUnclear());
+		}
+		return { kind: "unanswered" };
+	} finally {
+		reader.close();
+	}
+}
+/**
+* Store the answer, and say what was stored.
+*
+* Said out loud in both directions, because a setting written to a file the person did not open is
+* a change they need to know how to undo, and because "yes" and "nothing happened" look identical
+* from a terminal otherwise.
+*/
+function settle(options, answer) {
+	recordTelemetryUploadConsent(answer);
+	options.write(`${answer ? telemetryUploadGranted() : telemetryUploadDeclined()}\n`);
+	return { kind: answer ? "granted" : "declined" };
+}
+//#endregion
 //#region src/main.ts
 /**
 * PR Review Buddy at the command line.
@@ -2206,9 +2371,33 @@ function greet(command) {
 	err(firstRun(BUILD_VERSION));
 	recordGreeting();
 }
+/**
+* The one question, asked after the hello and before the work.
+*
+* The greeting's commands minus `config`, which is where the answer is changed: somebody typing
+* `config set telemetry-upload off` is answering the question, and prompting them for it first
+* would be this binary interrupting the answer in order to ask.
+*
+* On stderr with its input from stdin, like every other question here, so a piped stdout still
+* carries only the result and a piped stdin is a run with nobody to ask.
+*/
+var ASKED = [
+	"review",
+	"open",
+	"agents"
+];
+async function ask(command) {
+	if (!ASKED.includes(command.name)) return;
+	await askTelemetryUpload({
+		isTTY: Boolean(process.stdin.isTTY && process.stderr.isTTY),
+		input: process.stdin,
+		write: (chunk) => void process.stderr.write(chunk)
+	});
+}
 async function main(argv) {
 	const command = parse(argv);
 	greet(command);
+	await ask(command);
 	switch (command.name) {
 		case "help":
 			out(HELP);