@joshuafolkken/kit 1.3044.0 → 1.3099.0

package/dist/commands/chunk-DFEXNB44.js

@@ -0,0 +1,159 @@
+import {
+  repo_setting
+} from "./chunk-MLJDW7YN.js";
+
+// scripts/repo/auto-merge-setting-logic.ts
+var SETTING_LABEL = "Repository auto-merge";
+var ALLOW_AUTO_MERGE_FIELD = "allow_auto_merge";
+var ORIGIN_ISSUE = "joshuafolkken/kit#834";
+var WORKFLOW_PATH = ".github/workflows/dependabot-auto-merge.yml";
+function enable_command(repo) {
+  return `gh api -X PATCH repos/${repo_setting.command_target(repo)} -f ${ALLOW_AUTO_MERGE_FIELD}=true`;
+}
+function classify_auto_merge(exit_code, stdout) {
+  return repo_setting.classify_boolean_setting(
+    repo_setting.parse_payload(exit_code, stdout),
+    ALLOW_AUTO_MERGE_FIELD
+  );
+}
+function format_disabled_detail(repo) {
+  return [
+    `    off, so ${WORKFLOW_PATH} fails with`,
+    "    `Auto-merge is not allowed for this repository` and Dependabot pull requests stay open.",
+    `    Enable: ${enable_command(repo)}`,
+    `    ${ORIGIN_ISSUE} distributes the workflow; kit never changes this setting.`
+  ];
+}
+function format_unreadable_detail(repo) {
+  if (repo === void 0) {
+    return [
+      "    The repository could not be identified \u2014 `gh` is missing, unauthenticated, or this is",
+      "    not a GitHub remote."
+    ];
+  }
+  return [
+    "    No admin access, or the request failed (offline, timed out, or an unexpected response).",
+    "    Check Settings \u2192 General \u2192 Pull Requests \u2192 Allow auto-merge on the repository's page."
+  ];
+}
+function format_auto_merge_report(status, repo) {
+  const target = repo_setting.report_target(repo);
+  if (status === "enabled") return [`  \u2714 ${SETTING_LABEL}: enabled (${target})`];
+  if (status === "unreadable") {
+    return [
+      `  \u26A0 ${SETTING_LABEL}: could not be read (${target}) \u2014 not checked, not necessarily off`,
+      ...format_unreadable_detail(repo)
+    ];
+  }
+  return [`  \u26A0 ${SETTING_LABEL}: disabled (${target})`, ...format_disabled_detail(repo)];
+}
+var auto_merge_setting_logic = {
+  SETTING_LABEL,
+  classify_auto_merge,
+  format_auto_merge_report
+};
+
+// scripts/repo/auto-merge-setting.ts
+function read_auto_merge(repo) {
+  const { exit_code, stdout } = repo_setting.query_repo_api(`repos/${repo}`);
+  return auto_merge_setting_logic.classify_auto_merge(exit_code, stdout);
+}
+function report_auto_merge_section(repo) {
+  const status = repo === void 0 ? "unreadable" : read_auto_merge(repo);
+  repo_setting.print_section(auto_merge_setting_logic.format_auto_merge_report(status, repo));
+  return status;
+}
+var auto_merge_setting = {
+  GH_TIMEOUT_MS: repo_setting.GH_TIMEOUT_MS,
+  read_auto_merge,
+  report_auto_merge_section
+};
+
+// scripts/security/security-updates-logic.ts
+var SETTING_LABEL2 = "Dependabot security updates";
+var ENABLED_FIELD = "enabled";
+var PAUSED_FIELD = "paused";
+var ORIGIN_ISSUE2 = "joshuafolkken/kit#803";
+function enable_command2(repo) {
+  return `gh api -X PUT repos/${repo_setting.command_target(repo)}/automated-security-fixes`;
+}
+function classify_active(paused) {
+  if (paused === void 0) return "enabled";
+  if (typeof paused !== "boolean") return "unreadable";
+  return paused ? "paused" : "enabled";
+}
+function classify_security_updates(exit_code, stdout) {
+  const payload = repo_setting.parse_payload(exit_code, stdout);
+  const status = repo_setting.classify_boolean_setting(payload, ENABLED_FIELD);
+  if (status !== "enabled") return status;
+  return classify_active(repo_setting.read_field(payload, PAUSED_FIELD));
+}
+function is_exposed(status) {
+  return status === "disabled" || status === "paused";
+}
+function format_exposed_detail(status, repo) {
+  const remediation = status === "paused" ? [
+    "    enabled but paused, so no advisory pull request is opened.",
+    "    Resume it from the repository's Security \u2192 Dependabot page; re-running the enable",
+    "    API does not clear a pause."
+  ] : [
+    "    off, so npm advisories open no pull request at all.",
+    `    Enable: ${enable_command2(repo)}`
+  ];
+  return [
+    ...remediation,
+    `    ${ORIGIN_ISSUE2} disabled npm version updates, so this is the only remaining npm path.`
+  ];
+}
+function format_unreadable_detail2(repo) {
+  if (repo === void 0) {
+    return [
+      "    The repository could not be identified \u2014 `gh` is missing, unauthenticated, or this is",
+      "    not a GitHub remote."
+    ];
+  }
+  return [
+    "    No admin access, Dependabot not enabled for the repository, or the request failed",
+    "    (offline, timed out, or an unexpected response).",
+    "    Check the repository's Security \u2192 Dependabot page."
+  ];
+}
+function format_security_updates_report(status, repo) {
+  const target = repo_setting.report_target(repo);
+  if (status === "enabled") return [`  \u2714 ${SETTING_LABEL2}: enabled (${target})`];
+  if (!is_exposed(status)) {
+    return [
+      `  \u26A0 ${SETTING_LABEL2}: could not be read (${target}) \u2014 not checked, not necessarily off`,
+      ...format_unreadable_detail2(repo)
+    ];
+  }
+  return [`  \u26A0 ${SETTING_LABEL2}: ${status} (${target})`, ...format_exposed_detail(status, repo)];
+}
+var security_updates_logic = {
+  enable_command: enable_command2,
+  classify_security_updates,
+  is_exposed,
+  format_security_updates_report
+};
+
+// scripts/security/security-updates.ts
+var SECURITY_FIXES_PATH = "automated-security-fixes";
+function read_security_updates(repo) {
+  const { exit_code, stdout } = repo_setting.query_repo_api(`repos/${repo}/${SECURITY_FIXES_PATH}`);
+  return security_updates_logic.classify_security_updates(exit_code, stdout);
+}
+function report_security_updates_section(repo) {
+  const status = repo === void 0 ? "unreadable" : read_security_updates(repo);
+  repo_setting.print_section(security_updates_logic.format_security_updates_report(status, repo));
+  return status;
+}
+var security_updates = {
+  GH_TIMEOUT_MS: repo_setting.GH_TIMEOUT_MS,
+  read_security_updates,
+  report_security_updates_section
+};
+
+export {
+  auto_merge_setting,
+  security_updates
+};

