@joshuafolkken/kit 1.3101.0 → 1.3125.0

package/dist/commands/chunk-LZNACCHR.js

@@ -0,0 +1,174 @@
+import {
+  git_utilities
+} from "./chunk-B5GXZK3E.js";
+import {
+  GIT_TIMEOUT_MS,
+  MS_PER_SECOND,
+  PROBE_TIMEOUT_MS
+} from "./chunk-WPAQUMHC.js";
+
+// scripts/git/git-spawn.ts
+import { execa as execa3 } from "execa";
+
+// scripts/git/git-execa-error.ts
+function get_exit_code(error) {
+  if (typeof error !== "object" || error === null || !("exitCode" in error)) return void 0;
+  const { exitCode: exit_code } = error;
+  return typeof exit_code === "number" ? exit_code : void 0;
+}
+function has_timed_out(error) {
+  if (typeof error !== "object" || error === null || !("timedOut" in error)) return false;
+  return error.timedOut === true;
+}
+var TIMEOUT_EXIT_CODE = "timeout";
+function create_spawn_error(command, exit_code) {
+  const exit_code_string = exit_code === void 0 ? "unknown" : String(exit_code);
+  const error_message = `git ${command} exited with code ${exit_code_string}`;
+  return new Error(error_message, { cause: { exit_code: exit_code_string } });
+}
+
+// scripts/git/git-push-transport.ts
+import { execa as execa2 } from "execa";
+
+// scripts/git/git-ssh-keepalive.ts
+import { execa } from "execa";
+var SSH_KEEPALIVE_OPTIONS = "-o ServerAliveInterval=15 -o ServerAliveCountMax=3";
+var SSH_COMMAND_VARIABLE = "GIT_SSH_COMMAND";
+var SSH_LEGACY_VARIABLE = "GIT_SSH";
+var KEEPALIVE_SSH_COMMAND = `ssh ${SSH_KEEPALIVE_OPTIONS}`;
+var SSH_COMMAND_CONFIG_KEY = "core.sshCommand";
+var CONFIG_PROBE_ARGUMENTS = ["config", "--get", SSH_COMMAND_CONFIG_KEY];
+var PROBE_OPTIONS = { timeout: PROBE_TIMEOUT_MS };
+function to_environment_value(name) {
+  return process.env[name]?.trim() ?? "";
+}
+function to_configured_ssh_command() {
+  const from_command = to_environment_value(SSH_COMMAND_VARIABLE);
+  return from_command === "" ? to_environment_value(SSH_LEGACY_VARIABLE) : from_command;
+}
+async function has_configured_ssh_command() {
+  if (to_configured_ssh_command() !== "") return true;
+  try {
+    const git_command_bin = git_utilities.get_git_command_for_spawn();
+    const { stdout } = await execa(git_command_bin, CONFIG_PROBE_ARGUMENTS, PROBE_OPTIONS);
+    return stdout.trim() !== "";
+  } catch (error) {
+    return has_timed_out(error);
+  }
+}
+async function to_environment() {
+  const should_keep_alive = !await has_configured_ssh_command();
+  return should_keep_alive ? { [SSH_COMMAND_VARIABLE]: KEEPALIVE_SSH_COMMAND } : {};
+}
+var git_ssh_keepalive = {
+  to_environment
+};
+
+// scripts/git/git-push-transport.ts
+var PUSH_TIMEOUT_SECONDS = 120;
+var PUSH_TIMEOUT_MS = PUSH_TIMEOUT_SECONDS * MS_PER_SECOND;
+var PUSH_TIMEOUT_LABEL = `${String(PUSH_TIMEOUT_SECONDS)}s`;
+var PUSH_TIMEOUT_MESSAGE = "git push timed out";
+var PUSH_SUBCOMMAND = "push";
+async function to_push_options() {
+  return {
+    stdio: "inherit",
+    timeout: PUSH_TIMEOUT_MS,
+    env: await git_ssh_keepalive.to_environment()
+  };
+}
+async function did_push_time_out(arguments_list) {
+  const git_command_bin = git_utilities.get_git_command_for_spawn();
+  const options = await to_push_options();
+  try {
+    await execa2(git_command_bin, [PUSH_SUBCOMMAND, ...arguments_list], options);
+    return false;
+  } catch (error) {
+    if (has_timed_out(error)) return true;
+    throw create_spawn_error(PUSH_SUBCOMMAND, get_exit_code(error));
+  }
+}
+function to_manual_command(arguments_list) {
+  return ["git", PUSH_SUBCOMMAND, ...arguments_list].join(" ");
+}
+function to_retry_notice(arguments_list) {
+  return `${PUSH_TIMEOUT_MESSAGE} after ${PUSH_TIMEOUT_LABEL} \u2014 retrying once: ${to_manual_command(arguments_list)}`;
+}
+function create_timeout_error(arguments_list) {
+  const message = `${PUSH_TIMEOUT_MESSAGE} twice (${PUSH_TIMEOUT_LABEL} each). Re-run it by hand: ${to_manual_command(arguments_list)}`;
+  return new Error(message, { cause: { exit_code: TIMEOUT_EXIT_CODE } });
+}
+async function push(arguments_list) {
+  if (!await did_push_time_out(arguments_list)) return;
+  console.warn(to_retry_notice(arguments_list));
+  if (!await did_push_time_out(arguments_list)) return;
+  throw create_timeout_error(arguments_list);
+}
+var git_push_transport = {
+  push
+};
+
+// scripts/git/git-spawn.ts
+async function read(arguments_, timeout_ms = GIT_TIMEOUT_MS) {
+  const git_cmd = git_utilities.get_git_command_for_spawn();
+  const { stdout } = await execa3(git_cmd, arguments_, { timeout: timeout_ms });
+  return stdout.trimEnd();
+}
+var REMOTE_TIMEOUT_MS = PUSH_TIMEOUT_MS;
+function to_budget_error(command, error, timeout_ms) {
+  if (!has_timed_out(error)) return create_spawn_error(command, get_exit_code(error));
+  const seconds = String(Math.round(timeout_ms / MS_PER_SECOND));
+  return new Error(`git ${command} timed out after ${seconds}s`, {
+    cause: { exit_code: TIMEOUT_EXIT_CODE }
+  });
+}
+async function spawn_remote(arguments_, options) {
+  const git_cmd = git_utilities.get_git_command_for_spawn();
+  try {
+    const { stdout } = await execa3(git_cmd, arguments_, options);
+    return typeof stdout === "string" ? stdout.trimEnd() : "";
+  } catch (error) {
+    throw to_budget_error(arguments_[0] ?? "", error, options.timeout);
+  }
+}
+async function read_remote(arguments_, timeout_ms = REMOTE_TIMEOUT_MS) {
+  return await spawn_remote(arguments_, {
+    timeout: timeout_ms,
+    env: await git_ssh_keepalive.to_environment()
+  });
+}
+async function with_output_remote(command, arguments_list) {
+  await spawn_remote([command, ...arguments_list], {
+    stdio: "inherit",
+    timeout: REMOTE_TIMEOUT_MS,
+    env: await git_ssh_keepalive.to_environment()
+  });
+}
+function to_output_spawn_options(options) {
+  const { timeout_ms = GIT_TIMEOUT_MS, environment = {} } = options;
+  return { stdio: "inherit", timeout: timeout_ms, env: environment };
+}
+async function with_output(command, arguments_list, options = {}) {
+  const git_command_bin = git_utilities.get_git_command_for_spawn();
+  const spawn_arguments = [...options.config_options ?? [], command, ...arguments_list];
+  const spawn_options = to_output_spawn_options(options);
+  try {
+    await execa3(git_command_bin, spawn_arguments, spawn_options);
+  } catch (error) {
+    throw to_budget_error(command, error, spawn_options.timeout);
+  }
+}
+var git_spawn = {
+  read,
+  read_remote,
+  with_output,
+  with_output_remote
+};
+
+export {
+  get_exit_code,
+  has_timed_out,
+  create_spawn_error,
+  git_push_transport,
+  git_spawn
+};

