@joshuafolkken/kit 1.3101.0 → 1.3125.0

package/dist/commands/chunk-J56TYLAL.js

@@ -0,0 +1,77 @@
+import {
+  issue_outcome
+} from "./chunk-F546BPG3.js";
+import {
+  run_hold_cli
+} from "./chunk-IQMMYORJ.js";
+import {
+  cli_body
+} from "./chunk-7IZJ5MG2.js";
+import {
+  git_gh_command
+} from "./chunk-VJNE7W7O.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-JGC4B5JR.js

@@ -0,0 +1,94 @@
+import {
+  lane_stage_stats
+} from "./chunk-3TN76RWK.js";
+import {
+  lane_stats
+} from "./chunk-WYAY6CQI.js";
+import {
+  lane_ledger
+} from "./chunk-I2RBOH4F.js";
+
+// scripts/lane/lane-held-stats.ts
+var COLUMNS = [
+  "held by",
+  "total (min)",
+  "median (min)",
+  "max (min)",
+  "holds",
+  "not ended"
+];
+var MS_PER_HOUR = 36e5;
+var MAX_HOLD_MS = MS_PER_HOUR;
+var LAUNCH_COMMAND = "lane:launch";
+var { NOT_MEASURED } = lane_stage_stats;
+var NONE_ROW = ["none", NOT_MEASURED, NOT_MEASURED, NOT_MEASURED, "0", "0"];
+var { is_dispatch, is_number } = lane_stage_stats;
+function is_held(entry) {
+  return entry.kind === lane_ledger.KIND.HELD;
+}
+function is_hold_end(entry) {
+  return is_held(entry) || is_dispatch(entry) || entry.kind === lane_ledger.KIND.RELEASED;
+}
+function end_times(entries) {
+  return entries.filter((entry) => is_hold_end(entry)).map((entry) => Date.parse(entry.at)).filter((at) => Number.isFinite(at)).toSorted((left, right) => left - right);
+}
+function wait_ms(held, ends) {
+  const from_ms = Date.parse(held.at);
+  const end_ms = ends.find((at) => at > from_ms);
+  return end_ms === void 0 ? void 0 : Math.min(end_ms - from_ms, MAX_HOLD_MS);
+}
+function holds_of(entries) {
+  const ends = end_times(entries);
+  return entries.filter(is_held).map((held) => ({ reason: held.reason, wait_ms: wait_ms(held, ends) }));
+}
+function launch_holds(entries) {
+  return entries.flatMap(
+    (entry) => entry.kind === lane_ledger.KIND.CORE_WAIT && entry.command === LAUNCH_COMMAND ? { reason: LAUNCH_COMMAND, wait_ms: entry.waited_ms } : []
+  );
+}
+function total(values) {
+  return values.reduce((sum, value) => sum + value, 0);
+}
+function ended_of(holds, reason) {
+  return holds.filter((hold) => hold.reason === reason).map((hold) => hold.wait_ms).filter((value) => is_number(value));
+}
+function reason_row(reason, holds) {
+  const ended = ended_of(holds, reason);
+  const count = holds.filter((hold) => hold.reason === reason).length;
+  return lane_stats.to_row([
+    reason,
+    lane_stage_stats.cell(ended.length === 0 ? void 0 : total(ended)),
+    lane_stage_stats.cell(lane_stats.median(ended)),
+    lane_stage_stats.cell(lane_stats.peak(ended)),
+    String(count),
+    String(count - ended.length)
+  ]);
+}
+function reasons_of(holds) {
+  const reasons = [...new Set(holds.map((hold) => hold.reason))];
+  return reasons.toSorted(
+    (left, right) => total(ended_of(holds, right)) - total(ended_of(holds, left))
+  );
+}
+function table(entries, window) {
+  const period = lane_stats.in_window(entries, window);
+  const holds = [...holds_of(period), ...launch_holds(period)];
+  const rows = reasons_of(holds).map((reason) => reason_row(reason, holds));
+  return [
+    lane_stats.to_row(COLUMNS),
+    lane_stats.to_row(COLUMNS.map(() => "---")),
+    ...rows.length === 0 ? [lane_stats.to_row(NONE_ROW)] : rows
+  ].join("\n");
+}
+function is_open_at(held, now_ms) {
+  return now_ms - Date.parse(held.at) < MAX_HOLD_MS;
+}
+function open_reason(entries, now_ms) {
+  const last = entries.findLast((entry) => is_hold_end(entry));
+  return last !== void 0 && is_held(last) && is_open_at(last, now_ms) ? last.reason : void 0;
+}
+var lane_held_stats = { open_reason, table };
+
+export {
+  lane_held_stats
+};