package/dist/commands/chunk-DHDKG5HZ.js

@@ -0,0 +1,151 @@
+import {
+  run_wake
+} from "./chunk-QCRUPRQ2.js";
+import {
+  run_carry_ended
+} from "./chunk-KPAJBJXG.js";
+import {
+  telegram_notify
+} from "./chunk-MDKRTUE4.js";
+import {
+  run_event_stream_emit
+} from "./chunk-26JL4UU4.js";
+import {
+  run_event_stream
+} from "./chunk-KGSEWOKI.js";
+import {
+  run_carry
+} from "./chunk-DS53UUDH.js";
+import {
+  process_identity
+} from "./chunk-F2RDEF2J.js";
+
+// scripts/run/run-stranded.ts
+var RECOVERY_COMMAND = "pnpm josh run:wake --start";
+var LIVE = "live";
+var GONE = "gone";
+var UNKNOWN = "unknown";
+var STRANDED = "stranded";
+var OK = "ok";
+function supervisor_liveness(wake, same_process = process_identity.is_same_process) {
+  if (wake === void 0) return GONE;
+  const is_same = same_process(wake.pid, wake.process_start);
+  if (is_same === void 0) return UNKNOWN;
+  return is_same ? LIVE : GONE;
+}
+function had_driver(carry) {
+  return carry.is_handed_off === true || carry.owner_pid !== void 0;
+}
+function is_stranded(input) {
+  if (input.read.kind !== "carried" || input.is_owner_live || !had_driver(input.read.carry)) {
+    return false;
+  }
+  return input.supervisor === GONE;
+}
+function describe(carry) {
+  return `Run stranded \u2014 ${run_carry.describe_carry(carry)}. The owner is gone, no successor holds the budget, and no supervisor is watching.`;
+}
+function verdict_of(is_run_stranded) {
+  return is_run_stranded ? STRANDED : OK;
+}
+var run_stranded = {
+  GONE,
+  LIVE,
+  OK,
+  RECOVERY_COMMAND,
+  STRANDED,
+  UNKNOWN,
+  describe,
+  is_stranded,
+  supervisor_liveness,
+  verdict_of
+};
+
+// scripts/run/run-stranded-detect.ts
+var STRAND_RECOVERY = `Restart supervision with \`${run_stranded.RECOVERY_COMMAND}\` \u2014 it wakes a fresh successor to claim the budget; the cutting session must not resume it itself.`;
+function targets_of(directory) {
+  return { carry: run_carry.carry_path(directory), wake: run_wake.wake_path(directory) };
+}
+async function real_resolve_targets() {
+  const directory = await run_carry.repository_directory();
+  return directory === void 0 ? void 0 : targets_of(directory);
+}
+async function real_emit_stranded(text) {
+  return await run_event_stream_emit.emit_once(run_event_stream.EVENT_KIND.STRANDED, text);
+}
+async function real_notify_stranded(body) {
+  return await telegram_notify.stranded({ body, recovery: STRAND_RECOVERY });
+}
+var DEFAULT_PORTS = {
+  resolve_targets: real_resolve_targets,
+  read_carry: (target) => run_carry.read_carry(target),
+  is_owner_live: run_carry.is_owner_live,
+  has_ended: run_carry_ended.has_ended,
+  read_wake: (target) => run_wake.read_wake(target),
+  supervisor_liveness: (wake) => run_stranded.supervisor_liveness(wake),
+  emit_stranded: real_emit_stranded,
+  notify_stranded: real_notify_stranded
+};
+function input_at(ports, targets) {
+  const read = ports.read_carry(targets.carry);
+  if (read.kind !== "carried") return void 0;
+  return {
+    read,
+    is_owner_live: ports.is_owner_live(read.carry),
+    supervisor: ports.supervisor_liveness(ports.read_wake(targets.wake))
+  };
+}
+async function gather(ports) {
+  const targets = await ports.resolve_targets();
+  return targets === void 0 ? void 0 : input_at(ports, targets);
+}
+async function report(ports, input) {
+  if (input.read.kind !== "carried") return;
+  const text = run_stranded.describe(input.read.carry);
+  if (await ports.emit_stranded(text)) await ports.notify_stranded(text);
+}
+async function detect_and_report(ports = DEFAULT_PORTS) {
+  const input = await gather(ports);
+  if (input === void 0) return run_stranded.OK;
+  const is_run_stranded = run_stranded.is_stranded(input);
+  if (is_run_stranded) await report(ports, input);
+  return run_stranded.verdict_of(is_run_stranded);
+}
+async function run_stranded_check() {
+  try {
+    await detect_and_report();
+  } catch {
+  }
+}
+function is_stranded_at(directory, ports = DEFAULT_PORTS) {
+  const input = input_at(ports, targets_of(directory));
+  return input !== void 0 && run_stranded.is_stranded(input);
+}
+function ports_with(same_process) {
+  return {
+    ...DEFAULT_PORTS,
+    is_owner_live: (carry) => run_carry.is_owner_live(carry, /* @__PURE__ */ new Date(), same_process),
+    supervisor_liveness: (wake) => run_stranded.supervisor_liveness(wake, same_process)
+  };
+}
+function is_left_stranded(run, ports = DEFAULT_PORTS) {
+  const read = ports.read_carry(run.carry_target);
+  if (read.kind !== "carried") return !ports.has_ended(run.ended_target, run.started_at);
+  return run_stranded.is_stranded({
+    read,
+    is_owner_live: run_carry.is_held_by_another(read.carry, ports.is_owner_live),
+    supervisor: run_stranded.GONE
+  });
+}
+var run_stranded_detect = {
+  detect_and_report,
+  is_left_stranded,
+  is_stranded_at,
+  ports_with,
+  run_stranded_check
+};
+
+export {
+  run_stranded,
+  run_stranded_detect
+};

