@joshuafolkken/kit 1.3044.0 → 1.3099.0

package/dist/commands/chunk-URZ4RDC4.js

@@ -0,0 +1,220 @@
+import {
+  stamp_file
+} from "./chunk-VLN6TSPJ.js";
+import {
+  PROJECT_ROOT
+} from "./chunk-3CCGKX7Y.js";
+import {
+  git_command
+} from "./chunk-IXZZSST7.js";
+import {
+  json_value
+} from "./chunk-HIU2WXB6.js";
+
+// scripts/review/review-checkout.ts
+async function read_checkout() {
+  const [root, branch, head] = await Promise.all([
+    git_command.repository_root(),
+    git_command.branch(),
+    git_command.head_commit()
+  ]);
+  return { root, branch, head };
+}
+function is_same_checkout(expected, actual) {
+  return expected.root === actual.root && expected.branch === actual.branch && expected.head === actual.head;
+}
+function describe_checkout(checkout) {
+  return `${checkout.root} (branch ${checkout.branch}, HEAD ${checkout.head})`;
+}
+var review_checkout = { describe_checkout, is_same_checkout, read_checkout };
+
+// scripts/review/review-attest.ts
+import { randomBytes } from "node:crypto";
+import { lstatSync } from "node:fs";
+var REVIEW_SLOT = { CODE: "code", INTERACTION: "interaction" };
+var REVIEW_SLOTS = [REVIEW_SLOT.CODE, REVIEW_SLOT.INTERACTION];
+var POINTER_PREFIXES = {
+  code: "josh-review-target-",
+  interaction: "josh-review-interaction-target-"
+};
+var EXPECT_PREFIX = "josh-review-expect-";
+var ATTEST_PREFIX = "josh-review-attest-";
+var NONCE_BYTES = 8;
+var HOURS_BEFORE_STALE = 8;
+var MILLISECONDS_PER_HOUR = 36e5;
+var STALE_AFTER_MS = HOURS_BEFORE_STALE * MILLISECONDS_PER_HOUR;
+function pointer_path(root = PROJECT_ROOT, slot = REVIEW_SLOT.CODE) {
+  return stamp_file.stamp_path(POINTER_PREFIXES[slot], root);
+}
+function expect_path(nonce) {
+  return stamp_file.stamp_path(EXPECT_PREFIX, nonce);
+}
+function attest_path(nonce) {
+  return stamp_file.stamp_path(ATTEST_PREFIX, nonce);
+}
+function read_json(source) {
+  const raw = stamp_file.read_stamp_text(source);
+  return raw === void 0 ? void 0 : json_value.parse_or_undefined(raw);
+}
+function string_field(value, key) {
+  const field = value[key];
+  return typeof field === "string" ? field : void 0;
+}
+function to_checkout(value) {
+  if (!json_value.is_record(value)) return void 0;
+  const root = string_field(value, "root");
+  const branch = string_field(value, "branch");
+  const head = string_field(value, "head");
+  if (root === void 0 || branch === void 0 || head === void 0) return void 0;
+  return { root, branch, head };
+}
+function to_pointer(value) {
+  if (!json_value.is_record(value)) return void 0;
+  const nonce = string_field(value, "nonce");
+  const taken_at = string_field(value, "taken_at");
+  if (nonce !== void 0 && taken_at !== void 0) return { nonce, taken_at };
+  return void 0;
+}
+function read_pointer(root, slot) {
+  return to_pointer(read_json(pointer_path(root, slot)));
+}
+function read_expectation(nonce) {
+  return to_checkout(read_json(expect_path(nonce)));
+}
+function read_attestation(nonce) {
+  return to_checkout(read_json(attest_path(nonce)));
+}
+function drop_records(pointer) {
+  if (pointer === void 0) return;
+  stamp_file.remove_stamp(expect_path(pointer.nonce));
+  stamp_file.remove_stamp(attest_path(pointer.nonce));
+}
+function drop_slot(root, slot) {
+  const pointer = read_pointer(root, slot);
+  stamp_file.remove_stamp(pointer_path(root, slot));
+  drop_records(pointer);
+}
+function is_stale(taken_at, now) {
+  const taken = Date.parse(taken_at);
+  return Number.isNaN(taken) || now - taken > STALE_AFTER_MS;
+}
+function record_target(checkout, root, slot = REVIEW_SLOT.CODE) {
+  const nonce = randomBytes(NONCE_BYTES).toString("hex");
+  const taken_at = (/* @__PURE__ */ new Date()).toISOString();
+  if (slot === REVIEW_SLOT.CODE) drop_slot(root, REVIEW_SLOT.INTERACTION);
+  drop_records(read_pointer(root, slot));
+  stamp_file.write_stamp(expect_path(nonce), { ...checkout, taken_at });
+  stamp_file.write_stamp(pointer_path(root, slot), { nonce, taken_at });
+  return nonce;
+}
+function attest(nonce, actual) {
+  const expected = read_expectation(nonce);
+  if (expected === void 0) return { status: "missing", nonce, actual };
+  stamp_file.write_stamp(attest_path(nonce), { ...actual, taken_at: (/* @__PURE__ */ new Date()).toISOString() });
+  if (review_checkout.is_same_checkout(expected, actual)) {
+    return { status: "ok", nonce, expected, actual };
+  }
+  return { status: "mismatch", nonce, expected, actual };
+}
+function not_required() {
+  return { status: "not-required" };
+}
+function verdict_for(nonce) {
+  const expected = read_expectation(nonce);
+  if (expected === void 0) return { status: "missing", nonce };
+  const actual = read_attestation(nonce);
+  if (actual === void 0) return { status: "missing", nonce, expected };
+  if (review_checkout.is_same_checkout(expected, actual)) {
+    return { status: "ok", nonce, expected, actual };
+  }
+  return { status: "mismatch", nonce, expected, actual };
+}
+function check_slot(now, root, slot) {
+  const pointer = read_pointer(root, slot);
+  if (pointer === void 0) return not_required();
+  const verdict = verdict_for(pointer.nonce);
+  if (verdict.status === "missing" && is_stale(pointer.taken_at, now)) return not_required();
+  return verdict;
+}
+function is_passing(verdict) {
+  return verdict.status === "ok" || verdict.status === not_required().status;
+}
+function check(now = Date.now(), root) {
+  const verdicts = REVIEW_SLOTS.map((slot) => check_slot(now, root, slot));
+  return verdicts.find((verdict) => !is_passing(verdict)) ?? verdicts.find((verdict) => verdict.status === "ok") ?? not_required();
+}
+function is_written_since(source, taken_at) {
+  try {
+    const stats = lstatSync(source);
+    return stats.isFile() && stats.mtimeMs >= Date.parse(taken_at);
+  } catch {
+    return false;
+  }
+}
+function is_attested_on(checkout, root) {
+  const pointer = read_pointer(root);
+  if (pointer === void 0) return false;
+  const verdict = verdict_for(pointer.nonce);
+  return verdict.status === "ok" && verdict.expected?.branch === checkout.branch;
+}
+function is_reviewed_on(checkout, findings_path, root) {
+  const pointer = read_pointer(root);
+  if (pointer === void 0 || !is_attested_on(checkout, root)) return false;
+  return is_written_since(findings_path, pointer.taken_at);
+}
+function is_briefed_since(written_at, root) {
+  const pointer = read_pointer(root);
+  return pointer !== void 0 && written_at >= pointer.taken_at;
+}
+async function check_here(now = Date.now()) {
+  return check(now, await git_command.repository_root());
+}
+function clear(root) {
+  for (const slot of REVIEW_SLOTS) drop_slot(root, slot);
+}
+async function clear_here() {
+  clear(await git_command.repository_root());
+}
+var MISMATCH_VERDICT = "REVIEW TARGET MISMATCH";
+function describe_side(label, checkout) {
+  if (checkout === void 0) return `${label}: unknown`;
+  return `${label}: ${review_checkout.describe_checkout(checkout)}`;
+}
+var MISSING_REASON = "The review left no attestation, so there is no evidence it read this checkout at all. A review that read the wrong tree finds nothing wrong and reports no findings, which is indistinguishable from a clean review \u2014 so an absent attestation is treated as no review (joshuafolkken/kit#1522).";
+var MISMATCH_REASON = `${MISMATCH_VERDICT}: the review attested a different checkout from the one it was briefed on. Its findings \u2014 including "no findings" \u2014 describe another tree.`;
+var REMEDY = "Re-run `/code-review` with the brief `pnpm josh review:brief` prints, against the checkout named above, and let it run `pnpm josh review:attest <nonce>` from there before it reports.";
+function refusal_message(verdict) {
+  const reason = verdict.status === "mismatch" ? MISMATCH_REASON : MISSING_REASON;
+  return [
+    reason,
+    describe_side("Briefed on", verdict.expected),
+    describe_side("Reviewed", verdict.actual),
+    REMEDY
+  ].join("\n");
+}
+var review_attest = {
+  attest,
+  check,
+  check_here,
+  clear,
+  clear_here,
+  expect_path,
+  is_attested_on,
+  is_briefed_since,
+  is_reviewed_on,
+  MISMATCH_VERDICT,
+  MISSING_REASON,
+  read_attestation,
+  read_expectation,
+  read_pointer,
+  record_target,
+  refusal_message,
+  REVIEW_SLOT,
+  REVIEW_SLOTS,
+  STALE_AFTER_MS
+};
+
+export {
+  review_checkout,
+  review_attest
+};