package/dist/commands/chunk-JKPYLZ6T.js

@@ -0,0 +1,198 @@
+import {
+  review_round_one_blobs
+} from "./chunk-6LHMR3CR.js";
+import {
+  review_round2
+} from "./chunk-OBMXXG5D.js";
+import {
+  path_decision
+} from "./chunk-EYR2X5MZ.js";
+import {
+  review_attest,
+  review_checkout
+} from "./chunk-37RULO76.js";
+import {
+  review_stamps
+} from "./chunk-PMC2N6JK.js";
+import {
+  moved_paths
+} from "./chunk-NR4BD5DD.js";
+import {
+  gate_tree
+} from "./chunk-3OSUM6DM.js";
+import {
+  test_declared_logic
+} from "./chunk-7HCPRVMB.js";
+import {
+  release_approval_prune
+} from "./chunk-G6H2TOAA.js";
+import {
+  stamp_file
+} from "./chunk-VLN6TSPJ.js";
+import {
+  PROJECT_ROOT
+} from "./chunk-3CCGKX7Y.js";
+
+// scripts/review/review-reviewed-tree.ts
+var LINE_SUFFIX = /:\d+(?:-\d+)?$/u;
+var UNSETTLED_DIGEST = "unsettled";
+function settled_files(files, unsettled) {
+  const cited = unsettled.map((file) => [
+    file.replace(LINE_SUFFIX, ""),
+    UNSETTLED_DIGEST
+  ]);
+  return { ...files, ...Object.fromEntries(cited) };
+}
+async function record(unsettled = []) {
+  try {
+    const { files, base } = await gate_tree.read_gate_tree();
+    const blobs = review_round_one_blobs.capture(Object.keys(files));
+    review_stamps.reviewed_stamp.write(settled_files(files, unsettled), void 0, base, blobs);
+  } catch {
+  }
+}
+function is_rerecorded_approval(stamp, path) {
+  return release_approval_prune.is_approval(path) && stamp.files[path] !== UNSETTLED_DIGEST;
+}
+function is_pinning_test(stamp, tree, path) {
+  const is_settled = Object.hasOwn(tree.files, path) && stamp.files[path] !== UNSETTLED_DIGEST;
+  return is_settled && test_declared_logic.is_test_file(path);
+}
+function is_no_move(stamp, tree, path) {
+  return is_rerecorded_approval(stamp, path) || is_pinning_test(stamp, tree, path);
+}
+var MOVEMENT = { DELTA: "delta", HELD: "held", UNSETTLED: "unsettled" };
+var UNEXECUTED_NOTE = "passed over documentation, a prompt or an inert path no round executes";
+var CAUSE = {
+  NO_RECORD: "no reviewed tree was recorded",
+  SKIPPED: "a move round 2 would not read \u2014 a revert to the briefed bytes, a file outside the change, or documentation, a prompt or an inert path a recorded High cites",
+  SYNCED: "the default branch changed a file the round covers",
+  UNFIXED: "a file a recorded High cites still holds its round-1 brief bytes, so no fix is in round 2's delta",
+  UNATTESTED: "the round was not attested on this branch",
+  UNREAD: "git did not answer"
+};
+function unsettled_by(cause, path) {
+  return { movement: MOVEMENT.UNSETTLED, cause: path === void 0 ? cause : `${cause}: ${path}` };
+}
+function is_carry_candidate(stamp, path) {
+  const is_settled = Object.hasOwn(stamp.files, path) && stamp.files[path] !== UNSETTLED_DIGEST;
+  return is_settled && review_round2.is_unexecuted(path, []);
+}
+function carry(stamp, tree, parts) {
+  const candidates = parts.synced.filter((path) => is_carry_candidate(stamp, path));
+  const { blobs, base: from } = stamp;
+  const answers = candidates.length === 0 ? void 0 : review_round_one_blobs.carried_each({ blobs, from, to: tree.base, paths: candidates });
+  if (answers === void 0) return { passed: [], noted: [] };
+  return {
+    passed: candidates.filter((path) => answers[path] !== false),
+    noted: candidates.filter((path) => answers[path] === void 0)
+  };
+}
+function moved_files(stamp, tree, parts) {
+  return parts.changed.filter((path) => !is_no_move(stamp, tree, path));
+}
+function is_unexecuted_move(stamp, path) {
+  return stamp.files[path] !== UNSETTLED_DIGEST && review_round2.is_unexecuted(path, []);
+}
+function unexecuted_note(paths) {
+  if (paths.length === 0) return void 0;
+  return `${UNEXECUTED_NOTE}: ${path_decision.format_path_list(paths)}`;
+}
+function is_read_by_round_two(path, tree, briefed) {
+  if (review_round2.is_unexecuted(path, [])) return false;
+  return briefed?.files[path] !== tree.files[path];
+}
+function unread_cause(stamp, path) {
+  const is_cited = stamp.files[path] === UNSETTLED_DIGEST;
+  return is_cited && !review_round2.is_unexecuted(path, []) ? CAUSE.UNFIXED : CAUSE.SKIPPED;
+}
+function moved_standing(stamp, moved, tree, briefed) {
+  if (moved.length === 0) return { movement: MOVEMENT.HELD };
+  const unread = moved.find((path) => !is_read_by_round_two(path, tree, briefed));
+  if (unread === void 0) return { movement: MOVEMENT.DELTA };
+  return unsettled_by(unread_cause(stamp, unread), unread);
+}
+function noted_standing(stamp, moved, tree, briefed) {
+  const unexecuted = moved.filter((path) => is_unexecuted_move(stamp, path));
+  const read = moved.filter((path) => !unexecuted.includes(path));
+  const answer = moved_standing(stamp, read, tree, briefed);
+  const note = unexecuted_note(unexecuted);
+  return note === void 0 || answer.movement === MOVEMENT.UNSETTLED ? answer : { ...answer, note };
+}
+async function standing(stamp, tree, briefed) {
+  const parts = await moved_paths.moved_parts(stamp, tree);
+  if (parts === void 0) return unsettled_by(CAUSE.UNREAD);
+  const { passed, noted } = carry(stamp, tree, parts);
+  const synced = parts.synced.find(
+    (path) => Object.hasOwn(stamp.files, path) && !passed.includes(path)
+  );
+  if (synced !== void 0) return unsettled_by(CAUSE.SYNCED, synced);
+  const moved = moved_files(stamp, tree, parts).filter((path) => !passed.includes(path));
+  return noted_standing(stamp, [...moved, ...noted], tree, briefed);
+}
+async function movement(stamp, tree, briefed) {
+  const answer = await standing(stamp, tree, briefed);
+  return answer.movement;
+}
+async function is_unmoved(stamp, tree) {
+  return await movement(stamp, tree) === MOVEMENT.HELD;
+}
+async function standing_here() {
+  const stamp = review_stamps.reviewed_stamp.read();
+  if (stamp === void 0) return unsettled_by(CAUSE.NO_RECORD);
+  const checkout = await review_checkout.read_checkout();
+  if (!review_attest.is_attested_on(checkout, checkout.root)) return unsettled_by(CAUSE.UNATTESTED);
+  const tree = await gate_tree.read_gate_tree();
+  return await standing(stamp, tree, review_stamps.round_one_stamp.read());
+}
+function high_cited() {
+  const files = review_stamps.reviewed_stamp.read()?.files ?? {};
+  return Object.keys(files).filter((path) => files[path] === UNSETTLED_DIGEST);
+}
+function resume_point(checkout) {
+  const stamp = review_stamps.reviewed_stamp.read();
+  if (stamp === void 0 || !review_attest.is_briefed_since(stamp.taken_at, checkout.root)) {
+    return void 0;
+  }
+  return review_attest.is_attested_on(checkout, checkout.root) ? stamp : void 0;
+}
+var STOPPED_PREFIX = "josh-review-round1-stopped-";
+function stopped_path() {
+  return stamp_file.stamp_path(STOPPED_PREFIX, PROJECT_ROOT);
+}
+function mark_stopped(issue, is_stopped) {
+  if (!is_stopped) {
+    stamp_file.remove_stamp(stopped_path());
+    return;
+  }
+  try {
+    stamp_file.write_text_stamp(stopped_path(), String(issue));
+  } catch {
+  }
+}
+function is_stopped_on(issue) {
+  return stamp_file.read_stamp_text(stopped_path()) === String(issue);
+}
+function discard() {
+  try {
+    review_stamps.reviewed_stamp.remove();
+    stamp_file.remove_stamp(stopped_path());
+  } catch {
+  }
+}
+var review_reviewed_tree = {
+  MOVEMENT,
+  discard,
+  high_cited,
+  is_stopped_on,
+  is_unmoved,
+  mark_stopped,
+  movement,
+  record,
+  resume_point,
+  standing_here
+};
+
+export {
+  review_reviewed_tree
+};