package/dist/commands/chunk-DHJRFBKO.js

@@ -0,0 +1,223 @@
+import {
+  agent_event
+} from "./chunk-LULJUD6P.js";
+import {
+  issue_state
+} from "./chunk-WXXLJQBO.js";
+import {
+  git_gh_issue_read
+} from "./chunk-TFYYXETQ.js";
+import {
+  run_hold
+} from "./chunk-F5N2QIFD.js";
+import {
+  lane_state
+} from "./chunk-7EAYFMDN.js";
+import {
+  has_parked_label
+} from "./chunk-QQBMVC5W.js";
+import {
+  issue_number_shape
+} from "./chunk-G75GWNNY.js";
+import {
+  PLATFORM_TEMP_ROOT
+} from "./chunk-VLN6TSPJ.js";
+import {
+  MS_PER_MINUTE,
+  MS_PER_SECOND
+} from "./chunk-WPAQUMHC.js";
+
+// scripts/run/run-liveness.ts
+import { readFileSync, realpathSync, statSync } from "node:fs";
+import { homedir, tmpdir } from "node:os";
+import path from "node:path";
+import { setTimeout as sleep } from "node:timers/promises";
+var ALIVE_VERDICT = "alive";
+var PAUSED_VERDICT = "paused";
+var SETTLED_VERDICT = "settled";
+var STOPPED_VERDICT = "stopped";
+var UNDETERMINED_VERDICT = "undetermined";
+var PROCESS_ALIVE = "alive";
+var PROCESS_NONE = "none";
+var PROCESS_UNKNOWN = "unknown";
+var DEFAULT_SILENT_MINUTES = 30;
+var DEFAULT_GAP_SECONDS = 5;
+var OPEN_STATE = "OPEN";
+var STATE_FIELDS = "state,labels";
+var REASONS = {
+  [ALIVE_VERDICT]: "The unit is still working: its output moved, or a process of the child is alive.",
+  [PAUSED_VERDICT]: "The lane state record says the lane is paused: its child is suspended, not working, and nothing moves until someone resumes it.",
+  [SETTLED_VERDICT]: "The child is closed, parked with `needs-decision` or `run:stalled`, or marked `already-done`, so there is nothing here to recover.",
+  [STOPPED_VERDICT]: "The output has been frozen past the silent window and no process of the child is alive in that checkout.",
+  [UNDETERMINED_VERDICT]: "A trace could not be read, so this says nothing about the unit. A trace that could not be read answers `undetermined`, never `stopped`."
+};
+var ALIVE_ADVICE = "Keep waiting on `pnpm josh lane:await`; do not touch the child.";
+var PAUSED_ADVICE = "Do not wait on it and do not recover it: tell the person the lane is paused; `pnpm josh lane:resume <N>` resumes it once they ask.";
+var SETTLED_ADVICE = "Read the child with `pnpm josh issue:state <N>` and take the branch its state says.";
+var STOPPED_CLEAN_ADVICE = "The unit ended \u2014 classify how before booking it. Run `pnpm josh run:merge <N> --output <path>` (add `--epic <E> --repo <owner/repo>` for a named epic): it reads the child's exit record without waiting for the unit to return, re-dispatches a child that could not reach the API (counting the outage; a run of them trips the environment guard, which holds launches), and parks an abandoned child with `run:stalled` against the consecutive-failure guard. The checkout is clean, so there is nothing to stash.";
+var STOPPED_DIRTY_ADVICE = "Classify how the unit ended with `pnpm josh run:merge <N> --output <path> --stash` (add `--epic <E> --repo <owner/repo>` for a named epic): `--stash` first stashes the half-finished work and records its `stash:pop` line on the Issue, then it re-dispatches an API-outage child (counting the outage; a run of them trips the environment guard, which holds launches) and parks an abandoned child with `run:stalled` against the consecutive-failure guard, without waiting for the unit to return.";
+var UNDETERMINED_ADVICE = "Read the trace that failed and ask again. Where the process trace was given as `unknown`, leave `--process` out so the command reads it. Two of these in a row is a fault in the check itself rather than a slow unit: stop polling and report it.";
+function is_output_moving(traces) {
+  return traces.is_output_frozen === false;
+}
+function is_agent_state_finished(state) {
+  return state?.result === "completed" || state?.result === "failed";
+}
+function is_agent_finished(traces) {
+  return is_agent_state_finished(traces.agent_state);
+}
+function recorded_verdict(state) {
+  if (state === "paused") return PAUSED_VERDICT;
+  return state === "ended" ? SETTLED_VERDICT : void 0;
+}
+function definitive_verdict(traces) {
+  if (traces.is_child_settled === true) return SETTLED_VERDICT;
+  const recorded = recorded_verdict(traces.lane_state);
+  if (recorded !== void 0) return recorded;
+  if (is_agent_finished(traces)) return STOPPED_VERDICT;
+  if (is_output_moving(traces)) return ALIVE_VERDICT;
+  return void 0;
+}
+function is_check_running(traces) {
+  return traces.process_trace === PROCESS_ALIVE;
+}
+function has_unreadable_trace(traces) {
+  return traces.is_child_settled === void 0 || traces.is_output_frozen === void 0 || traces.process_trace === PROCESS_UNKNOWN;
+}
+function to_verdict(traces) {
+  const definitive = definitive_verdict(traces);
+  if (definitive !== void 0) return definitive;
+  if (has_unreadable_trace(traces)) return UNDETERMINED_VERDICT;
+  return is_check_running(traces) ? ALIVE_VERDICT : STOPPED_VERDICT;
+}
+var ADVICE = {
+  [ALIVE_VERDICT]: ALIVE_ADVICE,
+  [PAUSED_VERDICT]: PAUSED_ADVICE,
+  [SETTLED_VERDICT]: SETTLED_ADVICE,
+  [UNDETERMINED_VERDICT]: UNDETERMINED_ADVICE
+};
+function to_advice(verdict, has_work_to_stash) {
+  if (verdict !== STOPPED_VERDICT) return ADVICE[verdict];
+  return has_work_to_stash ? STOPPED_DIRTY_ADVICE : STOPPED_CLEAN_ADVICE;
+}
+function decide(traces) {
+  const verdict = to_verdict(traces);
+  const has_work_to_stash = verdict === STOPPED_VERDICT && traces.is_tree_dirty;
+  return {
+    advice: to_advice(verdict, has_work_to_stash),
+    has_work_to_stash,
+    reason: traces.agent_state?.reason ?? REASONS[verdict],
+    verdict
+  };
+}
+function to_resolved_root(root) {
+  try {
+    return realpathSync(root);
+  } catch {
+    return root;
+  }
+}
+var ALLOWED_ROOTS = [
+  ...new Set(
+    [homedir(), tmpdir(), PLATFORM_TEMP_ROOT].flatMap((root) => [root, to_resolved_root(root)])
+  )
+];
+function is_within(candidate, root) {
+  const relative = path.relative(root, candidate);
+  return relative !== "" && !relative.startsWith("..") && !path.isAbsolute(relative);
+}
+function to_safe_path(output_path) {
+  const normalized = path.normalize(output_path);
+  if (!path.isAbsolute(normalized)) return void 0;
+  return ALLOWED_ROOTS.some((root) => is_within(normalized, root)) ? normalized : void 0;
+}
+function sample_output(output_path) {
+  const safe_path = to_safe_path(output_path);
+  if (safe_path === void 0) return void 0;
+  const stats = statSync(safe_path, { throwIfNoEntry: false });
+  if (!stats?.isFile()) return void 0;
+  return { mtime_ms: stats.mtimeMs, size: stats.size };
+}
+function read_agent_state(output_path) {
+  const safe_path = to_safe_path(output_path);
+  if (safe_path === void 0) return void 0;
+  try {
+    const state = agent_event.read(readFileSync(safe_path, "utf8"));
+    return state.provider === void 0 ? void 0 : state;
+  } catch {
+    return void 0;
+  }
+}
+function describe_agent_state(output_path) {
+  const state = read_agent_state(output_path);
+  return state === void 0 ? void 0 : `agent: ${state.provider ?? "unknown"} ${agent_event.describe(state)}`;
+}
+async function read_output_frozen(request) {
+  const first = sample_output(request.output_path);
+  if (first === void 0) return void 0;
+  if (request.now_ms - first.mtime_ms < request.silent_window_ms) return false;
+  await sleep(request.gap_ms);
+  const second = sample_output(request.output_path);
+  if (second === void 0) return void 0;
+  return second.mtime_ms === first.mtime_ms && second.size === first.size;
+}
+function carries_settled_label(labels) {
+  return has_parked_label(labels);
+}
+async function read_child_settled(issue, repo) {
+  const json = await git_gh_issue_read.issue_view_json(issue, STATE_FIELDS, repo);
+  if (json === void 0) return void 0;
+  const state = issue_state.parse_issue_state(json);
+  if (state === void 0) return void 0;
+  return state.state !== OPEN_STATE || carries_settled_label(state.labels);
+}
+function freshness_of(request) {
+  return {
+    gap_ms: request.gap_ms ?? DEFAULT_GAP_SECONDS * MS_PER_SECOND,
+    now_ms: Date.now(),
+    output_path: request.output_path,
+    silent_window_ms: request.silent_window_ms ?? DEFAULT_SILENT_MINUTES * MS_PER_MINUTE
+  };
+}
+async function read_traces(request) {
+  const [is_initial_child_settled, is_output_frozen, is_tree_dirty, record] = await Promise.all([
+    read_child_settled(request.issue, request.repo),
+    read_output_frozen(freshness_of(request)),
+    run_hold.is_tree_dirty(),
+    lane_state.read_state(request.issue)
+  ]);
+  const agent_state = read_agent_state(request.output_path);
+  const is_latest_child_settled = is_agent_state_finished(agent_state) ? await read_child_settled(request.issue, request.repo) : void 0;
+  const is_child_settled = is_latest_child_settled ?? is_initial_child_settled;
+  return {
+    agent_state,
+    is_child_settled,
+    is_output_frozen,
+    is_tree_dirty,
+    lane_state: record?.state,
+    process_trace: request.process_trace
+  };
+}
+async function check(request) {
+  issue_number_shape.require_issue_number(request.issue);
+  return decide(await read_traces(request));
+}
+var run_liveness = {
+  check,
+  decide,
+  describe_agent_state,
+  read_agent_state,
+  read_child_settled,
+  read_output_frozen,
+  sample_output,
+  to_safe_path
+};
+
+export {
+  UNDETERMINED_VERDICT,
+  PROCESS_ALIVE,
+  PROCESS_NONE,
+  PROCESS_UNKNOWN,
+  DEFAULT_SILENT_MINUTES,
+  run_liveness
+};

