@joshuafolkken/kit 1.3044.0 → 1.3099.0

package/dist/commands/chunk-6FN37DER.js

@@ -0,0 +1,330 @@
+import {
+  related_scope
+} from "./chunk-KJPZPTS4.js";
+import {
+  whole_suite_files
+} from "./chunk-WEUUJIWQ.js";
+import {
+  import_graph
+} from "./chunk-4IDINPBE.js";
+import {
+  test_declared_logic
+} from "./chunk-7HCPRVMB.js";
+import {
+  git_spawn
+} from "./chunk-B5HP6T4L.js";
+import {
+  json_value
+} from "./chunk-HIU2WXB6.js";
+
+// scripts/test/test-pinned-reach.ts
+import { existsSync } from "node:fs";
+import path2 from "node:path";
+
+// scripts/test/test-pinned-cache-logic.ts
+import { createHash } from "node:crypto";
+import { z } from "zod";
+var DIGEST_ALGORITHM = "sha256";
+var LINE_BREAK = "\n";
+var VERDICTS = ["red", "green", "no-test", "test-only"];
+var STORED_SCHEMA = z.object({
+  verdict: z.enum(VERDICTS),
+  tests: z.record(z.string(), z.string()),
+  basis: z.string().optional(),
+  related: z.record(z.string(), z.string()).optional()
+});
+var GREEN_SCHEMA = z.object({
+  file: z.string(),
+  old_lines: z.array(z.string()),
+  new_lines: z.array(z.string())
+});
+var CACHE_SCHEMA = z.object({
+  test_contents: z.string(),
+  change: z.string(),
+  entries: z.record(z.string(), STORED_SCHEMA),
+  pruned: z.string().optional(),
+  green: z.array(GREEN_SCHEMA).optional()
+});
+function digest_of(text) {
+  return createHash(DIGEST_ALGORITHM).update(text).digest("hex");
+}
+function hunk_key(hunk, content) {
+  if (hunk.parts !== void 0) {
+    return digest_of(JSON.stringify(hunk.parts.map((part) => hunk_key(part, content))));
+  }
+  const start = hunk.new_start - 1;
+  const lines = content.split(LINE_BREAK).slice(start, start + hunk.new_count);
+  return digest_of(JSON.stringify([hunk.file, hunk.function_name ?? "", hunk.old_lines, lines]));
+}
+function distinct(keys) {
+  return keys.map((key, index) => {
+    const seen = keys.slice(0, index).filter((earlier) => earlier === key).length;
+    return seen === 0 ? key : `${key}:${String(seen)}`;
+  });
+}
+function sorted(names) {
+  return names.toSorted((left, right) => left.localeCompare(right));
+}
+function test_set_of(test_files) {
+  return digest_of(sorted(test_files).join(LINE_BREAK));
+}
+function change_of(commit, paths, digests) {
+  return digest_of(JSON.stringify([commit, sorted(paths).map((file) => [file, digests.get(file)])]));
+}
+function entries_of(text) {
+  return json_value.parse_with(text, CACHE_SCHEMA)?.entries ?? {};
+}
+function greens_of(text) {
+  return json_value.parse_with(text, CACHE_SCHEMA)?.green ?? [];
+}
+function freshness_of(text, now) {
+  const cache = json_value.parse_with(text, CACHE_SCHEMA);
+  return {
+    is_same_change: cache?.change === now.change,
+    is_unchanged: cache?.test_contents === now.test_contents,
+    is_pruned: cache?.pruned !== void 0 && cache.pruned === now.pruned
+  };
+}
+function holds_tests(tests, freshness, digests) {
+  const files = Object.entries(tests);
+  if (files.length === 0) return freshness.is_unchanged;
+  return files.every(([file, digest]) => digests.get(file) === digest);
+}
+function is_based(entry, basis) {
+  return entry.basis !== void 0 && entry.basis === basis;
+}
+function is_same_code(freshness) {
+  return freshness.is_same_change || freshness.is_pruned;
+}
+function holds(entry, freshness, digests, basis) {
+  if (entry.verdict !== "red") return freshness.is_unchanged || is_based(entry, basis);
+  const is_same = is_same_code(freshness) || is_based(entry, basis);
+  return is_same && holds_tests(entry.tests, freshness, digests);
+}
+function fresh_verdict(entry, freshness, digests, basis) {
+  if (entry === void 0 || !holds(entry, freshness, digests, basis)) return void 0;
+  return { verdict: entry.verdict, failed: Object.keys(entry.tests) };
+}
+function related_basis(tests, digests, config) {
+  const pairs = sorted(tests).map((file) => [file, digests.get(file) ?? ""]);
+  return { digest: digest_of(JSON.stringify([config, pairs])), related: Object.fromEntries(pairs) };
+}
+function changed_tests(before, now) {
+  if (Object.keys(before).some((file) => now[file] === void 0)) return void 0;
+  return Object.keys(now).filter((file) => before[file] !== now[file]);
+}
+function recheck_tests(entry, basis) {
+  if (entry.related === void 0 || basis?.related === void 0) return void 0;
+  return changed_tests(entry.related, basis.related);
+}
+function failed_recheck(entry, digests) {
+  const failed = Object.keys(entry.tests);
+  if (failed.length === 0 || failed.some((file) => !digests.has(file))) return void 0;
+  return { verdict: entry.verdict, recheck: failed };
+}
+function recheck_of(entry, freshness, basis, digests) {
+  if (entry.verdict === "red") return failed_recheck(entry, digests);
+  if (!freshness.is_same_change) return void 0;
+  const recheck = recheck_tests(entry, basis) ?? [];
+  return recheck.length === 0 ? void 0 : { verdict: entry.verdict, recheck };
+}
+function rechecked(known, probe) {
+  if (known.verdict !== "red") {
+    return probe.verdict === "no-test" ? { verdict: known.verdict, failed: [] } : probe;
+  }
+  return probe.verdict === "green" || probe.verdict === "no-test" ? void 0 : probe;
+}
+function is_recheck(known) {
+  return known !== void 0 && "recheck" in known;
+}
+function red_basis(assets, closures) {
+  const named = closures.toSorted(([left], [right]) => left.localeCompare(right));
+  return digest_of(JSON.stringify([assets, named]));
+}
+function tests_of(failed, digests) {
+  const pairs = failed.flatMap((file) => {
+    const digest = digests.get(file);
+    return digest === void 0 ? [] : [[file, digest]];
+  });
+  return pairs.length === failed.length ? Object.fromEntries(pairs) : {};
+}
+function stored_of(probe, digests, basis) {
+  const entry = { verdict: probe.verdict, tests: tests_of(probe.failed, digests) };
+  if (basis === void 0) return entry;
+  return basis.related === void 0 ? { ...entry, basis: basis.digest } : { ...entry, basis: basis.digest, related: basis.related };
+}
+function stored(keys, probes, digests, bases = []) {
+  const pairs = keys.flatMap((key, index) => {
+    const probe = probes[index];
+    if (probe === void 0 || probe.verdict === "stopped") return [];
+    return [[key, stored_of(probe, digests, bases[index])]];
+  });
+  return Object.fromEntries(pairs);
+}
+var test_pinned_cache_logic = {
+  change_of,
+  digest_of,
+  distinct,
+  entries_of,
+  fresh_verdict,
+  freshness_of,
+  greens_of,
+  hunk_key,
+  is_recheck,
+  recheck_of,
+  rechecked,
+  red_basis,
+  related_basis,
+  stored,
+  tests_of,
+  test_set_of
+};
+
+// scripts/test/test-pinned-spawn.ts
+import path from "node:path";
+var TOKEN = /[\w.-]+/gu;
+function index_of(universe) {
+  const index = /* @__PURE__ */ new Map();
+  for (const file of universe) {
+    if (test_declared_logic.is_test_file(path.relative(process.cwd(), file))) continue;
+    const name = path.basename(file);
+    index.set(name, [...index.get(name) ?? [], file]);
+  }
+  return index;
+}
+function names_in(text, index) {
+  return (text.match(TOKEN) ?? []).flatMap((token) => index.get(token) ?? []);
+}
+function memoized(read) {
+  const known = /* @__PURE__ */ new Map();
+  return function answer(file) {
+    const found = known.get(file) ?? read(file);
+    known.set(file, found);
+    return found;
+  };
+}
+function reader_of(graph, names_of) {
+  return memoized((file) => [
+    ...new Set([file, ...graph.closure(file)].flatMap((read) => names_of(read)))
+  ]);
+}
+function reverse_of(graph, universe, names_of) {
+  const tests = universe.filter((file) => test_declared_logic.is_test_file(file));
+  return function related(file) {
+    const importers = graph.runtime_importers([file], universe);
+    return tests.filter((test) => names_of(test).some((entry) => importers.has(entry)));
+  };
+}
+function create(graph, universe) {
+  const index = index_of(universe);
+  const names_of = memoized((file) => names_in(graph.strings(file).join(" "), index));
+  const named_from = reader_of(graph, names_of);
+  function started(tests) {
+    const found = /* @__PURE__ */ new Set();
+    const pending = [...tests];
+    for (let current = pending.pop(); current !== void 0; current = pending.pop()) {
+      const next = named_from(current).filter((file) => !found.has(file));
+      for (const file of next) found.add(file);
+      pending.push(...next);
+    }
+    return found;
+  }
+  return { started, related: reverse_of(graph, universe, names_of) };
+}
+var test_pinned_spawn = { create };
+
+// scripts/test/test-pinned-reach.ts
+var NUL = "\0";
+var FIXTURE_MARK = "-fixture";
+async function work_tree_files() {
+  const listed = await git_spawn.read(["ls-files", "-coz", "--exclude-standard"]);
+  return listed.split(NUL).filter((file) => file !== "");
+}
+async function code_universe() {
+  const files = await work_tree_files();
+  const code = files.filter((file) => related_scope.is_relatable(file) && existsSync(file));
+  return code.map((file) => path2.resolve(file));
+}
+async function view_of() {
+  const graph = await import_graph.create(process.cwd());
+  if (graph === void 0) return void 0;
+  const universe = await code_universe();
+  return { graph, universe, spawn: test_pinned_spawn.create(graph, universe) };
+}
+function is_root(view, file) {
+  const relative = path2.relative(process.cwd(), file);
+  if (test_declared_logic.is_test_file(relative)) return false;
+  return view.graph.importers([file], view.universe).size <= 1;
+}
+function is_shared(file) {
+  return !related_scope.is_relatable(file) || whole_suite_files.WHOLE_SUITE_FILES.has(path2.normalize(file));
+}
+function is_asset(view, file) {
+  if (is_shared(file)) return true;
+  const reached = view.graph.runtime_importers([path2.resolve(file)], view.universe);
+  return [...reached].some((reader) => is_root(view, reader));
+}
+function is_fixture(file) {
+  return path2.basename(file).includes(FIXTURE_MARK);
+}
+async function probed_files(files) {
+  if (files.every((file) => !is_fixture(file))) return [...files];
+  const view = await view_of();
+  if (view === void 0) return [...files];
+  return files.filter((file) => !is_fixture(file) || is_asset(view, file));
+}
+function related_of(view, file) {
+  const reached = view.graph.runtime_importers([path2.resolve(file)], view.universe);
+  return [.../* @__PURE__ */ new Set([...reached, ...view.spawn.related(path2.resolve(file))])].map((reader) => path2.relative(process.cwd(), reader)).filter((reader) => test_declared_logic.is_test_file(reader));
+}
+async function reached_test_count(files) {
+  const view = await view_of();
+  if (view === void 0) return void 0;
+  return new Set(files.flatMap((file) => related_of(view, file))).size;
+}
+async function reached_test_counts(files) {
+  const view = await view_of();
+  if (view === void 0) return void 0;
+  return files.map((file) => ({ file, count: related_of(view, file).length }));
+}
+function failed_of(view, tests, inputs) {
+  if (tests.length === 0 || tests.some((test) => !inputs.test_digests.has(test))) return void 0;
+  const started = view.spawn.started(tests.map((test) => path2.resolve(test)));
+  const run = [...tests, ...[...started].map((file) => path2.relative(process.cwd(), file))];
+  const closures = run.map((file) => [file, view.graph.closure_hash(path2.resolve(file))]);
+  const assets = inputs.code.filter((file) => is_shared(file) || started.has(path2.resolve(file)));
+  const change = test_pinned_cache_logic.change_of(inputs.commit, assets, inputs.digests);
+  return test_pinned_cache_logic.red_basis(change, closures);
+}
+function create2(inputs) {
+  const held = {};
+  async function related(file) {
+    held.view ??= view_of();
+    const read = await held.view;
+    return read === void 0 ? void 0 : related_of(read, file);
+  }
+  async function failed(tests) {
+    held.view ??= view_of();
+    const read = await held.view;
+    return read === void 0 ? void 0 : failed_of(read, tests, inputs);
+  }
+  async function spawned(file) {
+    held.view ??= view_of();
+    const read = await held.view;
+    return read?.spawn.related(path2.resolve(file)).map((test) => path2.relative(process.cwd(), test));
+  }
+  return { related, failed, spawned };
+}
+var test_pinned_reach = {
+  code_universe,
+  create: create2,
+  probed_files,
+  reached_test_count,
+  reached_test_counts,
+  work_tree_files
+};
+
+export {
+  test_pinned_cache_logic,
+  test_pinned_reach
+};

