@joshuafolkken/kit 1.3101.0 → 1.3125.0

package/dist/commands/chunk-ILQU26IF.js

@@ -0,0 +1,408 @@
+import {
+  git_pr_checks_failed
+} from "./chunk-UOVUUVDK.js";
+import {
+  api_auth
+} from "./chunk-NUR4FQHM.js";
+import {
+  RERUNS_SPENT_MESSAGE
+} from "./chunk-4ODXKJJT.js";
+import {
+  review_record_cli
+} from "./chunk-2JGOKYJQ.js";
+import {
+  NO_CHECKS_MESSAGE,
+  PR_CHECKS_TIMEOUT_MESSAGE
+} from "./chunk-VJNE7W7O.js";
+import {
+  UNREADABLE_COMMENTS_STOP
+} from "./chunk-3PGB2RKZ.js";
+import {
+  review_finding_text
+} from "./chunk-5ZWU2B7T.js";
+import {
+  review_finding_ledger
+} from "./chunk-KVURNO74.js";
+import {
+  review_attest
+} from "./chunk-37RULO76.js";
+import {
+  review_prompt_level
+} from "./chunk-E33LSO2W.js";
+import {
+  git_error
+} from "./chunk-XMZJB7JP.js";
+import {
+  is_blocked_cause
+} from "./chunk-WVR4RUFP.js";
+import {
+  review_prior_findings
+} from "./chunk-VFW6XZH7.js";
+import {
+  run_ship_stage
+} from "./chunk-PUQA7F6Y.js";
+import {
+  issue_cite
+} from "./chunk-HQ2HSZBN.js";
+import {
+  gh_retry
+} from "./chunk-NAZ753DE.js";
+
+// scripts/run/ship/run-ship-review.ts
+var LINE_SEPARATOR = /\r?\n/u;
+var HIGH = "high";
+var MEDIUM = "medium";
+var FIXED_PREFIX = "fixed ";
+var KIND_FIELDS = 2;
+var VERDICT = {
+  CLEAN: "clean",
+  FIXED: "fixed",
+  BLOCKING: "blocking",
+  INVALID: "invalid"
+};
+var MISSING_NOTE = "the reviewer wrote no findings file \u2014 the review did not complete";
+var CLEAN_NOTE = "review clean or Low-only \u2014 recorded; shipping on.";
+var FIXED_NOTE = "review fixes applied in place \u2014 recorded; the gate re-runs on the fixed tree and round 2 follows the commit.";
+var SWEEP_INSTRUCTION = [
+  "Before fixing, sweep each finding for its other sites \u2014 the same file, the callers of the same",
+  "function and a grep of the pattern \u2014 fix every site in one pass, and list each range searched on its",
+  "own line in the Issue fix comment."
+].join(" ");
+var BLOCKING_NOTE = `review found High/Medium it did not fix \u2014 recorded. ${SWEEP_INSTRUCTION} Then take the round-2 route (\`chain-rule.md\`).`;
+var UNVERIFIED_OUTCOME = {
+  is_passing: false,
+  note: `review fixes did not pass the scoped checks \u2014 recorded as unfixed. ${SWEEP_INSTRUCTION} Then take the round-2 route (\`chain-rule.md\`).`
+};
+var OTHER_SITES_CLAUSE = '"other sites: <file>:<line>, \u2026" for each other site of the same pattern';
+var ROUND_TWO_CLEAN_NOTE = "round 2 clean or Low-only \u2014 recorded; shipping on.";
+var SUBMIT_COMMAND = "pnpm josh review:submit";
+var ROUND_TWO_BLOCKING_NOTE = `round 2 found High/Medium or edited the tree \u2014 recorded; round 2 is final. ${SWEEP_INSTRUCTION} Then push and gate it, and run followup (\`chain-rule.md\` step 4).`;
+function submit_command(slot) {
+  return slot === review_attest.REVIEW_SLOT.CODE ? SUBMIT_COMMAND : `${SUBMIT_COMMAND} --interaction`;
+}
+function sink_clauses(slot, findings_path) {
+  if (findings_path !== void 0) {
+    return [
+      `Then write every finding to ${findings_path},`,
+      "and an empty file when there is none."
+    ];
+  }
+  return [
+    `Then pipe every finding on stdin to \`${submit_command(slot)}\` \u2014 never write a findings file yourself \u2014`,
+    "or run it with `--none` and no stdin when there is none; if it refuses a line, fix that line and run it again."
+  ];
+}
+function findings_instruction(slot, fixed_clause, findings_path) {
+  const categories = review_finding_ledger.CATEGORIES.join(", ");
+  const [opening, closing] = sink_clauses(slot, findings_path);
+  return [
+    opening,
+    "one per line as",
+    `<category>:<severity>:<file>[:<line>]${review_finding_text.DESCRIPTION_SEPARATOR}<one sentence: what is wrong and why>`,
+    `(category one of ${categories}; severity high, medium or low)${fixed_clause},`,
+    `a high or medium line ending with ${OTHER_SITES_CLAUSE},`,
+    closing
+  ].join(" ");
+}
+function issue_read_instruction(issue) {
+  return [
+    `Read Issue ${issue_cite.plain_for("program", issue)} with \`pnpm josh issue:read ${issue}\`, which prints the body and every`,
+    `comment together \u2014 never a body-only \`gh api \u2026/issues/${issue}\` read.`
+  ].join(" ");
+}
+var IN_SESSION_CLAUSE = "Review it yourself in this session \u2014 you carry no Skill or Agent tool, so never launch a second reviewer.";
+function round_one_opening(brief_path) {
+  return [
+    `${review_prompt_level.opening(brief_path)}Review this checkout as a /code-review: read the review brief at ${brief_path} and follow it exactly \u2014`,
+    "the level on its first line, the rubric it names, the checkout it pins and its review:attest step.",
+    IN_SESSION_CLAUSE
+  ].join(" ");
+}
+function reviewer_prompt(brief_path, slot, issue, findings_path) {
+  return [
+    round_one_opening(brief_path),
+    issue_read_instruction(issue),
+    ...review_prior_findings.prompt_clauses(issue),
+    "Apply a fix only for a Medium finding whose fix is small and local \u2014 a one-function refactor, an",
+    "added test, an added guard; never fix a High or a change that reaches beyond one place, and never",
+    "commit, stage or push. After any fix, run `pnpm josh lint:related && pnpm josh test:related` and",
+    "return only once both are green; revert a fix you cannot get green and report that finding unfixed.",
+    findings_instruction(
+      slot,
+      `, prefixing a finding you fixed with "${FIXED_PREFIX}"`,
+      findings_path
+    )
+  ].join(" ");
+}
+function report_prompt(brief_path, slot, issue, findings_path) {
+  return [
+    round_one_opening(brief_path),
+    "Do not edit any file: the code review running beside this one fixes in this checkout.",
+    issue_read_instruction(issue),
+    ...review_prior_findings.prompt_clauses(issue),
+    findings_instruction(slot, "", findings_path)
+  ].join(" ");
+}
+function slot_prompt(round_prompt, slot, slots) {
+  if (slot === review_attest.REVIEW_SLOT.CODE || slots.length === 1) return round_prompt;
+  return report_prompt;
+}
+function final_opening(brief_path) {
+  return `${round_one_opening(brief_path)} This is the final round-2 verification pass; read the scope the brief names. Do not edit any file.`;
+}
+function verification_prompt(brief_path, slot, issue, findings_path) {
+  return [
+    final_opening(brief_path),
+    issue_read_instruction(issue),
+    ...review_prior_findings.prompt_clauses(issue),
+    findings_instruction(slot, "", findings_path)
+  ].join(" ");
+}
+function finding_of(line) {
+  const is_fixed = line.startsWith(FIXED_PREFIX);
+  const unmarked = is_fixed ? line.slice(FIXED_PREFIX.length) : line;
+  return { ...review_finding_text.split_description(unmarked), is_fixed, line };
+}
+function spec_findings(text) {
+  return text.split(LINE_SEPARATOR).map((line) => line.trim()).filter((line) => line.length > 0).map((line) => finding_of(line));
+}
+function is_recordable(finding) {
+  return review_record_cli.parse_finding(finding.spec) !== void 0;
+}
+function is_blocking(finding) {
+  const severity = review_record_cli.parse_finding(finding.spec)?.severity;
+  return severity === HIGH || severity === MEDIUM && !finding.is_fixed;
+}
+function kind_of(finding) {
+  return finding.spec.split(":", KIND_FIELDS).join(":");
+}
+function kinds_of(findings) {
+  return [...new Set(findings.map((finding) => kind_of(finding)))];
+}
+function stop_finding_of(finding) {
+  const location = review_record_cli.parse_finding(finding.spec)?.file ?? "";
+  return {
+    kind: kind_of(finding),
+    location,
+    sentence: review_finding_text.first_sentence(finding.description)
+  };
+}
+function deciding_findings(text) {
+  const findings = spec_findings(text).filter((finding) => is_recordable(finding));
+  const blocking = findings.filter((finding) => is_blocking(finding));
+  return blocking.length > 0 ? blocking : findings.filter((finding) => finding.is_fixed);
+}
+function blocking_kinds(text) {
+  return kinds_of(deciding_findings(text));
+}
+function blocking_details(text) {
+  return deciding_findings(text).map((finding) => stop_finding_of(finding));
+}
+function passing_fixes(verdict, outcome) {
+  if (!outcome.is_passing || verdict.kind !== VERDICT.FIXED) return [];
+  return blocking_details(verdict.report.join("\n"));
+}
+function scored_kind(findings) {
+  if (findings.some((finding) => is_blocking(finding))) return VERDICT.BLOCKING;
+  return findings.some((finding) => finding.is_fixed) ? VERDICT.FIXED : VERDICT.CLEAN;
+}
+function read_verdict(text) {
+  if (text === void 0) return { kind: VERDICT.INVALID, note: MISSING_NOTE };
+  const findings = spec_findings(text);
+  const invalid = findings.find((finding) => !is_recordable(finding));
+  if (invalid !== void 0) {
+    return { kind: VERDICT.INVALID, note: `unreadable finding: ${invalid.spec}` };
+  }
+  return {
+    kind: scored_kind(findings),
+    specs: findings.map(
+      (finding) => finding.is_fixed ? `${FIXED_PREFIX}${finding.spec}` : finding.spec
+    ),
+    report: findings.map((finding) => finding.line)
+  };
+}
+function recorded_specs(verdict, outcome) {
+  if (outcome.is_passing) return verdict.report;
+  return verdict.report.map(
+    (spec) => spec.startsWith(FIXED_PREFIX) ? spec.slice(FIXED_PREFIX.length) : spec
+  );
+}
+function round_one_outcome(verdict) {
+  if (verdict.kind === VERDICT.BLOCKING) return { is_passing: false, note: BLOCKING_NOTE };
+  return { is_passing: true, note: verdict.kind === VERDICT.FIXED ? FIXED_NOTE : CLEAN_NOTE };
+}
+function is_clean_round_one(text) {
+  return read_verdict(text).kind === VERDICT.CLEAN;
+}
+function has_fixes(text) {
+  if (text === void 0) return false;
+  return spec_findings(text).some((finding) => finding.is_fixed);
+}
+function round_two_outcome(verdict) {
+  const is_passing = verdict.kind === VERDICT.CLEAN;
+  return { is_passing, note: is_passing ? ROUND_TWO_CLEAN_NOTE : ROUND_TWO_BLOCKING_NOTE };
+}
+var run_ship_review = {
+  final_opening,
+  FIXED_PREFIX,
+  OTHER_SITES_CLAUSE,
+  SWEEP_INSTRUCTION,
+  UNVERIFIED_OUTCOME,
+  VERDICT,
+  blocking_details,
+  blocking_kinds,
+  has_fixes,
+  is_clean_round_one,
+  passing_fixes,
+  read_verdict,
+  recorded_specs,
+  report_prompt,
+  reviewer_prompt,
+  round_one_opening,
+  round_one_outcome,
+  round_two_outcome,
+  slot_prompt,
+  submit_command,
+  verification_prompt
+};
+
+// scripts/run/ship/run-ship-stop-cause.ts
+var CAUSE = {
+  FINDING: "finding",
+  INFRA: "infra",
+  CONFLICT: "conflict",
+  CHECK: "check",
+  AUTH: "auth",
+  ATTEST: "attest",
+  TIMEOUT: "timeout",
+  CI_INFRA: "ci-infra"
+};
+var { STAGE } = run_ship_stage;
+var REVIEW_STAGES = /* @__PURE__ */ new Set([STAGE.REVIEW, STAGE.ROUND_TWO]);
+var INFRA_STAGES = /* @__PURE__ */ new Set([
+  STAGE.SYNC,
+  STAGE.COMMIT,
+  STAGE.FOLLOWUP,
+  STAGE.REPORT
+]);
+var INFRA_PATTERNS = [
+  /rate limit/iu,
+  new RegExp(NO_CHECKS_MESSAGE, "u"),
+  new RegExp(UNREADABLE_COMMENTS_STOP, "u"),
+  /\b(?:ECONNRESET|ECONNREFUSED|ETIMEDOUT|EAI_AGAIN|ENOTFOUND)\b/u,
+  /socket hang up/iu,
+  /could not resolve host/iu,
+  /\bHTTP 50[234]\b/u
+];
+function is_infra(output) {
+  return INFRA_PATTERNS.some((pattern) => pattern.test(output));
+}
+var AUTH_LINE = new RegExp(
+  `^(?:isolated reviewer failed: (?:the broker answered a failure: )?)?${api_auth.AUTH_FAILURE_NOTE}`,
+  "mu"
+);
+function is_review(stage) {
+  return REVIEW_STAGES.has(stage);
+}
+function review_cause(output, tagged = CAUSE.FINDING) {
+  return AUTH_LINE.test(output) ? CAUSE.AUTH : tagged;
+}
+var NO_OUTPUT = { body: "" };
+function infra_text({ body, out = body }) {
+  return out;
+}
+var FAILURE_LINE = new RegExp(`^${git_error.FAILURE_PREFIX} `, "gmu");
+var REPORTED_LINE = new RegExp(
+  `^(?:${git_error.FAILURE_PREFIX}|${git_error.DETAILS_PREFIX}) (?<message>.*)$`,
+  "gmu"
+);
+function final_failures(body) {
+  const last = [...body.matchAll(FAILURE_LINE)].at(-1);
+  if (last === void 0) return [];
+  return [...body.slice(last.index).matchAll(REPORTED_LINE)].map(
+    ({ groups }) => groups?.["message"] ?? ""
+  );
+}
+function is_spent_stop(body) {
+  return final_failures(body).some((message) => body.includes(gh_retry.spent_note(message)));
+}
+function is_wait_timeout(body) {
+  return final_failures(body).includes(PR_CHECKS_TIMEOUT_MESSAGE);
+}
+function is_reruns_spent(body) {
+  return final_failures(body).some((message) => message.startsWith(RERUNS_SPENT_MESSAGE));
+}
+function ended_cause(body) {
+  if (is_wait_timeout(body)) return CAUSE.TIMEOUT;
+  return is_reruns_spent(body) ? CAUSE.CI_INFRA : void 0;
+}
+function is_infra_stop(failed) {
+  return is_infra(infra_text(failed)) || is_spent_stop(failed.body);
+}
+function stage_cause(stage, failed) {
+  if (failed.cause === CAUSE.CHECK || !INFRA_STAGES.has(stage)) return CAUSE.CHECK;
+  const ended = ended_cause(failed.body);
+  if (ended !== void 0) return ended;
+  return is_infra_stop(failed) ? CAUSE.INFRA : CAUSE.CHECK;
+}
+function cause_of(stage, failed) {
+  const { body, conflicts, cause } = failed;
+  const reason = run_ship_stage.stop_reason(stage, conflicts);
+  if (reason === run_ship_stage.CONFLICT) return CAUSE.CONFLICT;
+  if (is_review(stage)) return review_cause(body, cause);
+  return stage_cause(stage, failed);
+}
+function is_finding_stop(stage, cause) {
+  return is_review(stage) && cause === CAUSE.FINDING;
+}
+function findings_of(stage, cause, body) {
+  return is_finding_stop(stage, cause) ? run_ship_review.blocking_kinds(body) : [];
+}
+function checks_of(stage, cause, body) {
+  return stage === STAGE.FOLLOWUP && cause === CAUSE.CHECK ? git_pr_checks_failed.names_of(body) : [];
+}
+function details_of(stage, failed = NO_OUTPUT) {
+  if (!is_finding_stop(stage, cause_of(stage, failed))) return [];
+  return run_ship_review.blocking_details(failed.body);
+}
+function preflight_of({ preconditions, unpinned }) {
+  return {
+    ...preconditions !== void 0 && { preconditions: [...preconditions] },
+    ...unpinned !== void 0 && { unpinned }
+  };
+}
+function record_of(issue, stage, failed = NO_OUTPUT) {
+  const { body, conflicts } = failed;
+  const cause = cause_of(stage, failed);
+  const findings = findings_of(stage, cause, body);
+  const checks = checks_of(stage, cause, body);
+  return {
+    issue,
+    reason: run_ship_stage.stop_reason(stage, conflicts),
+    cause,
+    ...preflight_of(failed),
+    ...findings.length > 0 && { findings: [...findings] },
+    ...checks.length > 0 && { checks: [...checks] }
+  };
+}
+function blocked_cause_of(body) {
+  return final_failures(body).find(is_blocked_cause);
+}
+var AT_ONCE_CAUSES = /* @__PURE__ */ new Set([CAUSE.TIMEOUT, CAUSE.CI_INFRA]);
+function parks_at_once(stage, failed) {
+  return AT_ONCE_CAUSES.has(cause_of(stage, failed));
+}
+var run_ship_stop_cause = {
+  CAUSE,
+  blocked_cause_of,
+  cause_of,
+  details_of,
+  is_review,
+  parks_at_once,
+  record_of
+};
+
+export {
+  run_ship_review,
+  run_ship_stop_cause
+};