package/dist/commands/chunk-UUA63LCI.js

@@ -0,0 +1,77 @@
+import {
+  issue_outcome
+} from "./chunk-2WRDAQPJ.js";
+import {
+  run_hold_cli
+} from "./chunk-YD7XK2TX.js";
+import {
+  cli_body
+} from "./chunk-7IZJ5MG2.js";
+import {
+  git_gh_command
+} from "./chunk-NRULNBYI.js";
+import {
+  error_text
+} from "./chunk-CDY4NFQG.js";
+import {
+  issue_number_shape
+} from "./chunk-G75GWNNY.js";
+import {
+  cli_flags
+} from "./chunk-2FE3C4PH.js";
+
+// scripts/issue/issue-evidence-exit.ts
+var FAILURE_EXIT_CODE = 1;
+var EVIDENCE_FILE_FLAG = "--evidence-file";
+var OPTIONS = { "evidence-file": { type: "string" }, outcome: { type: "string" } };
+function parse_request(argv) {
+  const parsed = cli_flags.arguments_of(argv, OPTIONS);
+  if (parsed === void 0) return void 0;
+  const issue_number = issue_number_shape.single_of(parsed.positionals);
+  const file_path = parsed.values["evidence-file"];
+  if (issue_number === void 0 || file_path === void 0) return void 0;
+  const evidence = cli_body.read_file_or_stdin(file_path).trim();
+  if (evidence.length === 0) throw new Error(`Evidence file is empty: ${file_path}`);
+  return {
+    issue_number,
+    evidence: issue_outcome.body_of({ body: evidence, summary: parsed.values.outcome })
+  };
+}
+function resolve_request(argv, command) {
+  try {
+    const request = parse_request(argv);
+    if (request === void 0) {
+      console.error(`Usage: josh ${command} <issue-number> ${EVIDENCE_FILE_FLAG} <path>`);
+    }
+    return request;
+  } catch (error) {
+    console.error(error_text.message_of(error));
+    return void 0;
+  }
+}
+async function post_evidence(request) {
+  try {
+    console.info(await git_gh_command.issue_comment(request.issue_number, request.evidence));
+    return true;
+  } catch (error) {
+    console.error(`Evidence comment not posted: ${error_text.message_of(error)}`);
+    return false;
+  }
+}
+async function write_exit(request, exit) {
+  const { issue_number, evidence } = request;
+  return await post_evidence(request) && await exit.finish(issue_number, evidence);
+}
+async function is_admitted(request, exit) {
+  return exit.admit === void 0 || await exit.admit(request.issue_number);
+}
+async function run(argv, exit) {
+  const request = resolve_request(argv, exit.command);
+  if (request === void 0 || !await is_admitted(request, exit)) return FAILURE_EXIT_CODE;
+  return await write_exit(request, exit) ? await run_hold_cli.run(["--release", request.issue_number]) : FAILURE_EXIT_CODE;
+}
+var issue_evidence_exit = { run, write: write_exit };
+
+export {
+  issue_evidence_exit
+};