package/dist/commands/chunk-6JD4VNO4.js

@@ -0,0 +1,124 @@
+import {
+  check_reuse,
+  gate_report
+} from "./chunk-HSZECERZ.js";
+import {
+  related_scope
+} from "./chunk-KJPZPTS4.js";
+import {
+  project_checks
+} from "./chunk-RO4QEZJO.js";
+import {
+  gate_plan
+} from "./chunk-2CKJODCK.js";
+import {
+  core_admission,
+  core_budget
+} from "./chunk-ZCHZU6NX.js";
+import {
+  machine_capacity
+} from "./chunk-XDR2BRDL.js";
+import {
+  gate_labels
+} from "./chunk-WQ6FS544.js";
+import {
+  lane_ledger_write
+} from "./chunk-KIS7JFNP.js";
+import {
+  lane_paths
+} from "./chunk-G75GWNNY.js";
+import {
+  process_identity
+} from "./chunk-F2RDEF2J.js";
+
+// scripts/gate/gate-ledger.ts
+var BACKGROUND_CORES = 2;
+var SAMPLE_INTERVAL_MS = 3e3;
+async function read_external_cores() {
+  const { busy_cores } = await machine_capacity.read_machine();
+  if (busy_cores === void 0) return void 0;
+  return machine_capacity.external_cores(busy_cores, BACKGROUND_CORES);
+}
+function read_foreign_cores() {
+  const foreign = core_budget.live_reservations().filter(
+    ({ reservation }) => !process_identity.is_own_process(reservation.pid, reservation.process_start)
+  );
+  return core_admission.ledger_load(foreign, Date.now()).cores;
+}
+function peak(readings) {
+  const read = readings.filter((reading) => reading !== void 0);
+  if (read.length < readings.length) return void 0;
+  return Math.max(...read);
+}
+function start_sampler(readings) {
+  return setInterval(() => {
+    readings.push(read_foreign_cores());
+  }, SAMPLE_INTERVAL_MS).unref();
+}
+async function start(ledger_path) {
+  if (ledger_path === void 0) return { ledger_path, readings: [], sampler: void 0 };
+  const readings = [await read_external_cores()];
+  return { ledger_path, readings, sampler: start_sampler(readings) };
+}
+function unit_facts(result) {
+  if (result.label !== gate_labels.UNIT_LABEL) return {};
+  return {
+    fallback: related_scope.fallback_kind(result.output),
+    ...related_scope.is_unmoved(result.output) && { is_unmoved: true }
+  };
+}
+function check_records(results) {
+  return results.map((result) => ({
+    label: result.label,
+    elapsed_ms: result.elapsed_ms,
+    is_passed: !gate_report.is_gate_step_failed(result),
+    is_reused: result.reused_at !== void 0,
+    ...result.cpu_ms !== void 0 && { cpu_ms: Math.round(result.cpu_ms) },
+    ...unit_facts(result),
+    claim: result.claim
+  }));
+}
+async function record_reused(ledger_path, elapsed_ms) {
+  if (ledger_path === void 0) return;
+  await lane_ledger_write.record_gate(ledger_path, {
+    elapsed_ms,
+    is_passed: true,
+    is_reused: true,
+    issue: lane_paths.issue_here()
+  });
+}
+async function record(begun, results, outcome) {
+  clearInterval(begun.sampler);
+  if (begun.ledger_path === void 0) return;
+  const unit_ms = results.find((result) => result.label === gate_labels.UNIT_LABEL)?.elapsed_ms;
+  const external_cores = peak([...begun.readings, await read_external_cores()]);
+  await lane_ledger_write.record_gate(begun.ledger_path, {
+    ...outcome,
+    unit_ms,
+    external_cores,
+    checks: check_records(results),
+    issue: lane_paths.issue_here()
+  });
+}
+var gate_ledger = {
+  BACKGROUND_CORES,
+  SAMPLE_INTERVAL_MS,
+  record,
+  record_reused,
+  start
+};
+
+// scripts/gate/whole-tree-reuse.ts
+var WHOLE_TREE_FLAG = "--whole-tree";
+async function is_reused(tree, records) {
+  if (records === void 0) return false;
+  const labels = gate_plan.whole_tree_labels(project_checks.is_kit_repository(process.cwd()));
+  const reused = await check_reuse.reusable_checks(labels, tree, records);
+  return labels.every((label) => reused.has(label));
+}
+var whole_tree_reuse = { WHOLE_TREE_FLAG, is_reused };
+
+export {
+  gate_ledger,
+  whole_tree_reuse
+};

