@pmelab/gtd 58.1.0 → 59.0.0

package/dist/chunks/review-Bfaror38.mjs

@@ -1,427 +0,0 @@
-import { answered, changesSince, head, judge, numeric, read, refuse, requireRevert, restoreScript, run, vars, writeScript } from "../flows.mjs";
-import { S as reviewSections, _ as REVIEW_SECTIONS, v as reviewChunks, x as reviewRisks } from "./steering-CCNvngSH.mjs";
-import { review } from "../workflow-kit.mjs";
-import { $ as nitFixBlock, A as reviewing, At as parseStandards, C as fixCheck, Dt as conflictTitle, E as fixRisks, Et as conflictFor, Mt as standardKey, N as buildReviewTriageMessage, O as reviewMissing, Ot as isConflictTitle, S as collecting, Tt as conflictBody, b as awaitReview, bt as withSummary, ct as reviewEditNotesCapture, d as healthy, ft as reviewNotesCapture, jt as renderStandards, kt as oneLine, lt as reviewEditsCapture, u as guarded, v as REVIEW, w as fixNits, wt as STANDARDS, y as answerReviewQuestions } from "./reserved-lMYCaapY.mjs";
-import { i as isOptionalObject, n as closeReview, o as tail, s as NO_FINDINGS } from "./tail-Bd7L940p.mjs";
-//#region src/workflows/shared/learn.ts
-const SUMMARY_MAX = 200;
-const summary = (body) => {
-	const text = oneLine(body);
-	return text.length > SUMMARY_MAX ? `${text.slice(0, SUMMARY_MAX - 1)}…` : text;
-};
-/** The standard a won't-fix or an own answer would make; a fix states none. */
-const candidateOf = (d) => {
-	const anchor = oneLine(d.anchor);
-	if (d.choice === "wontfix") {
-		const why = summary(d.body);
-		return [{
-			decision: d,
-			text: `Won't fix: ${anchor}${why === "" ? "" : ` — ${why}`}`
-		}];
-	}
-	if (d.choice === "answer") return [{
-		decision: d,
-		text: `${oneLine(d.text)} (re: ${anchor})`
-	}];
-	return [];
-};
-const without = (list, drop) => {
-	const keys = new Set(drop.map(standardKey));
-	return list.filter((s) => !keys.has(standardKey(s)));
-};
-const adding = (list, text) => list.some((s) => standardKey(s) === standardKey(text)) ? [...list] : [...list, text];
-/**
-* Keep the new one, keep the old one, or replace both with the human's own
-* wording. Another open conflict stops naming a replaced standard: the human
-* never judged it against the replacement, so keeping it must not drop that.
-*/
-const resolve = (standards, d) => {
-	const c = conflictFor(standards, d.anchor);
-	if (c === void 0) return standards;
-	const others = standards.undecided.filter((u) => u !== c);
-	if (d.choice === "wontfix") return {
-		decided: standards.decided,
-		undecided: others
-	};
-	const kept = d.choice === "fix" ? c.text : oneLine(d.text);
-	const undecided = others.map((u) => ({
-		text: u.text,
-		olds: without(u.olds, c.olds)
-	}));
-	return {
-		decided: adding(without(standards.decided, c.olds), kept),
-		undecided
-	};
-};
-const contradicts = (i, id, other) => ({
-	id: `standard-${i}.contradicts-${id}`,
-	primitive: "noul",
-	instructions: `Does the "Standard:" line of evidence "standard-${i}" contradict ${other}?`,
-	criteria: "yes: following one breaks the other. no: both can be followed — they are compatible or unrelated."
-});
-const questionsFor = (i, anchor, decided) => [
-	{
-		id: `standard-${i}`,
-		primitive: "noul",
-		instructions: `Is the human's answer to review note "${anchor}" (evidence "standard-${i}") a reusable standard for this codebase — a rule later changes and reviews should follow — rather than a call about this one note? Its "Standard:" line is the wording gtd would keep.`,
-		criteria: "yes: it states a rule or preference that applies beyond this note. no: it is specific to this note, a one-off call, or unclear."
-	},
-	...decided.map((_, k) => contradicts(i, `${k + 1}`, `kept standard ${k + 1} (evidence "kept-${k + 1}")`)),
-	...Array.from({ length: i - 1 }, (_, j) => contradicts(i, `new-${j + 1}`, `the "Standard:" line of evidence "standard-${j + 1}"`))
-];
-const evidenceOf = (c) => [
-	`Note: ${c.decision.anchor}`,
-	`Reviewer's text: ${c.decision.body}`,
-	`Human's answer: ${c.decision.choice === "wontfix" ? "won't fix" : c.decision.text}`,
-	`Standard: ${c.text}`
-].join("\n");
-/**
-* One judge rest over every candidate. Only a confident `yes` on uncut
-* evidence makes a standard; a contradiction the judge does not confidently
-* rule out goes to the human instead of overwriting what they decided before.
-* A cut kept standard leaves the round unlearned: raise `judgeBudgetBytes`.
-*/
-const judged = async (candidates, decided, minP) => {
-	const { answers, truncated } = await judge("review.standards.judge", {
-		questions: candidates.flatMap((c, i) => questionsFor(i + 1, c.decision.anchor, decided)),
-		evidence: Object.fromEntries([...candidates.map((c, i) => [`standard-${i + 1}`, evidenceOf(c)]), ...decided.map((s, k) => [`kept-${k + 1}`, s])]),
-		message: "Judging whether your answers are standards to keep: run `gtd judge run`, or land without a verdict, which keeps none.",
-		label: "Learning your standards"
-	});
-	const ruledOut = (i, id) => answered(answers[`standard-${i}.contradicts-${id}`], "no", minP);
-	const added = [];
-	const raised = [];
-	candidates.forEach((c, n) => {
-		const i = n + 1;
-		if (truncated.includes(`standard-${i}`)) return;
-		if (decided.some((_, k) => truncated.includes(`kept-${k + 1}`))) return;
-		if (!answered(answers[`standard-${i}`], "yes", minP)) return;
-		const olds = [...decided.filter((_, k) => !ruledOut(i, `${k + 1}`)), ...added.filter((a) => !ruledOut(i, `new-${a.i}`)).map((a) => a.text)];
-		if (olds.length === 0) added.push({
-			i,
-			text: c.text
-		});
-		else raised.push({
-			text: c.text,
-			olds
-		});
-	});
-	return {
-		added: added.map((a) => a.text),
-		raised
-	};
-};
-/**
-* Settles every answer to a standard conflict, then learns standards from
-* the won't-fix ticks and own answers: kept in `.gtd/STANDARDS.md`, a
-* contradicting one as a new conflict note in `.gtd/REVIEW.md`.
-*/
-const learnStandards = async (decisions) => {
-	const before = parseStandards(read(".gtd/STANDARDS.md") ?? "");
-	const rest = decisions.filter((d) => !isConflictTitle(d.anchor));
-	const settled = decisions.filter((d) => isConflictTitle(d.anchor)).reduce(resolve, before);
-	const known = new Set([...settled.decided, ...settled.undecided.map((c) => c.text)].map(standardKey));
-	const candidates = rest.flatMap(candidateOf).filter((c) => {
-		const key = standardKey(c.text);
-		if (known.has(key)) return false;
-		known.add(key);
-		return true;
-	});
-	const minP = numeric(vars.standardMinP, Infinity);
-	const { added, raised } = candidates.length === 0 || !Number.isFinite(minP) ? {
-		added: [],
-		raised: []
-	} : await judged(candidates, settled.decided, minP);
-	const after = {
-		decided: [...settled.decided, ...added],
-		undecided: [...settled.undecided, ...raised]
-	};
-	if (renderStandards(after) !== renderStandards(before)) await run("review.standards.recording", writeScript(STANDARDS, renderStandards(after)), { label: "Recording your standards" });
-	if (raised.length > 0) {
-		const chunks = raised.map((c) => `## ${conflictTitle(c)}\n\n${conflictBody(c)}`);
-		await run("review.standards.raising", writeScript(REVIEW, `${(read(".gtd/REVIEW.md") ?? "").trimEnd()}\n\n${chunks.join("\n\n")}\n`), {
-			label: "Asking about a contradicting standard",
-			file: REVIEW
-		});
-	}
-};
-const settlesStandard = (d) => isConflictTitle(d.anchor);
-const standardsPending = () => parseStandards(read(".gtd/STANDARDS.md") ?? "").undecided.length > 0;
-const standardsAddedSince = (base) => {
-	const change = changesSince(base).get(STANDARDS);
-	if (change === void 0) return [];
-	const was = new Set(parseStandards(change.before ?? "").decided);
-	return parseStandards(change.after ?? "").decided.filter((s) => !was.has(s));
-};
-//#endregion
-//#region src/workflows/shared/review.ts
-const VERDICTS = [
-	"edit",
-	"question",
-	"nit",
-	"praise"
-];
-/** One four-way choice per note the human added to `.gtd/REVIEW.md`. */
-const verdictQuestion = (note) => ({
-	id: note.id,
-	primitive: "choice",
-	instructions: `Classify the human's note on review item "${note.anchor}" (in .gtd/REVIEW.md). Its evidence holds the anchor, the reviewer's text and the human's text.`,
-	criteria: "edit: a request to change behaviour, design or scope — anything needing a plan, or any note you are unsure about. question: asks something and wants an answer, with no change requested. nit: a small, local, unambiguous fix (naming, typo, formatting, comment wording) needing no re-plan. praise: an approving remark with nothing to do."
-});
-const TIER_ORDER = {
-	critical: 0,
-	should: 1,
-	could: 2
-};
-/** Capture order: critical, should, could; within a tier one-way doors, then new concepts. */
-const captureKey = (s) => s === void 0 ? 2 : TIER_ORDER[s.tier] * 3 + s.rank;
-const SEVERITY_ANSWERS = {
-	security: ["yes", "no"],
-	reversibility: ["one-way", "two-way"],
-	blastRadius: [
-		"local",
-		"module",
-		"contract"
-	],
-	newConcept: ["yes", "no"]
-};
-/** Anything unanswered, unrecognised, cut or below `minP` is `critical`, never `could`. */
-const severityOf = (note, judgment, minP) => {
-	const ans = (q) => judgment.answers[`${note.id}.${q}`];
-	const a = (q) => ans(q)?.answer;
-	const rank = () => a("reversibility") === "one-way" ? 0 : a("newConcept") === "yes" ? 1 : 2;
-	if (note.forced) return {
-		tier: "critical",
-		reason: "critical: forced by `!`",
-		rank: 2
-	};
-	if (judgment.truncated.includes(note.id) || Object.entries(SEVERITY_ANSWERS).some(([q, allowed]) => !allowed.includes(a(q) ?? "") || !((ans(q)?.p ?? NaN) >= minP))) return {
-		tier: "critical",
-		reason: "critical: judge unsure",
-		rank: 2
-	};
-	const critical = [...a("security") === "yes" ? ["security"] : [], ...a("reversibility") === "one-way" ? ["one-way door"] : []];
-	if (critical.length > 0) return {
-		tier: "critical",
-		reason: `critical: ${critical.join(", ")}`,
-		rank: rank(),
-		...a("security") === "yes" ? { security: true } : {}
-	};
-	const should = [...a("blastRadius") === "contract" ? ["contract"] : [], ...a("newConcept") === "yes" ? ["new concept"] : []];
-	if (should.length > 0) return {
-		tier: "should",
-		reason: `should: ${should.join(", ")}`,
-		rank: rank()
-	};
-	return {
-		tier: "could",
-		reason: "could",
-		rank: 2
-	};
-};
-/** `asks` names the change in full, `change` refers back to it. */
-const severityQuestions = (id, asks, change) => [
-	{
-		id: `${id}.security`,
-		primitive: "noul",
-		instructions: `Does ${asks} touch security — authentication, authorisation, secrets, untrusted input or data exposure?`,
-		criteria: "yes: it changes or could weaken a security property. no: it does not."
-	},
-	{
-		id: `${id}.reversibility`,
-		primitive: "choice",
-		instructions: `Once ${change} ships, can it be undone without breaking anyone who already depends on it?`,
-		criteria: "one-way: a published API, file format, persisted data, protocol or other contract that cannot be taken back. two-way: can be reverted freely."
-	},
-	{
-		id: `${id}.blastRadius`,
-		primitive: "choice",
-		instructions: `How far does ${change} reach?`,
-		criteria: "local: one function or file. module: a whole module or several files. contract: a public interface other code or users depend on."
-	},
-	{
-		id: `${id}.newConcept`,
-		primitive: "noul",
-		instructions: `Does ${change} introduce a concept new to this codebase — a new abstraction, entity or term? Judge from the evidence, never a glossary; reusing or extending an existing concept is not new.`,
-		criteria: "yes: a genuinely new concept. no: reuses or extends an existing one."
-	}
-];
-/**
-* One judge rest: a verdict per unforced note (a forced note is asked
-* nothing) plus four severity answers. Dismissing a note is the risky
-* direction, so only a confident non-`edit` verdict on uncut evidence counts;
-* a cut, unanswered or below-floor note is an `edit`. Severity answers on a
-* non-`edit` note are ignored; on an `edit` they order the collecting turn.
-*/
-const triage = (severities) => async (notes) => {
-	const asked = notes.filter((n) => !n.forced);
-	const judgment = asked.length === 0 ? {
-		answers: {},
-		truncated: []
-	} : await judge("review.triage", {
-		questions: asked.flatMap((n) => [verdictQuestion(n), ...severityQuestions(n.id, `the change the human asks for in note "${n.id}" (on "${n.anchor}")`, `the change in note "${n.id}"`)]),
-		evidence: Object.fromEntries(asked.map((n) => [n.id, `Anchor: ${n.anchor}\nReviewer's text: ${n.before}\nHuman's text: ${n.text}`])),
-		message: buildReviewTriageMessage(),
-		label: "Judging each note"
-	});
-	const { answers, truncated } = judgment;
-	const minP = numeric(vars.reviewNoteActionable, Infinity);
-	const severityMinP = numeric(vars.reviewSeverityMinP, Infinity);
-	severities.clear();
-	return new Map(notes.map((n) => {
-		const verdict = n.forced ? void 0 : VERDICTS.find((v) => v !== "edit" && answered(answers[n.id], v, minP));
-		if (verdict !== void 0 && !truncated.includes(n.id)) return [n.id, verdict];
-		severities.set(n.id, severityOf(n, judgment, severityMinP));
-		return [n.id, "edit"];
-	}));
-};
-const isCode = (path) => path !== ".gtd" && !path.startsWith(".gtd/");
-/** Refuses a review with a chunk pointing at no code; a range with no code change has nothing to point at. */
-const requirePointers = (review, codeChanged) => {
-	const chunks = reviewChunks(review);
-	const problems = [
-		...chunks.filter((c) => c.pointers === 0 && codeChanged).map((c) => `  - ${REVIEW}:${c.line + 1}: ${c.title} — points at no code`),
-		...chunks.filter((c) => isConflictTitle(c.title)).map((c) => `  - ${REVIEW}:${c.line + 1}: ${c.title} — gtd writes conflicts; leave it out`),
-		...chunks.filter((c, i) => chunks.findIndex((d) => d.title === c.title) !== i).map((c) => `  - ${REVIEW}:${c.line + 1}: ${c.title} — a second chunk with this title`),
-		...reviewSections(review).map((s) => `  - ${REVIEW}:${s.line + 1}: ${REVIEW_SECTIONS[s.section]} — write \`## \` chunks only`)
-	];
-	if (problems.length === 0) return;
-	refuse(`gtd land: review-pointers: ${problems.length} problem(s) in ${REVIEW} — every chunk needs a pointer to its code:\n${problems.join("\n")}`);
-};
-/**
-* A reviewer walks the human through everything since `base`, every chunk
-* pointing at its code; gtd then appends the summary chunks.
-*/
-const walkthrough = async (base, summary, lap, carry, nitFix, afterRiskFix) => {
-	await reviewing(base, carry, lap, nitFixBlock(nitFix));
-	const written = read(REVIEW);
-	if (written === void 0) return;
-	requirePointers(written, changesSince(base).some((c) => isCode(c.path)));
-	if (!afterRiskFix && reviewRisks(written).length > 0) return;
-	const full = withSummary(written, summary);
-	if (full !== written) await run("review.carrying", writeScript(REVIEW, full), {
-		label: "Adding the quality lap's summary",
-		file: REVIEW,
-		base
-	});
-};
-/**
-* A reviewer's walkthrough of everything since `base` reaches a human, who
-* may comment: each note is judged — edits end the review as `feedback` for
-* the caller to build, questions are answered in place, nits fixed in one
-* batch, praise dropped.
-*/
-const humanReview = (base, escalations = { rounds: 0 }, options = {}) => {
-	const { guard, guardRests, fixAccess, rules } = options;
-	const feedback = options.feedback ?? {
-		file: ".gtd/REQUIREMENTS.md",
-		collecting,
-		unmatched: "gtd land: no declared pattern matches the pending changes — write .gtd/REQUIREMENTS.md from the feedback, or change nothing when it asks for nothing"
-	};
-	const severities = /* @__PURE__ */ new Map();
-	let nitFix;
-	let riskFixed = false;
-	return review(base, {
-		file: REVIEW,
-		feedback: feedback.file,
-		isCode,
-		reviewing: (b, carry) => {
-			const fixedAt = nitFix;
-			const afterRiskFix = riskFixed;
-			riskFixed = false;
-			const summary = {
-				report: options.report ?? NO_FINDINGS,
-				standards: {
-					added: standardsAddedSince(b),
-					undecided: parseStandards(read(".gtd/STANDARDS.md") ?? "").undecided
-				}
-			};
-			return guarded(() => walkthrough(b, summary, options.lap ?? "first", carry, fixedAt, afterRiskFix), guard)();
-		},
-		fixRisks: guarded((notes) => {
-			riskFixed = true;
-			return fixRisks(notes, fixAccess, rules);
-		}, guard),
-		keepGreen: () => healthy(() => fixCheck(rules), {
-			escalations,
-			guard,
-			guardRests,
-			rules
-		}),
-		awaitReview: (b) => {
-			nitFix = void 0;
-			return awaitReview(b);
-		},
-		reviewMissing,
-		collecting: feedback.collecting,
-		triage: triage(severities),
-		settles: settlesStandard,
-		learn: learnStandards,
-		pending: standardsPending,
-		answerQuestions: answerReviewQuestions,
-		fixNits: async (notes) => {
-			await guarded((n) => fixNits(n, fixAccess, rules), guard)(notes);
-			nitFix = head();
-		},
-		close: closeReview,
-		captures: {
-			edits: reviewEditsCapture,
-			notes: reviewNotesCapture,
-			editNotes: (round, edits, answeredAt) => reviewEditNotesCapture(round, edits.map((n, i) => ({
-				n,
-				i,
-				s: severities.get(n.id),
-				key: captureKey(severities.get(n.id))
-			})).sort((x, y) => x.key - y.key || x.i - y.i).map(({ n, s }) => ({
-				id: n.id,
-				anchor: n.anchor,
-				text: n.forced ? n.text.replace(/^!\s*/, "") : n.text,
-				...s === void 0 ? {} : { label: s.reason }
-			})), answeredAt)
-		},
-		refusals: {
-			deleted: "gtd land: review-doc: .gtd/REVIEW.md was deleted — restore it, or leave a note (or edit code) to request changes.",
-			unmatched: feedback.unmatched,
-			...feedback.dropped === void 0 ? {} : { dropped: feedback.dropped }
-		}
-	});
-};
-function buildTail(first, second, ...rest) {
-	const options = callForm(first, second, rest);
-	if (options === void 0) return Promise.reject(/* @__PURE__ */ new Error("buildTail takes buildTail(base, options?) or the deprecated buildTail(fixFirst, base, green?, options?); this call fits neither"));
-	const [base, form] = options;
-	return tail((escalations, report) => humanReview(base, escalations, {
-		...form,
-		report
-	}), form);
-}
-const isOptionalBoolean = (value) => value == null || typeof value === "boolean";
-const legacyForm = (fixFirst, base, green, options) => isOptionalBoolean(fixFirst) && isOptionalBoolean(green) && isOptionalObject(options) ? [base, {
-	...options,
-	fixFirst: fixFirst ?? void 0,
-	green: green ?? void 0
-}] : void 0;
-const currentForm = (base, options, third, fourth) => isOptionalObject(options) && third == null && fourth == null ? [base, options ?? {}] : void 0;
-const callForm = (first, second, [third, fourth, ...extra]) => {
-	if (extra.some((value) => value != null)) return void 0;
-	if (typeof second === "string") return legacyForm(first, second, third, fourth);
-	if (typeof first === "string") return currentForm(first, second, third, fourth);
-};
-/**
-* Undo the human's review-round code edits. A path changed since the human
-* left it is not overwritten; requireRevert names it instead.
-*/
-const reUnwind = async (feedback) => {
-	const { base, restoreFrom, edited } = feedback;
-	await run("re-unwind", restoreScript(base, {
-		restore: edited.filter((c) => c.status !== "added").map((c) => c.path),
-		remove: edited.filter((c) => c.status === "added").map((c) => c.path)
-	}, restoreFrom), {
-		label: "Re-unwinding your review edit",
-		file: REVIEW,
-		base
-	});
-	requireRevert(edited, base);
-};
-//#endregion
-export { isCode as n, reUnwind as r, buildTail as t };