package/dist/commands/chunk-UUH3DE77.js

@@ -0,0 +1,57 @@
+import {
+  durable_state_root
+} from "./chunk-5VQCL33M.js";
+import {
+  stamp_file
+} from "./chunk-VLN6TSPJ.js";
+import {
+  json_value
+} from "./chunk-HIU2WXB6.js";
+
+// scripts/lane/lane-state-record.ts
+import path from "node:path";
+import { z } from "zod";
+var STATE_SUFFIX = ".json";
+var DEPENDENCY_WAIT_COMMAND = "lane:dependency-wait";
+var HUMAN_REVIEW = "human-review";
+var LANE_STATES = ["open", "running", "paused", HUMAN_REVIEW, "ended"];
+var IDLE_STATES = /* @__PURE__ */ new Set(["paused", HUMAN_REVIEW, "ended"]);
+var lane_run_schema = z.object({ started_at: z.string(), owner_pid: z.number().optional() });
+var stuck_schema = z.object({ pid: z.number(), reason: z.string() });
+var lane_state_schema = z.object({
+  issue: z.string(),
+  run: lane_run_schema.optional(),
+  state: z.enum(LANE_STATES),
+  launched_at: z.string().optional(),
+  changed_at: z.string(),
+  changed_by: z.string(),
+  stuck: z.array(stuck_schema).optional()
+});
+function record_name(common, issue) {
+  return stamp_file.stamp_name(
+    durable_state_root.PREFIX.LANE_STATE,
+    common,
+    `-${issue}${STATE_SUFFIX}`
+  );
+}
+function read_record_file(source) {
+  const raw = stamp_file.read_stamp_text(source);
+  return raw === void 0 ? void 0 : json_value.parse_with(raw, lane_state_schema);
+}
+function is_idle(state_root, common, issue) {
+  const record = read_record_file(path.join(state_root, record_name(common, issue)));
+  return record !== void 0 && IDLE_STATES.has(record.state);
+}
+var lane_state_record = {
+  DEPENDENCY_WAIT_COMMAND,
+  HUMAN_REVIEW,
+  LANE_STATES,
+  STATE_SUFFIX,
+  is_idle,
+  read_record_file,
+  record_name
+};
+
+export {
+  lane_state_record
+};