package/dist/commands/chunk-6KUA7MRG.js

@@ -0,0 +1,64 @@
+import {
+  issue_watch
+} from "./chunk-3CJNQU7P.js";
+import {
+  review_attest
+} from "./chunk-URZ4RDC4.js";
+import {
+  session_cite
+} from "./chunk-22DVQCP6.js";
+import {
+  git_command
+} from "./chunk-IXZZSST7.js";
+
+// scripts/issue/issue-watch-gate.ts
+var EVERY_CALL_MS = 0;
+function ack_command(issue) {
+  return `pnpm josh issue:ack ${issue}`;
+}
+function unread_message(record) {
+  return [
+    `A person updated issue ${session_cite.issue(record.issue)} after this run read it, and the run has not taken the update in:`,
+    record.pending ?? "",
+    `Read it, compare it with the acceptance criteria, fix what it changes, then run \`${ack_command(record.issue)}\` to record that it was read.`
+  ].join("\n\n");
+}
+function review_message(record, briefed_at) {
+  return [
+    `Issue ${session_cite.issue(record.issue)} was updated after the review was briefed (taken in at ${record.acknowledged_at}, briefed at ${briefed_at}), so the review read the earlier specification.`,
+    "Re-run `/code-review` with a fresh `pnpm josh review:brief`, so the review reads the change against the updated issue."
+  ].join("\n");
+}
+async function polled(root) {
+  return await issue_watch.poll({ interval_ms: EVERY_CALL_MS }, root);
+}
+async function unread_refusal(root) {
+  const record = await polled(root);
+  return record?.pending === void 0 ? void 0 : unread_message(record);
+}
+async function review_refusal(root) {
+  const record = await polled(root);
+  if (record === void 0) return void 0;
+  if (record.pending !== void 0) return unread_message(record);
+  const pointer = review_attest.read_pointer(root);
+  if (pointer === void 0 || record.acknowledged_at <= pointer.taken_at) return void 0;
+  return review_message(record, pointer.taken_at);
+}
+async function review_refusal_here() {
+  return await review_refusal(await git_command.repository_root());
+}
+async function assert_read_here() {
+  const refusal = await unread_refusal(await git_command.repository_root());
+  if (refusal !== void 0) throw new Error(refusal);
+}
+var issue_watch_gate = {
+  assert_read_here,
+  review_refusal,
+  review_refusal_here,
+  unread_message,
+  unread_refusal
+};
+
+export {
+  issue_watch_gate
+};