package/dist/commands/chunk-MEJ2CQK2.js

@@ -0,0 +1,102 @@
+import {
+  changed_paths
+} from "./chunk-AL2H63BP.js";
+import {
+  git_command
+} from "./chunk-KMED24C4.js";
+
+// scripts/git/changed-file-scope.ts
+import path from "node:path";
+var UNREADABLE_REASON = "the changed files could not be read";
+var LISTED_FILE_LIMIT = 10;
+async function repository_root_or_cwd() {
+  try {
+    return await git_command.repository_root();
+  } catch {
+    return process.cwd();
+  }
+}
+async function read_changed_files(root) {
+  try {
+    const relative_paths = await changed_paths.read_changed_paths(false);
+    return relative_paths.map((relative) => path.join(root, relative));
+  } catch {
+    return void 0;
+  }
+}
+function select_files(paths, inputs) {
+  return paths.filter(
+    (file_path) => inputs.is_selectable(file_path) && inputs.is_present(file_path)
+  );
+}
+function all_scope(reason) {
+  return { mode: "all", files: [], reason };
+}
+function resolve_scope(paths, inputs) {
+  if (paths === void 0) return all_scope(UNREADABLE_REASON);
+  const files = select_files(paths, inputs);
+  if (files.length === 0) return all_scope(inputs.nothing_reason);
+  return { mode: "related", files, reason: `${String(files.length)} changed file(s)` };
+}
+function format_file_list(files, root) {
+  const listed = files.slice(0, LISTED_FILE_LIMIT).map((file) => `  - ${path.relative(root, file)}`);
+  const hidden = files.length - listed.length;
+  if (hidden > 0) listed.push(`  \u2026 and ${String(hidden)} more`);
+  return listed.join("\n");
+}
+function describe_scope(scope, root, vocabulary) {
+  if (scope.mode === "all") {
+    return `${vocabulary.label}: ${scope.reason} \u2014 ${vocabulary.fallback_suffix}.`;
+  }
+  return `${vocabulary.label}: ${scope.reason} \u2014 ${vocabulary.narrowed_suffix}.
+${format_file_list(scope.files, root)}`;
+}
+var ARGV_START = 2;
+var FLAG_PREFIX = "-";
+function is_flag(argument) {
+  return argument.startsWith(FLAG_PREFIX);
+}
+function explicit_files_of(command_arguments) {
+  return command_arguments.filter((argument) => !is_flag(argument));
+}
+function flags_of(command_arguments) {
+  return command_arguments.filter((argument) => is_flag(argument));
+}
+async function resolve_command_scope(request) {
+  const explicit_files = explicit_files_of(request.command_arguments);
+  if (explicit_files.length === 0) {
+    return resolve_scope(await read_changed_files(request.root), request.inputs);
+  }
+  return resolve_scope(
+    explicit_files.map((file) => path.resolve(file)),
+    request.inputs
+  );
+}
+function report_unusable_arguments(command_arguments, scope, label) {
+  const narrowed = new Set(scope.files);
+  const unusable = explicit_files_of(command_arguments).filter(
+    (file) => !narrowed.has(path.resolve(file))
+  );
+  if (unusable.length === 0) return;
+  process.stdout.write(`${label}: ignored \u2014 not a file this check reads: ${unusable.join(" ")}
+`);
+}
+var changed_file_scope = {
+  ARGV_START,
+  LISTED_FILE_LIMIT,
+  UNREADABLE_REASON,
+  describe_scope,
+  flags_of,
+  format_file_list,
+  is_flag,
+  read_changed_files,
+  report_unusable_arguments,
+  repository_root_or_cwd,
+  resolve_command_scope,
+  resolve_scope,
+  select_files
+};
+
+export {
+  changed_file_scope
+};