package/dist/commands/chunk-UVY5ODCM.js

@@ -0,0 +1,60 @@
+import {
+  stash_args
+} from "./chunk-R7IT5VOL.js";
+import {
+  main_merge_guard
+} from "./chunk-HE3GOMR7.js";
+import {
+  git_stash
+} from "./chunk-WROJTXWZ.js";
+import {
+  error_text
+} from "./chunk-CDY4NFQG.js";
+
+// scripts/git/stash/stash-push-cli.ts
+var COMMAND = "stash:push";
+var STASH_RERUN = "the command that stashed (`run:pause`, `stash:push`, `latest:if-required`)";
+var STASHED_VERDICT = "stashed";
+var CLEAN_VERDICT = "clean";
+var SUCCESS_EXIT_CODE = 0;
+var FAILURE_EXIT_CODE = 1;
+function report(verdict, detail) {
+  console.info(verdict);
+  console.error(detail);
+  return SUCCESS_EXIT_CODE;
+}
+function refuse() {
+  console.error(stash_args.usage(COMMAND));
+  return FAILURE_EXIT_CODE;
+}
+async function set_aside(request) {
+  const unmerged = await git_stash.unmerged_paths(request.dir);
+  if (unmerged.length > 0) {
+    throw new Error(main_merge_guard.unresolved_message(COMMAND, unmerged, STASH_RERUN));
+  }
+  if (!await git_stash.has_stashable_changes(request.dir)) return CLEAN_VERDICT;
+  await git_stash.push(request.message, request.dir, git_stash.STASHABLE_PATHSPEC);
+  return STASHED_VERDICT;
+}
+async function answer(request) {
+  if (await set_aside(request) === CLEAN_VERDICT) {
+    return report(CLEAN_VERDICT, "Nothing to stash.");
+  }
+  return report(STASHED_VERDICT, `Stashed as "${request.message}".`);
+}
+async function run(argv) {
+  const parsed = stash_args.read_arguments(argv);
+  const request = parsed === void 0 ? void 0 : stash_args.to_request(parsed);
+  if (request === void 0) return refuse();
+  try {
+    return await answer(request);
+  } catch (error) {
+    console.error(error_text.message_of(error));
+    return FAILURE_EXIT_CODE;
+  }
+}
+var stash_push_cli = { CLEAN_VERDICT, STASHED_VERDICT, run, set_aside };
+
+export {
+  stash_push_cli
+};