package/dist/commands/chunk-6LDEZFYR.js

@@ -0,0 +1,88 @@
+import {
+  issue_run_hold
+} from "./chunk-QX2R6UJG.js";
+import {
+  git_gh_command
+} from "./chunk-NRULNBYI.js";
+import {
+  open_issue_schema
+} from "./chunk-34DND4BA.js";
+import {
+  IN_PROGRESS_LABEL
+} from "./chunk-QQBMVC5W.js";
+import {
+  session_cite
+} from "./chunk-22DVQCP6.js";
+import {
+  read_json_listing
+} from "./chunk-43DU7DYZ.js";
+
+// scripts/epic/epic-busy.ts
+var LISTING_LIMIT = 100;
+var NO_AGES = /* @__PURE__ */ new Map();
+function format_holder(issue, repo, ages) {
+  const cite = session_cite.issue(issue.number, issue.title, repo);
+  const age = ages.get(issue.number);
+  return age === void 0 ? cite : `${cite} (${age})`;
+}
+function format_holders(issues, repo, ages) {
+  return issues.map((issue) => format_holder(issue, repo, ages)).join(", ");
+}
+function occupied_lanes(read) {
+  return read.kind === "busy" ? read.issues.length : 0;
+}
+function occupancy_message(issues, repo, limit, ages = NO_AGES) {
+  return `${String(issues.length)} of ${String(limit)} lanes in use in ${repo}: ${format_holders(issues, repo, ages)}.`;
+}
+function lanes_full_message(issues, repo, limit, ages = NO_AGES) {
+  return `${occupancy_message(issues, repo, limit, ages)} No lane is free, so nothing is offered here. A lane is released when its child merges or is parked; if a label is stale, remove it and ask again, and \`JOSH_LANE_LIMIT\` is what raises the ceiling.`;
+}
+function unreadable_message(repo) {
+  return `Could not read the \`${IN_PROGRESS_LABEL}\` listing for ${repo}. That is not "nothing is running" \u2014 check \`gh auth status\` and ask again.`;
+}
+function truncated_message(repo) {
+  return `\u26A0 The \`${IN_PROGRESS_LABEL}\` listing for ${repo} could not be read to the end, so an issue holding that repository may not be in it. That is not "nothing is running" \u2014 nothing is offered here, and asking again will not clear it. Narrow what carries \`${IN_PROGRESS_LABEL}\` in that repository, or run this child there by hand.`;
+}
+var BUSY_REASONS = {
+  unreadable: unreadable_message,
+  truncated: truncated_message
+};
+function busy_reason(read, repo, limit, ages = NO_AGES) {
+  if (read.kind === "busy") return lanes_full_message(read.issues, repo, limit, ages);
+  if (read.kind === "idle") return "";
+  return BUSY_REASONS[read.kind](repo);
+}
+function is_holder(issue) {
+  return issue_run_hold.is_held((issue.labels ?? []).map((label) => label.name));
+}
+function parse_listing(raw, is_capped) {
+  const read = read_json_listing(raw, open_issue_schema);
+  if (read.kind !== "read") return { kind: "unreadable" };
+  const holders = read.rows.filter((row) => is_holder(row));
+  if (holders.length > 0) return { kind: "busy", issues: holders };
+  return { kind: is_capped ? "truncated" : "idle" };
+}
+async function read_repository(repo) {
+  const { json, is_capped } = await git_gh_command.issue_list_by_label_in_repo(
+    IN_PROGRESS_LABEL,
+    LISTING_LIMIT,
+    repo
+  );
+  return json === void 0 ? { kind: "unreadable" } : parse_listing(json, is_capped);
+}
+var epic_busy = {
+  LISTING_LIMIT,
+  occupied_lanes,
+  occupancy_message,
+  lanes_full_message,
+  unreadable_message,
+  truncated_message,
+  busy_reason,
+  is_holder,
+  parse_listing,
+  read_repository
+};
+
+export {
+  epic_busy
+};