@joshuafolkken/kit 1.3044.0 → 1.3092.0

package/dist/commands/chunk-QXCG3SG4.js

@@ -0,0 +1,88 @@
+import {
+  with_page_size
+} from "./chunk-CDYFUCDC.js";
+import {
+  poll
+} from "./chunk-SBGTCT2C.js";
+import {
+  git_gh_exec
+} from "./chunk-43DU7DYZ.js";
+import {
+  GH_API_TIMEOUT_MS
+} from "./chunk-WPAQUMHC.js";
+import {
+  json_value
+} from "./chunk-HIU2WXB6.js";
+
+// scripts/propagate/propagate-publish.ts
+var VERSIONS_PAGE_SIZE = 100;
+var NAMES_JQ = "[.[] | .name]";
+var DEFAULT_TIMEOUT_MS = 6e5;
+var DEFAULT_INTERVAL_MS = 15e3;
+var UNREADABLE_THRESHOLD = 3;
+function is_version_published(published_versions, target_version) {
+  return published_versions.includes(target_version);
+}
+function should_keep_waiting(now_ms, deadline_ms) {
+  return now_ms < deadline_ms;
+}
+function finish(state, version, attempts) {
+  return { state, version, attempts };
+}
+function fetch_published_versions(versions_endpoint) {
+  const endpoint = with_page_size(versions_endpoint, VERSIONS_PAGE_SIZE);
+  const stdout = git_gh_exec.read_gh_api_sync({
+    path: endpoint,
+    jq_filter: NAMES_JQ,
+    timeout_ms: GH_API_TIMEOUT_MS
+  });
+  if (stdout === void 0) return void 0;
+  return json_value.parse_array(stdout)?.filter((name) => typeof name === "string");
+}
+var WAIT_DEFAULTS = {
+  timeout_ms: DEFAULT_TIMEOUT_MS,
+  interval_ms: DEFAULT_INTERVAL_MS,
+  fetch_versions: fetch_published_versions,
+  sleep: poll.sleep,
+  now: Date.now
+};
+function resolve_wait_options(options) {
+  return { ...WAIT_DEFAULTS, ...options };
+}
+function probe_state(versions, target_version, consecutive_failures) {
+  if (versions === void 0) {
+    return consecutive_failures >= UNREADABLE_THRESHOLD ? "unreadable" : void 0;
+  }
+  return is_version_published(versions, target_version) ? "published" : void 0;
+}
+function probe_once(resolved, versions_endpoint, target_version, progress) {
+  progress.attempts += 1;
+  const versions = resolved.fetch_versions(versions_endpoint);
+  progress.failures = versions === void 0 ? progress.failures + 1 : 0;
+  const state = probe_state(versions, target_version, progress.failures);
+  return state === void 0 ? {} : { state };
+}
+async function wait_for_publish(versions_endpoint, target_version, options = {}) {
+  const resolved = resolve_wait_options(options);
+  const deadline = resolved.now() + resolved.timeout_ms;
+  const progress = { attempts: 0, failures: 0 };
+  const state = await poll.wait_for(
+    () => {
+      if (!should_keep_waiting(resolved.now(), deadline)) return "timed_out";
+      return probe_once(resolved, versions_endpoint, target_version, progress).state;
+    },
+    { interval_ms: resolved.interval_ms, sleeper: resolved.sleep }
+  );
+  return finish(state, target_version, progress.attempts);
+}
+var propagate_publish = {
+  UNREADABLE_THRESHOLD,
+  is_version_published,
+  should_keep_waiting,
+  fetch_published_versions,
+  wait_for_publish
+};
+
+export {
+  propagate_publish
+};

package/dist/commands/chunk-QZVMGAWV.js