package/dist/commands/chunk-UWMB6EOU.js

@@ -0,0 +1,45 @@
+import {
+  git_gh_command
+} from "./chunk-NRULNBYI.js";
+import {
+  issue_label_schema
+} from "./chunk-34DND4BA.js";
+import {
+  IN_PROGRESS_LABEL,
+  label_name_of
+} from "./chunk-QQBMVC5W.js";
+import {
+  session_cite
+} from "./chunk-22DVQCP6.js";
+import {
+  parse_json_object_or_undefined
+} from "./chunk-43DU7DYZ.js";
+
+// scripts/followup/git-followup-label.ts
+import { z } from "zod";
+var labels_read_schema = z.object({ labels: z.array(issue_label_schema).optional() });
+function unreadable_error(issue_number) {
+  return new Error(
+    `gh api answered no readable labels for issue ${session_cite.issue(issue_number)}`
+  );
+}
+async function read_label_names(issue_number) {
+  const raw = await git_gh_command.issue_get_labels_and_body(issue_number);
+  if (raw === void 0) throw unreadable_error(issue_number);
+  const parsed = parse_json_object_or_undefined(raw, labels_read_schema);
+  if (parsed === void 0) throw unreadable_error(issue_number);
+  return (parsed.labels ?? []).map((label) => label.name);
+}
+async function strip_in_progress(issue_number) {
+  if (issue_number === void 0) return;
+  const stored = label_name_of(await read_label_names(issue_number), IN_PROGRESS_LABEL);
+  if (stored === void 0) return;
+  await git_gh_command.issue_remove_label(issue_number, stored);
+}
+var git_followup_label = {
+  strip_in_progress
+};
+
+export {
+  git_followup_label
+};

package/dist/commands/chunk-UY62WJV6.js