package/dist/commands/chunk-MHTKSRAH.js

@@ -0,0 +1,278 @@
+import {
+  run_ship_preflight
+} from "./chunk-DOM6HJL3.js";
+import {
+  run_investigation_record
+} from "./chunk-Q67SPFHV.js";
+import {
+  issue_read_cli
+} from "./chunk-H6MHUR2Y.js";
+import {
+  issue_state_cli
+} from "./chunk-6TOWGIY2.js";
+import {
+  acceptance_map
+} from "./chunk-VP3P7FLJ.js";
+import {
+  run_prep_locate
+} from "./chunk-T5D3BW3D.js";
+import {
+  issue_read
+} from "./chunk-TR6NTNWR.js";
+import {
+  markdown_section
+} from "./chunk-UYHREBT7.js";
+import {
+  latest_scope_cli
+} from "./chunk-BVUL57IX.js";
+import {
+  git_stash
+} from "./chunk-5KEESWMC.js";
+import {
+  issue_body_keys
+} from "./chunk-4DNAAFF4.js";
+import {
+  delegation_policy
+} from "./chunk-6I2JM5UX.js";
+import {
+  issue_state
+} from "./chunk-HXM26K3O.js";
+import {
+  git_gh_issue_read
+} from "./chunk-U6SMBYTN.js";
+import {
+  session_cite
+} from "./chunk-22DVQCP6.js";
+import {
+  error_text
+} from "./chunk-CDY4NFQG.js";
+import {
+  lane_child_marker
+} from "./chunk-XXPDFJRI.js";
+import {
+  issue_number_shape
+} from "./chunk-G75GWNNY.js";
+
+// scripts/run/run-prep.ts
+var SUMMARY_PREFIX = "prep #";
+var STATE_LABEL = "state: ";
+var HUMAN_REVIEW_LABEL = "human_review: ";
+var LATEST_LABEL = "latest: ";
+var FIELD_SEPARATOR = " \xB7 ";
+var SUMMARY_DASH = " \u2014 ";
+var UNKNOWN = "?";
+var YES = "yes";
+var NO = "no";
+var CONTENT_HEADER = "=== issue ===";
+var STATE_HEADER = "=== state ===";
+var LATEST_HEADER = "=== dependency update ===";
+var LOCATIONS_HEADER = "=== code locations ===";
+var INVESTIGATION_HEADER = "=== investigation ===";
+var INVESTIGATION_BODY = `Delegate before the first read \u2014 the guard refuses at ${delegation_policy.INVESTIGATION_LIMIT}. ${delegation_policy.INVESTIGATION_STEP} Brief it with the code locations above; read in the main line only the files this run will edit.`;
+var INVESTIGATION_PLANNED_BODY = "Skip the investigator \u2014 the plan is recorded (`run:planned` or a plan comment): the recorded plan in the issue (body or plan comment) is the investigation; read in the main line only the files this run will edit.";
+var INVESTIGATION_SAVED_LEAD = "Skip the investigator \u2014 its conclusion is saved below; read in the main line only the files this run will edit, where main moved since re-read only the cited files its diff touches, and delegate only what it does not answer:";
+var INVESTIGATION_SAVE_STEP = "Save the investigator's conclusion (its `file:line` citations) with the Write tool to";
+var SHIP_HEADER = "=== ship preconditions ===";
+var SHIP_MET = "met \u2014 nothing `josh ship` refuses on as the tree stands";
+var SHIP_UNMET = "unmet \u2014 `josh ship` will refuse until these are fixed; fix them before the gate:";
+var SECTION_SEPARATOR = "\n\n";
+var LATEST_JOINER = " \u2014 ";
+function human_review_value(state) {
+  if (state === void 0) return UNKNOWN;
+  return state.is_human_review ? YES : NO;
+}
+function summary(parts) {
+  const state_value = parts.state === void 0 ? UNKNOWN : parts.state.state;
+  const fields = [
+    `${STATE_LABEL}${state_value}`,
+    `${HUMAN_REVIEW_LABEL}${human_review_value(parts.state)}`,
+    `${LATEST_LABEL}${parts.latest_scope}`
+  ];
+  return `${SUMMARY_PREFIX}${parts.issue_number}${SUMMARY_DASH}${fields.join(FIELD_SEPARATOR)}`;
+}
+function state_body(parts) {
+  return parts.state === void 0 ? parts.state_failure : issue_state.format_issue_state(parts.state);
+}
+function section(header, body) {
+  return `${header}
+${body}`;
+}
+function ship_body(problems) {
+  if (problems.length === 0) return SHIP_MET;
+  return [SHIP_UNMET, ...problems.map((problem) => `  - ${problem}`)].join("\n");
+}
+function save_step(record) {
+  return record === void 0 ? "" : ` ${INVESTIGATION_SAVE_STEP} \`${record.path}\`.`;
+}
+function investigation_body(parts) {
+  const findings = parts.investigation?.findings;
+  if (findings !== void 0) return `${INVESTIGATION_SAVED_LEAD}
+${findings}`;
+  if (parts.is_planned === true) return INVESTIGATION_PLANNED_BODY;
+  return `${INVESTIGATION_BODY}${save_step(parts.investigation)}`;
+}
+function format_report(parts) {
+  return [
+    summary(parts),
+    section(CONTENT_HEADER, parts.content_body),
+    section(STATE_HEADER, state_body(parts)),
+    section(LATEST_HEADER, `${parts.latest_scope}${LATEST_JOINER}${parts.latest_reason}`),
+    section(LOCATIONS_HEADER, parts.locations),
+    section(INVESTIGATION_HEADER, investigation_body(parts)),
+    section(SHIP_HEADER, ship_body(parts.ship_problems))
+  ].join(SECTION_SEPARATOR);
+}
+var run_prep = {
+  CONTENT_HEADER,
+  INVESTIGATION_HEADER,
+  INVESTIGATION_PLANNED_BODY,
+  INVESTIGATION_SAVED_LEAD,
+  INVESTIGATION_SAVE_STEP,
+  LATEST_HEADER,
+  LOCATIONS_HEADER,
+  SHIP_HEADER,
+  SHIP_UNMET,
+  STATE_HEADER,
+  SUMMARY_PREFIX,
+  format_report,
+  ship_body,
+  summary
+};
+
+// scripts/run/run-prep-summary.ts
+var NOW_HEADING = issue_body_keys.heading("symptom");
+var CHANGE_HEADING = issue_body_keys.heading("expected");
+var TEST_LINE = "  - test:";
+function is_blank(line) {
+  return line.trim() === "";
+}
+function section_text(body, heading) {
+  const lines = markdown_section.section_lines(body, heading);
+  const start = lines.findIndex((line) => !is_blank(line));
+  if (start === -1) return [];
+  return lines.slice(start, lines.findLastIndex((line) => !is_blank(line)) + 1);
+}
+function check_lines(body) {
+  return acceptance_map.criteria_of(body).flatMap((criterion) => [`- ${criterion.text}`, TEST_LINE]);
+}
+function trust_lines(is_body_trusted) {
+  return is_body_trusted === true ? [] : [issue_read.UNTRUSTED_BODY_HEADING, ""];
+}
+function format_summary(body, is_body_trusted) {
+  return [
+    ...trust_lines(is_body_trusted),
+    "## Now",
+    ...section_text(body, NOW_HEADING),
+    "",
+    "## Change",
+    ...section_text(body, CHANGE_HEADING),
+    "",
+    "## Check",
+    ...check_lines(body)
+  ].join("\n");
+}
+var run_prep_summary = { format_summary };
+
+// scripts/run/run-prep-cli.ts
+var SUCCESS_EXIT_CODE = 0;
+var FAILURE_EXIT_CODE = 1;
+var USAGE = "Usage: josh run:prep <issue-number> [--summary]";
+var SUMMARY_FLAG = "--summary";
+var LANE_SKIP_SCOPE = "not asked";
+var LANE_SKIP_REASON = "a dispatched lane child does not run josh latest \u2014 the parent does, once per session";
+function parse_number(argv) {
+  const [first] = argv;
+  if (first === void 0 || argv.length !== 1 || !issue_number_shape.ISSUE_NUMBER_PATTERN.test(first)) {
+    return void 0;
+  }
+  return first;
+}
+function failure_note(issue_number, kind) {
+  return `(issue ${session_cite.issue(issue_number)} not bundled: ${kind})`;
+}
+function latest_decision() {
+  if (lane_child_marker.is_child_of(process.cwd())) {
+    return { scope: LANE_SKIP_SCOPE, reason: LANE_SKIP_REASON };
+  }
+  return latest_scope_cli.scope_decision();
+}
+async function lane_has_changes() {
+  if (!lane_child_marker.is_child_of(process.cwd())) return false;
+  try {
+    return await git_stash.has_stashable_changes(process.cwd());
+  } catch (error) {
+    error_text.trace_swallowed("run_prep_cli.lane_has_changes", error);
+    return false;
+  }
+}
+async function gather(issue_number) {
+  const [content, state, has_changes, ship_problems, investigation] = await Promise.all([
+    issue_read_cli.read_block(issue_number),
+    issue_state_cli.read_issue(issue_number),
+    lane_has_changes(),
+    run_ship_preflight.ahead(issue_number),
+    run_investigation_record.load(issue_number)
+  ]);
+  const locations = await run_prep_locate.locate(content.kind === "ok" ? content.block : "");
+  const latest = latest_decision();
+  return { content, state, latest, has_changes, locations, ship_problems, investigation };
+}
+function content_body(issue_number, content) {
+  return content.kind === "ok" ? content.block : failure_note(issue_number, content.kind);
+}
+function to_parts(issue_number, reads) {
+  const state = reads.state.kind === "state" ? reads.state.state : void 0;
+  const state_failure = state === void 0 ? failure_note(issue_number, reads.state.kind) : "";
+  return {
+    issue_number,
+    content_body: content_body(issue_number, reads.content),
+    state,
+    state_failure,
+    latest_scope: reads.latest.scope,
+    latest_reason: reads.latest.reason,
+    has_changes: reads.has_changes,
+    locations: reads.locations,
+    ship_problems: reads.ship_problems,
+    investigation: reads.investigation
+  };
+}
+function exit_code(reads) {
+  const is_complete = reads.content.kind === "ok" && reads.state.kind === "state";
+  return is_complete ? SUCCESS_EXIT_CODE : FAILURE_EXIT_CODE;
+}
+async function read_summary(issue_number) {
+  const [body, block] = await Promise.all([
+    git_gh_issue_read.issue_get_body(issue_number),
+    issue_read_cli.read_block(issue_number)
+  ]);
+  if (body === void 0) return void 0;
+  const is_trusted = block.kind === "ok" ? block.trust.is_body_trusted : void 0;
+  return { body, text: session_cite.text(run_prep_summary.format_summary(body, is_trusted)) };
+}
+async function print_summary(issue_number) {
+  const summary2 = await read_summary(issue_number);
+  if (summary2 === void 0) {
+    console.error(failure_note(issue_number, "unreadable"));
+    return FAILURE_EXIT_CODE;
+  }
+  console.info(summary2.text);
+  return SUCCESS_EXIT_CODE;
+}
+async function run(argv) {
+  const issue_number = parse_number(argv.filter((argument) => argument !== SUMMARY_FLAG));
+  if (issue_number === void 0) {
+    console.error(USAGE);
+    return FAILURE_EXIT_CODE;
+  }
+  if (argv.includes(SUMMARY_FLAG)) return await print_summary(issue_number);
+  const reads = await gather(issue_number);
+  const report = run_prep.format_report(to_parts(issue_number, reads));
+  console.info(session_cite.text(report));
+  return exit_code(reads);
+}
+var run_prep_cli = { failure_note, gather, parse_number, read_summary, run, to_parts };
+
+export {
+  run_prep,
+  run_prep_cli
+};