@@ -0,0 +1,307 @@
+import {
+  base_tree
+} from "./chunk-NTIVNQKF.js";
+import {
+  resolve_tsx_runner
+} from "./chunk-VL5I2IOD.js";
+import {
+  release_approval_prune
+} from "./chunk-QSJCZATC.js";
+import {
+  toolchain_inputs
+} from "./chunk-TUIFS5E7.js";
+import {
+  stamp_file
+} from "./chunk-VLN6TSPJ.js";
+import {
+  import_graph
+} from "./chunk-JZOTCPX2.js";
+import {
+  change_base
+} from "./chunk-LBVYFW3I.js";
+import {
+  git_command
+} from "./chunk-IXZZSST7.js";
+import {
+  git_spawn
+} from "./chunk-B5HP6T4L.js";
+import {
+  git_location_environment
+} from "./chunk-B77ZMVHS.js";
+import {
+  file_reader
+} from "./chunk-ZNX2LJCQ.js";
+import {
+  json_value
+} from "./chunk-HIU2WXB6.js";
+
+// tools/metrics/metrics-ratchet.ts
+import { z } from "zod";
+var NEWLINE = "\n";
+var JSON_INDENT = "	";
+var GROWTH_PRECISION = 100;
+var metrics_schema = z.object({
+  scripts: z.object({
+    files: z.number(),
+    code_lines: z.number(),
+    comment_lines: z.number(),
+    comment_ratio: z.number()
+  }),
+  rules: z.object({ files: z.number(), lines: z.number() }),
+  guards: z.number(),
+  ai_cost: z.object({ resident_bytes: z.number(), on_demand_bytes: z.number() }),
+  prose: z.object({ long_paragraphs: z.number(), excess_bold: z.number() })
+});
+var approval_schema = z.object({
+  reason: z.string(),
+  date: z.string(),
+  growth: z.record(z.string(), z.number())
+});
+function parse_metrics(text) {
+  const parsed = metrics_schema.safeParse(json_value.parse_or_undefined(text));
+  return parsed.success ? parsed.data : void 0;
+}
+function parse_approval(text) {
+  const parsed = approval_schema.safeParse(json_value.parse_or_undefined(text));
+  return parsed.success ? parsed.data : void 0;
+}
+function approval_text(approval) {
+  return `${JSON.stringify(approval, void 0, JSON_INDENT)}${NEWLINE}`;
+}
+function fresh_approvals(current, base) {
+  return [...current].filter(([name, text]) => base.get(name) !== text).flatMap(([, text]) => parse_approval(text) ?? []);
+}
+function ratcheted(metrics) {
+  return [
+    ["scripts.code_lines", metrics.scripts.code_lines],
+    ["scripts.comment_ratio", metrics.scripts.comment_ratio],
+    ["rules.lines", metrics.rules.lines],
+    ["guards", metrics.guards],
+    ["ai_cost.resident_bytes", metrics.ai_cost.resident_bytes],
+    ["ai_cost.on_demand_bytes", metrics.ai_cost.on_demand_bytes],
+    ["prose.long_paragraphs", metrics.prose.long_paragraphs],
+    ["prose.excess_bold", metrics.prose.excess_bold]
+  ];
+}
+function growth_between(base, current) {
+  return Math.round((current - base) * GROWTH_PRECISION) / GROWTH_PRECISION;
+}
+function approved_growth(approvals, name) {
+  return Math.max(0, ...approvals.map((approval) => approval.growth[name] ?? 0));
+}
+function changes(base, current, approvals) {
+  const before = new Map(ratcheted(base));
+  return ratcheted(current).map(([name, value]) => {
+    const base_value = before.get(name) ?? value;
+    const growth = growth_between(base_value, value);
+    return { name, base: base_value, current: value, growth };
+  }).filter((change) => change.growth !== 0).map((change) => ({ ...change, approved: approved_growth(approvals, change.name) }));
+}
+function settled_kind(changed, grown) {
+  if (grown > 0) return "approved";
+  return changed > 0 ? "shrank" : "unchanged";
+}
+function compare(base, current, approvals) {
+  const changed = changes(base, current, approvals);
+  const grown = changed.filter((change) => change.growth > 0);
+  const regressions = grown.filter((change) => change.growth > change.approved);
+  if (regressions.length > 0) return { kind: "regressed", regressions };
+  return { kind: settled_kind(changed.length, grown.length) };
+}
+function accept(base, current, reason, date) {
+  const grown = changes(base, current, []).filter((change) => change.growth > 0);
+  if (grown.length === 0) return void 0;
+  return {
+    reason,
+    date,
+    growth: Object.fromEntries(grown.map((change) => [change.name, change.growth]))
+  };
+}
+function own_approval(name, current, base) {
+  const text = current.get(name);
+  if (text === void 0 || base.get(name) === text) return void 0;
+  const approval = parse_approval(text);
+  return approval !== void 0 && approval.reason.trim().length > 0 ? approval : void 0;
+}
+function refresh(approval, base, current, date) {
+  const past = changes(base, current, [approval]).filter(
+    (change) => Object.hasOwn(approval.growth, change.name) && change.growth > change.approved
+  );
+  if (past.length === 0) return void 0;
+  const regrown = Object.fromEntries(past.map((change) => [change.name, change.growth]));
+  return { ...approval, date, growth: { ...approval.growth, ...regrown } };
+}
+function render_regression(change) {
+  const values = `merge-base ${String(change.base)} \u2192 current ${String(change.current)}`;
+  return `  ${change.name}  ${values} (+${String(change.growth)}, approved +${String(change.approved)})`;
+}
+function render_regressions(regressions, commit) {
+  return [
+    `josh metrics: ${String(regressions.length)} total(s) grew past the merge-base ${commit}:`,
+    ...regressions.map((change) => render_regression(change)),
+    'Bring them back down, or record the reason they grew: pnpm josh metrics --accept --reason "<why>"'
+  ].join(NEWLINE);
+}
+var metrics_ratchet = {
+  accept,
+  approval_text,
+  compare,
+  fresh_approvals,
+  own_approval,
+  parse_approval,
+  parse_metrics,
+  refresh,
+  render_regressions
+};
+
+// tools/metrics/metrics-base.ts
+import { dirname as __josh_dirname } from "node:path";
+import { fileURLToPath as __josh_file_path } from "node:url";
+import { existsSync, mkdirSync, readdirSync as readdirSync2, writeFileSync } from "node:fs";
+import path2 from "node:path";
+import { fileURLToPath } from "node:url";
+import { execa } from "execa";
+
+// tools/metrics/metrics-base-cache.ts
+import { readdirSync } from "node:fs";
+import path from "node:path";
+import { z as z2 } from "zod";
+var CACHE_PREFIX = "josh-metrics-base-";
+var KEY_SEPARATOR = "\n";
+var SOURCE_EXTENSION = ".ts";
+var TEST_MARKER = ".test.";
+var SOURCE_DIRECTORIES = ["scripts", "tools"];
+var COMMAND_SCRIPT = path.join("tools", "metrics", "metrics-command.ts");
+var approval_schema2 = z2.tuple([z2.string(), z2.string()]);
+var record_schema = z2.object({ stdout: z2.string(), approvals: z2.array(approval_schema2) });
+function sources_in(root, directory) {
+  try {
+    return readdirSync(path.join(root, directory), { recursive: true, encoding: "utf8" }).filter((name) => name.endsWith(SOURCE_EXTENSION) && !name.includes(TEST_MARKER)).map((name) => path.join(root, directory, name));
+  } catch {
+    return [];
+  }
+}
+function sorted(files) {
+  return [...files].toSorted((left, right) => left.localeCompare(right));
+}
+function ruler_files(root) {
+  const universe = SOURCE_DIRECTORIES.flatMap((directory) => sources_in(root, directory));
+  const forward = import_graph.build_forward(universe, root);
+  return sorted(import_graph.reachable(path.join(root, COMMAND_SCRIPT), forward));
+}
+function ruler_part(root, file) {
+  return `${path.relative(root, file)}${KEY_SEPARATOR}${file_reader.read_if_readable(file) ?? ""}`;
+}
+function ruler_digest(root) {
+  const parts = ruler_files(root).map((file) => ruler_part(root, file));
+  return stamp_file.digest([...parts, toolchain_inputs.digest(root)].join(KEY_SEPARATOR));
+}
+function cache_path(commit, root) {
+  return stamp_file.stamp_path(CACHE_PREFIX, `${commit}${KEY_SEPARATOR}${ruler_digest(root)}`);
+}
+function read(commit, root) {
+  const text = stamp_file.read_stamp_text(cache_path(commit, root));
+  return text === void 0 ? void 0 : record_schema.safeParse(json_value.parse_or_undefined(text)).data;
+}
+function write(commit, root, reading) {
+  try {
+    stamp_file.replace_stamp(cache_path(commit, root), reading);
+  } catch {
+  }
+}
+var metrics_base_cache = { cache_path, read, ruler_files, write };
+
+// tools/metrics/metrics-base.ts
+var __josh_meta = import.meta;
+var __josh_source_url = new URL("../../tools/metrics/metrics-base.ts", __josh_meta.url).href;
+var __josh_source_filename = __josh_file_path(__josh_source_url);
+var __josh_source_dirname = __josh_dirname(__josh_source_filename);
+var BASE_VARIABLE = "JOSH_METRICS_BASE";
+var COMMIT_PEEL = "^{commit}";
+var { APPROVAL_DIRECTORY } = release_approval_prune;
+var APPROVAL_EXTENSION = ".json";
+var TREE_PREFIX = "josh-metrics-base-";
+var JSON_FLAG = "--json";
+var COMMAND_SCRIPT2 = fileURLToPath(new URL("metrics-command.ts", __josh_source_url));
+var RULER_ROOT = fileURLToPath(new URL("../..", __josh_source_url));
+async function resolve_commit() {
+  const named = process.env[BASE_VARIABLE] ?? "";
+  if (named.length === 0) return await change_base.resolved_through_merge();
+  try {
+    return await git_spawn.read(["rev-parse", "--verify", `${named}${COMMIT_PEEL}`]);
+  } catch {
+    throw new Error(`josh metrics: ${BASE_VARIABLE}=${named} names no commit in this checkout`);
+  }
+}
+function approval_texts(root) {
+  const directory = path2.join(root, APPROVAL_DIRECTORY);
+  if (!existsSync(directory)) return /* @__PURE__ */ new Map();
+  return new Map(
+    readdirSync2(directory).flatMap((name) => {
+      const text = file_reader.read_if_readable(path2.join(directory, name));
+      return text === void 0 ? [] : [[name, text]];
+    })
+  );
+}
+function approval_name(issue) {
+  return `${String(issue)}${APPROVAL_EXTENSION}`;
+}
+function write_approval(root, issue, approval) {
+  const file = path2.join(APPROVAL_DIRECTORY, approval_name(issue));
+  mkdirSync(path2.join(root, APPROVAL_DIRECTORY), { recursive: true });
+  writeFileSync(path2.join(root, file), metrics_ratchet.approval_text(approval));
+  return file;
+}
+async function is_at(commit) {
+  const head = await git_spawn.read(["rev-parse", "HEAD"]);
+  const status = await git_command.status();
+  return head === commit && status.trim().length === 0;
+}
+async function measure_in(tree) {
+  const runner = resolve_tsx_runner();
+  const { stdout } = await execa(
+    runner.executable,
+    [...runner.leading_arguments, COMMAND_SCRIPT2, JSON_FLAG],
+    { cwd: tree, env: git_location_environment.location_free_environment(), extendEnv: true }
+  );
+  return stdout;
+}
+async function measure_base(commit) {
+  return await base_tree.with_tree(TREE_PREFIX, commit, async ({ tree }) => ({
+    stdout: await measure_in(tree),
+    approvals: [...approval_texts(tree)]
+  }));
+}
+function reading_of(cached) {
+  const metrics = metrics_ratchet.parse_metrics(cached.stdout);
+  return metrics === void 0 ? void 0 : { metrics, approvals: new Map(cached.approvals) };
+}
+function cached_reading(commit) {
+  const cached = metrics_base_cache.read(commit, RULER_ROOT);
+  return cached === void 0 ? void 0 : reading_of(cached);
+}
+async function read2(commit, current) {
+  if (await is_at(commit)) return current;
+  const hit = cached_reading(commit);
+  if (hit !== void 0) return hit;
+  const measured = await measure_base(commit);
+  const reading = reading_of(measured);
+  if (reading === void 0) throw new Error("josh metrics: the merge-base printed no totals");
+  metrics_base_cache.write(commit, RULER_ROOT, measured);
+  return reading;
+}
+var metrics_base = {
+  APPROVAL_DIRECTORY,
+  BASE_VARIABLE,
+  JSON_FLAG,
+  approval_name,
+  approval_texts,
+  read: read2,
+  resolve_commit,
+  write_approval
+};
+
+export {
+  metrics_ratchet,
+  metrics_base
+};

