@joshuafolkken/kit 1.2116.0 → 1.3041.0

package/dist/commands/metrics-command.js

@@ -0,0 +1,892 @@
+#!/usr/bin/env tsx
+import {
+  metrics_base,
+  metrics_ratchet
+} from "./chunk-QJRVDE7T.js";
+import {
+  session_language_cli
+} from "./chunk-Z3WGHIVB.js";
+import "./chunk-T4UYEHWG.js";
+import "./chunk-2EZTYLO4.js";
+import "./chunk-PFO7EYAP.js";
+import "./chunk-NU7W6QGT.js";
+import "./chunk-DEZF7QZZ.js";
+import "./chunk-DXJQHJQ4.js";
+import {
+  lane_load,
+  lane_sampler,
+  lane_stats
+} from "./chunk-XXC32PVL.js";
+import "./chunk-IB5TT73I.js";
+import {
+  lane_ledger
+} from "./chunk-ZNR75OXP.js";
+import "./chunk-I2KCGKJI.js";
+import "./chunk-E33LSO2W.js";
+import "./chunk-Y2RNUX4W.js";
+import "./chunk-EDKOSZ3K.js";
+import "./chunk-7C7FOKJK.js";
+import "./chunk-2BC33QPY.js";
+import "./chunk-CVJHQOI3.js";
+import "./chunk-CBAKBWSZ.js";
+import "./chunk-DPJVKTO4.js";
+import "./chunk-C54QXJD6.js";
+import "./chunk-FCINBCKB.js";
+import {
+  git_branch
+} from "./chunk-Q5Q2QYVU.js";
+import "./chunk-GO3GH7FG.js";
+import "./chunk-KVHNQHX3.js";
+import {
+  test_declared_logic
+} from "./chunk-7HCPRVMB.js";
+import "./chunk-RSSJWMQS.js";
+import "./chunk-HQGNXR6I.js";
+import "./chunk-KXK2A2HB.js";
+import "./chunk-Y4EBUI6M.js";
+import "./chunk-OIX2363L.js";
+import "./chunk-S4M6UWR2.js";
+import "./chunk-FVDQNMP6.js";
+import "./chunk-RN2YDNLF.js";
+import "./chunk-RW64VHEB.js";
+import "./chunk-6UCWAFQY.js";
+import "./chunk-DYZOOWVW.js";
+import "./chunk-6I2JM5UX.js";
+import "./chunk-BYSPYVLD.js";
+import "./chunk-NDWZTWXV.js";
+import "./chunk-3WWQFCGX.js";
+import "./chunk-LAYSCY4L.js";
+import "./chunk-N7QTMTST.js";
+import "./chunk-7HAGC6SW.js";
+import "./chunk-6CJXLPRI.js";
+import "./chunk-OJ65BZBV.js";
+import "./chunk-LHKXJD6L.js";
+import "./chunk-WVR4RUFP.js";
+import "./chunk-ROJXMBXP.js";
+import "./chunk-DBKTFB5V.js";
+import "./chunk-RLBFEHHC.js";
+import "./chunk-LQXFVZTS.js";
+import "./chunk-EMTZAGT5.js";
+import "./chunk-TCBUX52E.js";
+import "./chunk-KXHXMERX.js";
+import "./chunk-MDLOETXL.js";
+import "./chunk-NFKULY26.js";
+import "./chunk-JTU5A4JI.js";
+import "./chunk-65E4OZJ7.js";
+import "./chunk-452HWOJ7.js";
+import "./chunk-BYFC6MD2.js";
+import "./chunk-3AEDZZNL.js";
+import "./chunk-LULJUD6P.js";
+import "./chunk-TBNQIFWL.js";
+import "./chunk-XFPEUYDV.js";
+import "./chunk-5ZTQX7OS.js";
+import "./chunk-G4E4M2P4.js";
+import "./chunk-C2SEDMZ3.js";
+import "./chunk-ENKFCOVY.js";
+import "./chunk-6OP63TBT.js";
+import "./chunk-TVZXG4Y4.js";
+import "./chunk-FIUCHMCF.js";
+import "./chunk-4PUKDAXL.js";
+import "./chunk-W3FX7FYN.js";
+import "./chunk-ZBFNQUY7.js";
+import "./chunk-X3TNPALI.js";
+import "./chunk-XXNEY4B3.js";
+import "./chunk-EWVR5AEX.js";
+import "./chunk-C6QSVO5K.js";
+import "./chunk-U3IVVR4W.js";
+import "./chunk-5RG4S66L.js";
+import "./chunk-O3NDWYNT.js";
+import "./chunk-OKZWEVR4.js";
+import "./chunk-NSAVEXVR.js";
+import "./chunk-ZZXO6TFH.js";
+import "./chunk-34DND4BA.js";
+import "./chunk-P4KIQRSL.js";
+import "./chunk-QQBMVC5W.js";
+import "./chunk-TUIFS5E7.js";
+import "./chunk-QAHFPCFR.js";
+import "./chunk-66TGK5XL.js";
+import "./chunk-EZSO25UZ.js";
+import "./chunk-2DJLAUYB.js";
+import "./chunk-EW4NPUMQ.js";
+import "./chunk-BF6YX4HE.js";
+import "./chunk-3LZXX5GL.js";
+import "./chunk-W2IA2LV3.js";
+import "./chunk-OHNP3QL2.js";
+import "./chunk-22DVQCP6.js";
+import "./chunk-MDKDJF2K.js";
+import "./chunk-HQ2HSZBN.js";
+import "./chunk-WQ6FS544.js";
+import "./chunk-6HRRZANN.js";
+import "./chunk-I63RNFFR.js";
+import {
+  run_carry
+} from "./chunk-MPGJ4ONJ.js";
+import "./chunk-6WKJ3GDA.js";
+import {
+  lane_paths
+} from "./chunk-YIA6FC3K.js";
+import "./chunk-JQXPLMCO.js";
+import "./chunk-66NX6EXR.js";
+import "./chunk-3NWAGIA6.js";
+import "./chunk-2FE3C4PH.js";
+import "./chunk-HLUS2M3D.js";
+import "./chunk-SBGTCT2C.js";
+import "./chunk-AKK56GNX.js";
+import "./chunk-TBIX5FRN.js";
+import "./chunk-IGD6QJPH.js";
+import {
+  git_common_directory
+} from "./chunk-FFHEGWPK.js";
+import "./chunk-R6QE5VJG.js";
+import "./chunk-4ZHWTTQW.js";
+import "./chunk-RDRN56E4.js";
+import "./chunk-XDF25GSU.js";
+import "./chunk-EBVS2LKX.js";
+import "./chunk-AQ3PMSXK.js";
+import "./chunk-QVOFWFWC.js";
+import "./chunk-G6BXCWPH.js";
+import "./chunk-CDY4NFQG.js";
+import "./chunk-OKYFQJW3.js";
+import "./chunk-HHBC6QZE.js";
+import {
+  effective_limit,
+  line_budget
+} from "./chunk-KKIMVXAP.js";
+import {
+  stamp_file
+} from "./chunk-QWWTC3XR.js";
+import "./chunk-ILGPZ47M.js";
+import "./chunk-3CCGKX7Y.js";
+import "./chunk-KSR23NYN.js";
+import "./chunk-JZOTCPX2.js";
+import "./chunk-LR22UK5W.js";
+import "./chunk-V5FD7DVV.js";
+import "./chunk-36LOGVJ7.js";
+import "./chunk-ENFPR7J2.js";
+import {
+  line_targets
+} from "./chunk-OT3UMEWK.js";
+import "./chunk-SVV4U5AR.js";
+import "./chunk-UGCUSRZF.js";
+import {
+  git_command
+} from "./chunk-AKQYYHP2.js";
+import "./chunk-CJKPF5DJ.js";
+import "./chunk-RBU2NKHF.js";
+import "./chunk-WB4T3VY2.js";
+import "./chunk-B77ZMVHS.js";
+import "./chunk-B5GXZK3E.js";
+import "./chunk-KTLR4Y32.js";
+import {
+  file_reader
+} from "./chunk-ZNX2LJCQ.js";
+import "./chunk-VJE3RJAX.js";
+import {
+  MS_PER_SECOND,
+  PROBE_TIMEOUT_MS
+} from "./chunk-WPAQUMHC.js";
+import {
+  json_value
+} from "./chunk-HIU2WXB6.js";
+
+// tools/metrics/metrics-command.ts
+import { dirname as __josh_dirname2 } from "node:path";
+import { fileURLToPath as __josh_file_path2 } from "node:url";
+import { existsSync as existsSync2, readdirSync, readFileSync } from "node:fs";
+import path2 from "node:path";
+import { fileURLToPath as fileURLToPath2, pathToFileURL } from "node:url";
+
+// tools/claude/skill-meta.ts
+var SKILL_ROOT = ".claude/skills";
+var SKILL_ENTRY_FILE = "SKILL.md";
+var FRONTMATTER_PATTERN = /^---\n([\S\s]*?)\n---\n/u;
+var DESCRIPTION_PATTERN = /^description: (.+)$/mu;
+function has_frontmatter(content) {
+  return FRONTMATTER_PATTERN.test(content);
+}
+function frontmatter_of(content) {
+  return FRONTMATTER_PATTERN.exec(content)?.[1] ?? "";
+}
+function description_of(content) {
+  return DESCRIPTION_PATTERN.exec(frontmatter_of(content))?.[1] ?? "";
+}
+var skill_meta = {
+  SKILL_ROOT,
+  SKILL_ENTRY_FILE,
+  has_frontmatter,
+  frontmatter_of,
+  description_of
+};
+
+// tools/metrics/metrics-command.ts
+import { tsImport } from "tsx/esm/api";
+import { z as z2 } from "zod";
+
+// tools/metrics/metrics-code-lines.ts
+import { dirname as __josh_dirname } from "node:path";
+import { fileURLToPath as __josh_file_path } from "node:url";
+import { fileURLToPath } from "node:url";
+import { ESLint } from "eslint";
+var __josh_meta = import.meta;
+var __josh_source_url = new URL("../../tools/metrics/metrics-code-lines.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 UNTYPED_PARSE = {
+  languageOptions: { parserOptions: { project: false, projectService: false } }
+};
+var MAX_LINES_RULE = "max-lines";
+var CACHE_PREFIX = "josh-metrics-eslint-cache-";
+var CONFIG_FILE = fileURLToPath(new URL("../../eslint.config.js", __josh_source_url));
+function is_max_lines(rule) {
+  return rule.ruleId === MAX_LINES_RULE;
+}
+async function group_counts(root, group) {
+  const eslint = new ESLint({
+    cwd: root,
+    overrideConfigFile: CONFIG_FILE,
+    cacheLocation: stamp_file.stamp_path(CACHE_PREFIX, root),
+    allowInlineConfig: false,
+    ruleFilter: is_max_lines,
+    overrideConfig: { ...UNTYPED_PARSE, rules: line_budget.probe_rules(group.options) }
+  });
+  return line_budget.counts_from(await eslint.lintFiles(group.paths));
+}
+function unread_config(file_count, root) {
+  return new Error(
+    `josh metrics: eslint set no max-lines on any of the ${String(file_count)} script files in ${root} \u2014 ${CONFIG_FILE} did not load, so the tree has no total to compare. Run \`pnpm josh lint\` to see why it fails to load, and fix that first.`
+  );
+}
+async function code_line_counts(file_paths, root) {
+  const options = await effective_limit.options_for(file_paths, root, CONFIG_FILE);
+  if (file_paths.length > 0 && options.size === 0) throw unread_config(file_paths.length, root);
+  const groups = [...line_budget.grouped(options).values()];
+  const counted = await Promise.all(groups.map(async (group) => await group_counts(root, group)));
+  return new Map(counted.flatMap((counts) => [...counts]));
+}
+var metrics_code_lines = { code_line_counts };
+
+// tools/metrics/metrics-duration-probe.ts
+import { spawnSync } from "node:child_process";
+import { copyFileSync, existsSync, mkdirSync, renameSync, writeFileSync } from "node:fs";
+import { availableParallelism } from "node:os";
+import path from "node:path";
+
+// tools/metrics/metrics-durations.ts
+import { z } from "zod";
+var TOLERANCE_PERCENT = 10;
+var PERCENT = 100;
+var RECENT_GATES = 5;
+var HALVES = 2;
+var TRAILING_GATES = Math.floor(RECENT_GATES / HALVES) + 1;
+var SECONDS_DIGITS = 1;
+var NEWLINE = "\n";
+var JSON_INDENT = "	";
+var MISSING = "\u2014";
+var SEPARATOR = " \xB7 ";
+var RECORDED_NAMES = ["gate", "unit"];
+var DURATION_NAMES = [...RECORDED_NAMES, "josh_startup", "guard_startup"];
+var RECORDED = new Set(RECORDED_NAMES);
+var baseline_schema = z.record(z.string(), z.number());
+function present(durations) {
+  return DURATION_NAMES.flatMap((name) => {
+    const value = durations[name];
+    return value === void 0 ? [] : [[name, value]];
+  });
+}
+function overlay(base, top) {
+  return { ...base, ...Object.fromEntries(present(top)) };
+}
+function parse_baseline(text) {
+  const parsed = baseline_schema.safeParse(json_value.parse_or_undefined(text));
+  return parsed.success ? Object.fromEntries(present(parsed.data)) : {};
+}
+function is_regression(change) {
+  return change.current * PERCENT > change.baseline * (PERCENT + TOLERANCE_PERCENT);
+}
+function compare(baseline, current) {
+  const changes = present(current).map(([name, value]) => ({
+    name,
+    baseline: baseline[name] ?? value,
+    current: value
+  }));
+  return {
+    regressions: changes.filter((change) => is_regression(change)),
+    baseline: { ...current, ...baseline },
+    is_extended: present(current).some(([name]) => baseline[name] === void 0)
+  };
+}
+function gate_span(entry) {
+  const end_ms = Date.parse(entry.at);
+  return { entry, start_ms: end_ms - entry.elapsed_ms, end_ms };
+}
+function gate_spans(entries) {
+  return entries.filter((entry) => entry.kind === "gate").map((entry) => gate_span(entry));
+}
+function is_overlapped(span, other) {
+  return other !== span && other.start_ms < span.end_ms && span.start_ms < other.end_ms;
+}
+function is_quiet(entry) {
+  return entry.external_cores === 0;
+}
+function is_solo(span, spans) {
+  return is_quiet(span.entry) && spans.every((other) => !is_overlapped(span, other));
+}
+function sample(span, spans) {
+  const { elapsed_ms, unit_ms } = span.entry;
+  if (unit_ms === void 0) return [];
+  const { start_ms, end_ms } = span;
+  return is_solo(span, spans) ? [{ elapsed_ms, unit_ms, start_ms, end_ms }] : [];
+}
+function recent_samples(entries) {
+  const spans = gate_spans(entries);
+  return spans.flatMap((span) => sample(span, spans)).slice(-RECENT_GATES);
+}
+function windows(entries) {
+  const gates = recent_samples(entries);
+  if (gates.length < RECENT_GATES) return [];
+  return gates.map(({ start_ms, end_ms }) => ({ start_ms, end_ms }));
+}
+function is_recorded(change) {
+  return RECORDED.has(change.name);
+}
+function from_ledger(entries) {
+  const gates = recent_samples(entries);
+  if (gates.length < RECENT_GATES) return { gate: void 0, unit: void 0 };
+  return {
+    gate: lane_stats.median(gates.map((entry) => entry.elapsed_ms)),
+    unit: lane_stats.median(gates.map((entry) => entry.unit_ms))
+  };
+}
+function format(value) {
+  if (value === void 0) return MISSING;
+  if (value < MS_PER_SECOND) return `${String(Math.round(value))}ms`;
+  return `${(value / MS_PER_SECOND).toFixed(SECONDS_DIGITS)}s`;
+}
+function render(durations, is_startup_timed) {
+  const names = is_startup_timed ? DURATION_NAMES : RECORDED_NAMES;
+  const cells = names.map((name) => `${name} ${format(durations[name])}`);
+  return `durations  ${cells.join(SEPARATOR)}`;
+}
+function render_regressions(regressions, baseline_path2) {
+  const over = `more than ${String(TOLERANCE_PERCENT)}% over the baseline`;
+  return [
+    `josh metrics: ${String(regressions.length)} duration(s) ${over} in ${baseline_path2}:`,
+    ...regressions.map(
+      (change) => `  ${change.name}  baseline ${format(change.baseline)} \u2192 current ${format(change.current)}`
+    ),
+    `gate and unit trail a fix by up to ${String(TRAILING_GATES)} gates (the median of the last ${String(RECENT_GATES)} solo ones) \u2014 rerun the gate before accepting them.`,
+    'Find what slowed it, or record the current durations: pnpm josh metrics --accept --reason "<why>"'
+  ].join(NEWLINE);
+}
+function baseline_text(durations) {
+  const rounded = present(durations).map(([name, value]) => [name, Math.round(value)]);
+  return `${JSON.stringify(Object.fromEntries(rounded), void 0, JSON_INDENT)}${NEWLINE}`;
+}
+var metrics_durations = {
+  baseline_text,
+  compare,
+  from_ledger,
+  overlay,
+  parse_baseline,
+  render,
+  is_recorded,
+  render_regressions,
+  windows
+};
+
+// tools/metrics/metrics-duration-load.ts
+var OWN_LANES = 1;
+var HALF = 2;
+var NEWLINE2 = "\n";
+function is_loaded(entry, cores, own_lanes = OWN_LANES) {
+  return (entry.lanes ?? 0) > own_lanes || entry.load > cores;
+}
+function is_startup_loaded(entry, cores, is_in_lane) {
+  return is_loaded(entry, cores, is_in_lane ? OWN_LANES : 0);
+}
+function is_inside(entry, window) {
+  const at_ms = Date.parse(entry.at);
+  const reach_ms = lane_sampler.SAMPLE_INTERVAL_MS;
+  return at_ms >= window.start_ms - reach_ms && at_ms <= window.end_ms + reach_ms;
+}
+function is_busy_window(entries, window, cores) {
+  return entries.some(
+    (entry) => entry.kind === "load" && is_loaded(entry, cores) && is_inside(entry, window)
+  );
+}
+function is_busy(entries, cores) {
+  const windows2 = metrics_durations.windows(entries);
+  const busy = windows2.filter((window) => is_busy_window(entries, window, cores));
+  return busy.length > windows2.length / HALF;
+}
+function is_excused(change, reading) {
+  return metrics_durations.is_recorded(change) ? reading.is_busy : reading.is_startup_busy;
+}
+function split(regressions, reading) {
+  const warned = regressions.filter((change) => is_excused(change, reading));
+  return { warned, failed: regressions.filter((change) => !warned.includes(change)) };
+}
+function render_warning(regressions, baseline_path2) {
+  return [
+    "josh metrics: warning \u2014 another lane worked, or the load average passed the cores, while these were measured, so they do not fail the gate:",
+    metrics_durations.render_regressions(regressions, baseline_path2)
+  ].join(NEWLINE2);
+}
+var metrics_duration_load = {
+  is_busy,
+  is_startup_loaded,
+  render_warning,
+  split
+};
+
+// tools/metrics/metrics-duration-probe.ts
+var SAMPLES = 5;
+var BASELINE_FILE = "metrics-durations.json";
+var LEGACY_BASELINE_FILE = "josh-metrics-durations.json";
+var JOSH_COMMAND = [
+  "node",
+  "--disable-warning=ExperimentalWarning",
+  "tools/josh/josh-ready.ts",
+  "--help"
+];
+var GUARD_COMMAND = ["sh", "scripts/hooks/run-hook.sh", "pretool-guard"];
+var HOOK_INPUT = "{}";
+var FAILURE_EXIT_CODE = 1;
+function is_timed_out(result) {
+  const { error } = result;
+  return error !== void 0 && "code" in error && error.code === "ETIMEDOUT";
+}
+function time_once(command, root) {
+  const [program = "", ...args] = command;
+  const started_at = performance.now();
+  const result = spawnSync(program, args, {
+    cwd: root,
+    input: HOOK_INPUT,
+    stdio: ["pipe", "ignore", "ignore"],
+    timeout: PROBE_TIMEOUT_MS
+  });
+  const elapsed_ms = performance.now() - started_at;
+  if (is_timed_out(result)) return Math.max(elapsed_ms, PROBE_TIMEOUT_MS);
+  return result.status === 0 ? elapsed_ms : void 0;
+}
+function fastest(command, root) {
+  const timings = Array.from({ length: SAMPLES }, () => time_once(command, root));
+  return timings.includes(void 0) ? void 0 : Math.min(...timings.map(Number));
+}
+function time_startups(root) {
+  return { josh_startup: fastest(JOSH_COMMAND, root), guard_startup: fastest(GUARD_COMMAND, root) };
+}
+async function read_ledger() {
+  const ledger = await lane_ledger.target();
+  return ledger === void 0 ? [] : lane_ledger.read_entries(ledger);
+}
+async function measure(root, is_startup_timed) {
+  const entries = await read_ledger();
+  const recorded = metrics_durations.from_ledger(entries);
+  const cores = availableParallelism();
+  const is_busy2 = metrics_duration_load.is_busy(entries, cores);
+  if (!is_startup_timed) return { durations: recorded, is_busy: is_busy2, is_startup_busy: false };
+  const startups = time_startups(root);
+  const load = await lane_load.sample((/* @__PURE__ */ new Date()).toISOString());
+  const is_in_lane = lane_paths.issue_here(root) !== void 0;
+  const is_startup_busy = metrics_duration_load.is_startup_loaded(load, cores, is_in_lane);
+  return { durations: { ...recorded, ...startups }, is_busy: is_busy2, is_startup_busy };
+}
+function copy_if_present(source, target) {
+  try {
+    copyFileSync(source, target);
+  } catch (error) {
+    if (!file_reader.is_absent(error)) throw error;
+  }
+}
+function adopt_legacy_baseline(repository, file) {
+  const legacy = path.join(repository, LEGACY_BASELINE_FILE);
+  if (existsSync(file) || !existsSync(legacy)) return;
+  mkdirSync(path.dirname(file), { recursive: true });
+  try {
+    renameSync(legacy, file);
+  } catch {
+    copy_if_present(legacy, file);
+  }
+}
+async function baseline_path() {
+  const repository = await run_carry.repository_directory();
+  if (repository === void 0) return void 0;
+  const file = path.join(repository, git_common_directory.STATE_DIRECTORY, BASELINE_FILE);
+  adopt_legacy_baseline(repository, file);
+  return file;
+}
+function read_baseline(file) {
+  const text = file_reader.read_if_readable(file);
+  return text === void 0 ? {} : metrics_durations.parse_baseline(text);
+}
+function write_baseline(file, durations) {
+  mkdirSync(path.dirname(file), { recursive: true });
+  writeFileSync(file, metrics_durations.baseline_text(durations));
+}
+function accept(file, durations) {
+  write_baseline(file, metrics_durations.overlay(read_baseline(file), durations));
+}
+function report_regressions(verdict, file, reading) {
+  const { warned, failed } = metrics_duration_load.split(verdict.regressions, reading);
+  if (warned.length > 0) {
+    process.stderr.write(`${metrics_duration_load.render_warning(warned, file)}
+`);
+  }
+  if (failed.length === 0) return 0;
+  process.stderr.write(`${metrics_durations.render_regressions(failed, file)}
+`);
+  return FAILURE_EXIT_CODE;
+}
+function check(file, measurement) {
+  const verdict = metrics_durations.compare(read_baseline(file), measurement.durations);
+  if (verdict.regressions.length > 0) return report_regressions(verdict, file, measurement);
+  if (verdict.is_extended) write_baseline(file, verdict.baseline);
+  return 0;
+}
+var metrics_duration_probe = {
+  accept,
+  baseline_path,
+  check,
+  measure
+};
+
+// tools/metrics/metrics-logic.ts
+var SOURCE_PREFIXES = ["scripts/", "tools/"];
+var GUARD_SUFFIX = ":guard";
+var NEWLINE3 = "\n";
+var RATIO_DIGITS = 2;
+var ENCODING = "utf8";
+var PER_TURN_HOOK_TEXT = session_language_cli.format_line({
+  lang: session_language_cli.DEFAULT_SESSION_LANG,
+  is_default: true
+});
+function is_measured_script(relative_path) {
+  if (SOURCE_PREFIXES.every((prefix) => !relative_path.startsWith(prefix))) return false;
+  return !test_declared_logic.is_test_file(relative_path);
+}
+function non_blank_lines(text) {
+  return text.split(NEWLINE3).filter((line) => line.trim().length > 0).length;
+}
+function physical_lines(text) {
+  if (text.length === 0) return 0;
+  const lines = text.split(NEWLINE3).length;
+  return text.endsWith(NEWLINE3) ? lines - 1 : lines;
+}
+function comment_ratio(comment_lines, code_lines) {
+  if (code_lines === 0) return 0;
+  return Number((comment_lines / code_lines).toFixed(RATIO_DIGITS));
+}
+function script_totals(files) {
+  const code_lines = files.reduce((sum, file) => sum + file.code_lines, 0);
+  const non_blank = files.reduce((sum, file) => sum + non_blank_lines(file.text), 0);
+  const comment_lines = non_blank - code_lines;
+  return {
+    files: files.length,
+    code_lines,
+    comment_lines,
+    comment_ratio: comment_ratio(comment_lines, code_lines)
+  };
+}
+function rule_totals(texts) {
+  return {
+    files: texts.length,
+    lines: texts.reduce((sum, text) => sum + physical_lines(text), 0)
+  };
+}
+function guard_count(command_names2) {
+  return command_names2.filter((name) => name.endsWith(GUARD_SUFFIX)).length;
+}
+function byte_total(texts) {
+  return texts.reduce((sum, text) => sum + Buffer.byteLength(text, ENCODING), 0);
+}
+function ai_cost_totals(resident, on_demand) {
+  return {
+    resident_bytes: byte_total([...resident, PER_TURN_HOOK_TEXT]),
+    on_demand_bytes: byte_total(on_demand)
+  };
+}
+function render2(metrics) {
+  const { scripts, rules, ai_cost: ai_cost2, prose: prose2 } = metrics;
+  return [
+    `scripts  ${String(scripts.files)} files \xB7 ${String(scripts.code_lines)} code lines \xB7 ${String(scripts.comment_lines)} comment lines \xB7 comment ratio ${scripts.comment_ratio.toFixed(RATIO_DIGITS)}`,
+    `rules    ${String(rules.files)} files \xB7 ${String(rules.lines)} lines`,
+    `guards   ${String(metrics.guards)}`,
+    `ai cost  ${String(ai_cost2.resident_bytes)} resident bytes \xB7 ${String(ai_cost2.on_demand_bytes)} on-demand bytes`,
+    `prose    ${String(prose2.long_paragraphs)} long paragraphs \xB7 ${String(prose2.excess_bold)} excess bold spans`
+  ].join(NEWLINE3);
+}
+var metrics_logic = {
+  ai_cost_totals,
+  guard_count,
+  is_measured_script,
+  physical_lines,
+  render: render2,
+  rule_totals,
+  script_totals
+};
+
+// tools/metrics/prose-density.ts
+var NEWLINE4 = "\n";
+var PARAGRAPH_JOINER = " ";
+var LONG_PARAGRAPH_CHARACTERS = 400;
+var BOLD_ALLOWANCE = 1;
+var FENCE = /^\s*(?:```|~~~)/u;
+var HEADING = /^#{1,6}\s/u;
+var TABLE_ROW = /^\s*\|/u;
+var LIST_ITEM = /^\s*(?:[-*+]|\d+\.)\s/u;
+var BOLD_SPAN = /\*\*[^*\n]+\*\*/gu;
+function unfenced_lines(text) {
+  let is_fenced = false;
+  return text.split(NEWLINE4).map((line) => {
+    if (FENCE.test(line)) is_fenced = !is_fenced;
+    return is_fenced || FENCE.test(line) ? "" : line;
+  });
+}
+function is_break(line) {
+  return line.trim().length === 0 || HEADING.test(line) || TABLE_ROW.test(line);
+}
+function starts_paragraph(line) {
+  return is_break(line) || LIST_ITEM.test(line);
+}
+function add_line(paragraphs, line) {
+  if (starts_paragraph(line)) paragraphs.push([]);
+  if (!is_break(line)) paragraphs.at(-1)?.push(line.trim());
+}
+function paragraph_lengths(lines) {
+  const paragraphs = [[]];
+  for (const line of lines) add_line(paragraphs, line);
+  return paragraphs.map((paragraph) => paragraph.join(PARAGRAPH_JOINER).length);
+}
+function bold_count(line) {
+  return line.match(BOLD_SPAN)?.length ?? 0;
+}
+function section_bold_counts(lines) {
+  const counts = [0];
+  for (const line of lines) {
+    if (HEADING.test(line)) counts.push(0);
+    counts.push((counts.pop() ?? 0) + bold_count(line));
+  }
+  return counts;
+}
+function measure2(text) {
+  const lines = unfenced_lines(text);
+  const long = paragraph_lengths(lines).filter((length) => length > LONG_PARAGRAPH_CHARACTERS);
+  const excess = section_bold_counts(lines).map((count) => Math.max(0, count - BOLD_ALLOWANCE));
+  return {
+    long_paragraphs: long.length,
+    excess_bold: excess.reduce((sum, count) => sum + count, 0)
+  };
+}
+function totals(texts) {
+  const measured = texts.map((text) => measure2(text));
+  return {
+    long_paragraphs: measured.reduce((sum, one) => sum + one.long_paragraphs, 0),
+    excess_bold: measured.reduce((sum, one) => sum + one.excess_bold, 0)
+  };
+}
+var prose_density = {
+  LONG_PARAGRAPH_CHARACTERS,
+  measure: measure2,
+  totals
+};
+
+// tools/metrics/metrics-command.ts
+var __josh_meta2 = import.meta;
+var __josh_source_url2 = new URL("../../tools/metrics/metrics-command.ts", __josh_meta2.url).href;
+var __josh_source_filename2 = __josh_file_path2(__josh_source_url2);
+var __josh_source_dirname2 = __josh_dirname2(__josh_source_filename2);
+var ARGV_OFFSET = 2;
+var USAGE = 'Usage: josh metrics [--no-startup | --totals-only [--rerecord] | --accept --reason "<why>"]';
+var ACCEPT_FLAG = "--accept";
+var REASON_FLAG = "--reason";
+var ACCEPT_ARGUMENT_COUNT = 3;
+var FAILURE_EXIT_CODE2 = 1;
+var COMMAND_MAP_FILE = "scripts/josh/josh-command-map.ts";
+var command_map_schema = z2.object({ COMMAND_MAP: z2.record(z2.string(), z2.unknown()) });
+var RESIDENT_RULES = "CLAUDE.md";
+var RESIDENT_DOCUMENTS = [RESIDENT_RULES, "AGENTS.md", "GEMINI.md"];
+var RULES_DIR = "prompts";
+var PROSE_DOCUMENT = "README.md";
+var PROSE_DIRS = ["docs", RULES_DIR, skill_meta.SKILL_ROOT];
+var MARKDOWN_EXTENSION = ".md";
+var ENCODING2 = "utf8";
+var DATE_LENGTH = 10;
+var NOT_GROWN = "josh metrics: no total grew past the merge-base";
+var SETTLED_LINE = {
+  approved: "josh metrics: every total that grew is within the approval this branch recorded",
+  shrank: `${NOT_GROWN} \u2014 a total shrank, and the next branch is measured from it`,
+  unchanged: NOT_GROWN
+};
+var CHECK_FORMS = /* @__PURE__ */ new Map([
+  ["", { reason: void 0, is_startup_timed: true, form: "full" }],
+  ["--no-startup", { reason: void 0, is_startup_timed: false, form: "full" }],
+  ["--totals-only", { reason: void 0, is_startup_timed: false, form: "totals" }],
+  ["--totals-only --rerecord", { reason: void 0, is_startup_timed: false, form: "rerecord" }],
+  [metrics_base.JSON_FLAG, { reason: void 0, is_startup_timed: false, form: "json" }]
+]);
+function accept_reason(argv) {
+  const [accept_flag, reason_flag, reason = ""] = argv;
+  const is_accept = accept_flag === ACCEPT_FLAG && reason_flag === REASON_FLAG;
+  return is_accept && reason.trim().length > 0 ? { reason: reason.trim(), is_startup_timed: true, form: "full" } : void 0;
+}
+function parse_arguments(argv) {
+  const form = CHECK_FORMS.get(argv.join(" "));
+  if (form !== void 0) return form;
+  return argv.length === ACCEPT_ARGUMENT_COUNT ? accept_reason(argv) : void 0;
+}
+function read_text(file_path) {
+  return readFileSync(file_path, ENCODING2);
+}
+async function script_files(root) {
+  const targets = await line_targets.lint_target_files(root);
+  const measured = targets.filter(
+    (target) => metrics_logic.is_measured_script(path2.relative(root, target).split(path2.sep).join("/"))
+  );
+  const counts = await metrics_code_lines.code_line_counts(measured, root);
+  return [...counts].map(([file_path, code_lines]) => ({ text: read_text(file_path), code_lines }));
+}
+function markdown_paths(directory) {
+  if (!existsSync2(directory)) return [];
+  return readdirSync(directory, { recursive: true, withFileTypes: true }).filter((entry) => entry.isFile() && entry.name.endsWith(MARKDOWN_EXTENSION)).map((entry) => path2.join(entry.parentPath, entry.name));
+}
+function read_texts(paths) {
+  return paths.flatMap((file) => file_reader.read_if_readable(file) ?? []);
+}
+function skill_descriptions(skill_documents) {
+  const entries = skill_documents.filter(
+    (file) => path2.basename(file) === skill_meta.SKILL_ENTRY_FILE
+  );
+  return read_texts(entries).map((text) => skill_meta.description_of(text));
+}
+function ai_cost(root, prompts) {
+  const documents = read_texts(RESIDENT_DOCUMENTS.map((file) => path2.join(root, file)));
+  const skill_documents = markdown_paths(path2.join(root, skill_meta.SKILL_ROOT));
+  return metrics_logic.ai_cost_totals(
+    [...documents, ...skill_descriptions(skill_documents)],
+    read_texts([...prompts, ...skill_documents])
+  );
+}
+function prose(root) {
+  const directories = PROSE_DIRS.flatMap((directory) => markdown_paths(path2.join(root, directory)));
+  return prose_density.totals(read_texts([path2.join(root, PROSE_DOCUMENT), ...directories]));
+}
+async function command_names(root) {
+  const file = path2.join(root, COMMAND_MAP_FILE);
+  if (!existsSync2(file)) return [];
+  const loaded = await tsImport(pathToFileURL(file).href, __josh_source_url2);
+  return Object.keys(command_map_schema.parse(loaded).COMMAND_MAP);
+}
+async function measure3(root) {
+  const scripts = metrics_logic.script_totals(await script_files(root));
+  const prompts = markdown_paths(path2.join(root, RULES_DIR));
+  const rule_texts = read_texts([path2.join(root, RESIDENT_RULES), ...prompts]);
+  const guards = metrics_logic.guard_count(await command_names(root));
+  return {
+    scripts,
+    rules: metrics_logic.rule_totals(rule_texts),
+    guards,
+    ai_cost: ai_cost(root, prompts),
+    prose: prose(root)
+  };
+}
+function today() {
+  return (/* @__PURE__ */ new Date()).toISOString().slice(0, DATE_LENGTH);
+}
+function say(message) {
+  process.stdout.write(`${message}
+`);
+  return 0;
+}
+function fail(message) {
+  process.stderr.write(`${message}
+`);
+  return FAILURE_EXIT_CODE2;
+}
+function settle(commit, verdict) {
+  if (verdict.kind === "regressed") {
+    return fail(metrics_ratchet.render_regressions(verdict.regressions, commit));
+  }
+  return say(SETTLED_LINE[verdict.kind]);
+}
+function rerecord(root, issue, base, current) {
+  const name = metrics_base.approval_name(issue);
+  const own = metrics_ratchet.own_approval(name, current.approvals, base.approvals);
+  const fresh = own === void 0 ? void 0 : metrics_ratchet.refresh(own, base.metrics, current.metrics, today());
+  if (fresh === void 0) return current;
+  const file = metrics_base.write_approval(root, issue, fresh);
+  say(`josh metrics: the growth re-recorded in ${file} \u2014 ${fresh.reason}`);
+  return { ...current, approvals: metrics_base.approval_texts(root) };
+}
+async function rerecorded(root, base, current) {
+  const issue = git_branch.issue_from_branch(await git_command.branch());
+  return issue === void 0 ? current : rerecord(root, issue, base, current);
+}
+async function check_totals(root, metrics, is_rerecorded = false) {
+  const commit = await metrics_base.resolve_commit();
+  if (commit === void 0) return say("josh metrics: no merge-base, so no total is held to one");
+  const measured = { metrics, approvals: metrics_base.approval_texts(root) };
+  const base = await metrics_base.read(commit, measured);
+  const current = is_rerecorded ? await rerecorded(root, base, measured) : measured;
+  const approvals = metrics_ratchet.fresh_approvals(current.approvals, base.approvals);
+  return settle(commit, metrics_ratchet.compare(base.metrics, metrics, approvals));
+}
+async function check_totals_only(root, metrics, form) {
+  process.stdout.write(`${metrics_logic.render(metrics)}
+`);
+  return await check_totals(root, metrics, form === "rerecord");
+}
+async function check2(root, metrics, measurement) {
+  const totals_exit = await check_totals(root, metrics);
+  const durations_file = await metrics_duration_probe.baseline_path();
+  const durations_exit = durations_file === void 0 ? 0 : metrics_duration_probe.check(durations_file, measurement);
+  return Math.max(totals_exit, durations_exit);
+}
+function record_growth(root, issue, growth) {
+  const approval = metrics_ratchet.accept(growth.base, growth.current, growth.reason, today());
+  if (approval === void 0) return say(`${NOT_GROWN} \u2014 there is no growth to record`);
+  if (issue === void 0) return fail("josh metrics: this branch names no issue to record under");
+  const file = metrics_base.write_approval(root, issue, approval);
+  return say(`josh metrics: growth recorded in ${file} \u2014 ${growth.reason}`);
+}
+async function accept_totals(root, metrics, reason) {
+  const commit = await metrics_base.resolve_commit();
+  if (commit === void 0) return fail("josh metrics: no merge-base to measure the growth from");
+  const issue = git_branch.issue_from_branch(await git_command.branch());
+  const current = { metrics, approvals: metrics_base.approval_texts(root) };
+  const base = await metrics_base.read(commit, current);
+  return record_growth(root, issue, { base: base.metrics, current: metrics, reason });
+}
+async function accept2(root, metrics, durations, reason) {
+  const durations_file = await metrics_duration_probe.baseline_path();
+  if (durations_file !== void 0) metrics_duration_probe.accept(durations_file, durations);
+  return await accept_totals(root, metrics, reason);
+}
+async function run_full(root, metrics, parsed) {
+  const measurement = await metrics_duration_probe.measure(root, parsed.is_startup_timed);
+  const shown = metrics_durations.render(measurement.durations, parsed.is_startup_timed);
+  process.stdout.write(`${metrics_logic.render(metrics)}
+${shown}
+`);
+  if (parsed.reason === void 0) return await check2(root, metrics, measurement);
+  return await accept2(root, metrics, measurement.durations, parsed.reason);
+}
+async function run_metrics(argv) {
+  const parsed = parse_arguments(argv);
+  if (parsed === void 0) return fail(USAGE);
+  const root = await git_command.repository_root();
+  const metrics = await measure3(root);
+  if (parsed.form === "json") return say(JSON.stringify(metrics));
+  if (parsed.form !== "full") return await check_totals_only(root, metrics, parsed.form);
+  return await run_full(root, metrics, parsed);
+}
+if (process.argv[1] === fileURLToPath2(__josh_source_url2)) {
+  process.exitCode = await run_metrics(process.argv.slice(ARGV_OFFSET));
+}
+var metrics_command = {
+  command_names,
+  parse_arguments
+};
+export {
+  metrics_command
+};