package/dist/commands/chunk-MI4NHZWO.js

@@ -0,0 +1,65 @@
+import {
+  observation_ledger_home
+} from "./chunk-N5FT5LYP.js";
+import {
+  json_value
+} from "./chunk-HIU2WXB6.js";
+
+// scripts/hooks/hook-ledger-read.ts
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { z } from "zod";
+var LEDGER_EXTENSION = ".jsonl";
+var HOURS_PER_DAY = 24;
+var MS_PER_HOUR = 36e5;
+var MS_PER_DAY = HOURS_PER_DAY * MS_PER_HOUR;
+var KEY_SEPARATOR = "	";
+var line_schema = z.object({
+  at: z.string(),
+  hook: z.string(),
+  rule: z.string(),
+  tool: z.string(),
+  session: z.string(),
+  command: z.string()
+});
+function period_start(period_days, now) {
+  return now.getTime() - period_days * MS_PER_DAY;
+}
+function day_files(directory, period_days, now) {
+  const count = Math.ceil(period_days) + 1;
+  const days = Array.from(
+    { length: count },
+    (_, index) => observation_ledger_home.ledger_date(new Date(now.getTime() - (count - 1 - index) * MS_PER_DAY))
+  );
+  return days.map((day) => path.join(directory, `${day}${LEDGER_EXTENSION}`));
+}
+async function read_text(file) {
+  try {
+    return await readFile(file, "utf8");
+  } catch {
+    return "";
+  }
+}
+function lines_of(text) {
+  return text.split("\n").map((line) => json_value.parse_with(line, line_schema)).filter((line) => line !== void 0);
+}
+async function read_lines(directory, period_days, now) {
+  const files = day_files(directory, period_days, now);
+  const texts = await Promise.all(files.map(async (file) => await read_text(file)));
+  const start = period_start(period_days, now);
+  return texts.flatMap((text) => lines_of(text)).filter((line) => Date.parse(line.at) >= start);
+}
+function group(lines) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const line of lines) {
+    const key = `${line.hook}${KEY_SEPARATOR}${line.rule}`;
+    const found = groups.get(key) ?? { hook: line.hook, rule: line.rule, lines: [] };
+    groups.set(key, { ...found, lines: [...found.lines, line] });
+  }
+  return [...groups.values()].toSorted((left, right) => right.lines.length - left.lines.length);
+}
+var hook_ledger_read = { group, period_start, read_lines };
+
+export {
+  hook_ledger_read
+};