package/dist/commands/chunk-R36VZIKU.js

@@ -0,0 +1,53 @@
+import {
+  observation_ledger
+} from "./chunk-SV4FZR24.js";
+import {
+  input_fingerprint
+} from "./chunk-GA2YSPFH.js";
+import {
+  changed_paths
+} from "./chunk-U5EO4QEV.js";
+import {
+  change_base
+} from "./chunk-LBVYFW3I.js";
+import {
+  git_command
+} from "./chunk-IXZZSST7.js";
+
+// scripts/review/review-tree.ts
+var ABSENT_DIGEST = input_fingerprint.ABSENT;
+function tree_of(root, paths) {
+  return input_fingerprint.of_files(
+    root,
+    paths.filter((relative) => !observation_ledger.is_ledger_path(relative))
+  );
+}
+async function read_changed_tree(paths, root) {
+  return tree_of(
+    root ?? await git_command.repository_root(),
+    paths ?? await changed_paths.read_changed_paths(false)
+  );
+}
+var review_tree = { ABSENT_DIGEST, read_changed_tree, tree_of };
+
+// scripts/gate/gate-tree.ts
+async function read_changed_files() {
+  try {
+    return await review_tree.read_changed_tree();
+  } catch {
+    return {};
+  }
+}
+async function read_base() {
+  return await change_base.resolved_through_merge();
+}
+async function read_gate_tree() {
+  const [files, base] = await Promise.all([read_changed_files(), read_base()]);
+  return { files, base };
+}
+var gate_tree = { read_gate_tree };
+
+export {
+  review_tree,
+  gate_tree
+};

package/dist/commands/chunk-R3F7F3TX.js

@@ -0,0 +1,94 @@
+import {
+  lane_stage_stats
+} from "./chunk-J4XHEOOW.js";
+import {
+  lane_stats
+} from "./chunk-2XLR7R6E.js";
+import {
+  lane_ledger
+} from "./chunk-2O64H5UJ.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
+};