package/dist/commands/chunk-JM3EJYA3.js

@@ -0,0 +1,65 @@
+import {
+  gate_tree
+} from "./chunk-3OSUM6DM.js";
+import {
+  project_checks
+} from "./chunk-23TWJOAI.js";
+import {
+  release_approval_prune
+} from "./chunk-G6H2TOAA.js";
+import {
+  buffered_process
+} from "./chunk-JZHY7D6D.js";
+
+// scripts/gate/metrics-totals.ts
+var METRICS_TOTALS_COMMAND = ["josh", "metrics", "--totals-only"];
+var METRICS_RERECORD_COMMAND = [...METRICS_TOTALS_COMMAND, "--rerecord"];
+var NOTICE_HEADING = "\u26A0 josh metrics --totals-only did not pass \u2014 settle it before `josh run:review`, whose open stops on it (a total the branch approval names is re-recorded there):";
+var REVIEW_REFUSAL_HEADING = "run:review refused: josh metrics --totals-only did not pass \u2014 record the reason the totals grew (or bring them back down), then run run:review again:";
+async function growth_notice(directory) {
+  if (!project_checks.is_kit_repository(directory)) return void 0;
+  const result = await buffered_process.run_buffered_process(METRICS_TOTALS_COMMAND, {
+    cwd: directory
+  });
+  if (!buffered_process.is_process_failed(result)) return void 0;
+  return `${NOTICE_HEADING}
+${result.output.trim()}`;
+}
+async function totals_check(directory) {
+  if (!project_checks.is_kit_repository(directory)) return void 0;
+  return await buffered_process.run_buffered_process(METRICS_RERECORD_COMMAND, { cwd: directory });
+}
+async function totals_refusal(directory) {
+  const result = await totals_check(directory);
+  if (result === void 0 || !buffered_process.is_process_failed(result)) return void 0;
+  return `${REVIEW_REFUSAL_HEADING}
+${result.output.trim()}`;
+}
+function carries_approval(files) {
+  return Object.keys(files).some((file) => release_approval_prune.is_approval(file));
+}
+async function rerecord(directory, files) {
+  if (!project_checks.is_kit_repository(directory) || !carries_approval(files)) return false;
+  await buffered_process.run_buffered_process(METRICS_RERECORD_COMMAND, { cwd: directory });
+  return true;
+}
+var metrics_totals = {
+  METRICS_RERECORD_COMMAND,
+  METRICS_TOTALS_COMMAND,
+  NOTICE_HEADING,
+  REVIEW_REFUSAL_HEADING,
+  growth_notice,
+  rerecord,
+  // Finish the existing approval writer before fixing the tree any verification will read.
+  async rerecorded_tree(read = gate_tree.read_gate_tree, directory = process.cwd()) {
+    const tree = await read();
+    const is_rerecorded = await metrics_totals.rerecord(directory, tree.files);
+    return is_rerecorded ? await read() : tree;
+  },
+  totals_check,
+  totals_refusal
+};
+
+export {
+  metrics_totals
+};