@@ -0,0 +1,120 @@
+import {
+  git_pr
+} from "./chunk-NABSSY4P.js";
+import {
+  live_evidence
+} from "./chunk-HALHQILI.js";
+import {
+  git_issue
+} from "./chunk-QTVVFV4Q.js";
+import {
+  git_gh_command
+} from "./chunk-NRULNBYI.js";
+import {
+  git_branch
+} from "./chunk-YEQFAEVW.js";
+import {
+  error_text
+} from "./chunk-CDY4NFQG.js";
+import {
+  changed_paths
+} from "./chunk-U5EO4QEV.js";
+import {
+  git_command
+} from "./chunk-IXZZSST7.js";
+
+// scripts/git/git-preflight.ts
+var PRECONDITION = {
+  ISSUE: "issue",
+  BRANCH: "branch",
+  CLASSIFICATION: "classification"
+};
+function unmet(kind, problem) {
+  return { kind, problem };
+}
+function resolve_from_branch(current_branch) {
+  const number = git_issue.branch_number(current_branch);
+  if (number === void 0) {
+    const problem = unmet(PRECONDITION.ISSUE, git_issue.branch_derivation_error(current_branch));
+    return { target: void 0, problems: [problem] };
+  }
+  return { target: { number, branch_name: current_branch }, problems: [] };
+}
+function resolve_parsed(parsed, current_branch, default_branch) {
+  const branch_name = current_branch === default_branch ? parsed.branch_name : current_branch;
+  const target = { number: parsed.number, branch_name };
+  if (!git_branch.is_mismatch(current_branch, parsed.branch_name, default_branch)) {
+    return { target, problems: [] };
+  }
+  return {
+    target,
+    problems: [
+      unmet(
+        PRECONDITION.BRANCH,
+        `Branch mismatch: on "${current_branch}", but the title resolves to "${parsed.branch_name}".`
+      )
+    ]
+  };
+}
+function resolve_from_title(cli_input, current_branch, default_branch) {
+  try {
+    return resolve_parsed(git_issue.parse(cli_input), current_branch, default_branch);
+  } catch (error) {
+    return {
+      target: void 0,
+      problems: [unmet(PRECONDITION.ISSUE, error_text.message_of(error))]
+    };
+  }
+}
+async function resolve_target(cli_input) {
+  const current_branch = await git_branch.current();
+  if (cli_input === void 0) return resolve_from_branch(current_branch);
+  return resolve_from_title(cli_input, current_branch, await git_command.get_default_branch());
+}
+async function classification_problems(target) {
+  try {
+    await git_pr.release_classification(target.number, target.branch_name);
+    return [];
+  } catch (error) {
+    return [unmet(PRECONDITION.CLASSIFICATION, error_text.message_of(error))];
+  }
+}
+async function announce_evidence(branch_name) {
+  const [paths, body] = await Promise.all([
+    changed_paths.read_changed_paths(false),
+    git_gh_command.pr_get_body(branch_name)
+  ]);
+  if (live_evidence.verdict_for(paths, body) !== "required") return;
+  console.info(
+    `\u{1F4A1} This change touches runtime code: the PR body needs a ${live_evidence.EVIDENCE_HEADING} section before \`josh followup\` merges it.`
+  );
+}
+function refusal(problems) {
+  const lines = problems.map(({ problem }) => `  - ${problem}`);
+  return new Error(
+    [
+      `Preflight found ${String(problems.length)} unmet precondition(s); nothing was changed:`,
+      ...lines
+    ].join("\n")
+  );
+}
+async function answer(input) {
+  const { target, problems } = await resolve_target(input.cli_input);
+  const pr_target = input.will_open_pr ? target : void 0;
+  const pr_problems = pr_target === void 0 ? [] : await classification_problems(pr_target);
+  return { pr_target, problems: [...problems, ...pr_problems] };
+}
+async function problems_of(input) {
+  const { problems } = await answer(input);
+  return problems;
+}
+async function check(input) {
+  const { pr_target, problems } = await answer(input);
+  if (problems.length > 0) throw refusal(problems);
+  if (pr_target !== void 0) await announce_evidence(pr_target.branch_name);
+}
+var git_preflight = { check, problems_of };
+
+export {
+  git_preflight
+};