package/dist/commands/chunk-MIDWHXJZ.js

@@ -0,0 +1,46 @@
+import {
+  issue_evidence_exit
+} from "./chunk-J56TYLAL.js";
+import {
+  epic_close
+} from "./chunk-VWNVKWLV.js";
+import {
+  git_gh_command
+} from "./chunk-VJNE7W7O.js";
+import {
+  MEASURED_LABEL,
+  MEASURED_UNMET_LABEL
+} from "./chunk-QQBMVC5W.js";
+import {
+  session_cite
+} from "./chunk-22DVQCP6.js";
+
+// scripts/issue/issue-measured-close.ts
+async function apply_label(issue_number, label = MEASURED_LABEL) {
+  const write = await git_gh_command.issue_apply_label(issue_number, label);
+  if (!write.is_applied) console.error(`${label} not applied: ${write.reason}`);
+  return write.is_applied;
+}
+async function close_issue(issue_number) {
+  const is_closed = await git_gh_command.issue_close(issue_number, void 0);
+  if (is_closed) await epic_close.close_completed_epics({ issue_number, is_merged: true });
+  else console.error(`Issue ${session_cite.issue(issue_number)} not closed`);
+  return is_closed;
+}
+async function label_and_close(issue_number) {
+  return await apply_label(issue_number) && await close_issue(issue_number);
+}
+async function mark_unmet_and_close(issue_number) {
+  return await apply_label(issue_number, MEASURED_UNMET_LABEL) && await label_and_close(issue_number);
+}
+var COMMAND = "issue:measured";
+var MEASURED_EXIT = { command: COMMAND, finish: label_and_close };
+var MEASURED_UNMET_EXIT = { command: COMMAND, finish: mark_unmet_and_close };
+async function close(issue_number, evidence) {
+  return await issue_evidence_exit.write({ issue_number, evidence }, MEASURED_EXIT);
+}
+var issue_measured_close = { MEASURED_EXIT, MEASURED_UNMET_EXIT, close };
+
+export {
+  issue_measured_close
+};