package/dist/commands/chunk-DKDWOE3C.js

@@ -0,0 +1,78 @@
+import {
+  session_owner_pin
+} from "./chunk-TNJU4CXD.js";
+import {
+  repo_discovery
+} from "./chunk-MDKDJF2K.js";
+import {
+  repo_origin
+} from "./chunk-4ZHWTTQW.js";
+
+// scripts/discovery/repo-party.ts
+var FIRST_PARTY = "first-party";
+var THIRD_PARTY = "third-party";
+var UNKNOWN = "unknown";
+var GH_REPO_ENV_KEY = "GH_REPO";
+var GH_REPO_PATH_SEGMENTS = 2;
+function classify(session_owner, target) {
+  if (session_owner === void 0 || target === void 0) return UNKNOWN;
+  return session_owner.toLowerCase() === target.toLowerCase() ? FIRST_PARTY : THIRD_PARTY;
+}
+function parse_owner_repo(owner_repo) {
+  return repo_origin.parse_origin_url(`https://${repo_origin.GITHUB_HOST}/${owner_repo}`);
+}
+function target_owner(owner_repo) {
+  return parse_owner_repo(owner_repo)?.owner;
+}
+function current_owner(repository_path = process.cwd()) {
+  return session_owner_pin.pinned(repository_path) ?? repo_discovery.resolve_current_owner(repository_path);
+}
+function selector_repository(selector) {
+  return parse_owner_repo(selector.split("/").slice(-GH_REPO_PATH_SEGMENTS).join("/"));
+}
+function selector_owner(selector) {
+  return selector_repository(selector)?.owner;
+}
+function remote_repositories(repository_path) {
+  return repo_discovery.read_remote_urls(repository_path).map((url) => repo_origin.parse_origin_url(url));
+}
+function placeholder_repositories(repository_path, environment) {
+  const gh_repo = environment[GH_REPO_ENV_KEY];
+  return gh_repo === void 0 || gh_repo === "" ? remote_repositories(repository_path) : [selector_repository(gh_repo)];
+}
+function placeholder_owners(repository_path = process.cwd(), environment = process.env) {
+  return placeholder_repositories(repository_path, environment).map((identity) => identity?.owner);
+}
+function is_same_repository(left, right) {
+  if (left === void 0 || classify(left.owner, right.owner) !== FIRST_PARTY) return false;
+  return left.repo.toLowerCase() === right.repo.toLowerCase();
+}
+function sole_repository(candidates) {
+  const [first, ...rest] = candidates;
+  if (first === void 0) return void 0;
+  return rest.every((candidate) => is_same_repository(candidate, first)) ? first : void 0;
+}
+function current_repository(repository_path = process.cwd(), environment = process.env) {
+  return sole_repository(placeholder_repositories(repository_path, environment));
+}
+function is_own_repository(target, own) {
+  return is_same_repository(own, target);
+}
+var repo_party = {
+  FIRST_PARTY,
+  THIRD_PARTY,
+  UNKNOWN,
+  classify,
+  current_owner,
+  current_repository,
+  is_own_repository,
+  parse_owner_repo,
+  placeholder_owners,
+  selector_owner,
+  sole_repository,
+  target_owner
+};
+
+export {
+  repo_party
+};

package/dist/commands/chunk-DKO5VTEH.js

@@ -0,0 +1,65 @@
+import {
+  observation_ledger_home
+} from "./chunk-QXBOECGL.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
+};