@joshuafolkken/kit 1.3101.0 → 1.3125.0

package/dist/commands/chunk-XO7S2BTY.js

@@ -0,0 +1,365 @@
+import {
+  run_event_stream
+} from "./chunk-373P5MM2.js";
+import {
+  lane_state
+} from "./chunk-V36OV7AP.js";
+import {
+  issue_cite
+} from "./chunk-HQ2HSZBN.js";
+import {
+  error_text
+} from "./chunk-CDY4NFQG.js";
+import {
+  run_carry
+} from "./chunk-JSJS3OT7.js";
+
+// scripts/run/event/run-event-scope.ts
+var SINCE_SCOPE = "since";
+var UNKNOWN_SCOPE = "unknown";
+var UNKNOWN_EVENT_SCOPE = { kind: UNKNOWN_SCOPE };
+function moment_of(at) {
+  const parsed = Date.parse(at);
+  return Number.isNaN(parsed) ? void 0 : parsed;
+}
+function is_within(event, floor) {
+  const at = moment_of(event.at);
+  return at !== void 0 && at >= floor;
+}
+function scoped_events(events, scope) {
+  if (scope.kind === UNKNOWN_SCOPE) return void 0;
+  const floor = moment_of(scope.started_at);
+  if (floor === void 0) return void 0;
+  return events.filter((event) => is_within(event, floor));
+}
+function scope_of(read) {
+  if (read.kind !== "carried") return UNKNOWN_EVENT_SCOPE;
+  return { kind: SINCE_SCOPE, started_at: read.carry.started_at };
+}
+function last_scoped_event(events, scope) {
+  return scoped_events(events, scope)?.findLast(
+    (event) => !run_event_stream.TRACE_KINDS.has(event.kind)
+  );
+}
+var SHIP_POSITION_KINDS = /* @__PURE__ */ new Set([
+  run_event_stream.EVENT_KIND.SHIP_LAUNCH,
+  run_event_stream.EVENT_KIND.SHIP_STOP
+]);
+var KIND = run_event_stream.EVENT_KIND;
+var BATCH_RECORD_KINDS = /* @__PURE__ */ new Set([
+  KIND.CHILD_LAUNCH,
+  KIND.RESTART,
+  KIND.WITHDRAW,
+  KIND.PARK,
+  KIND.HUMAN_REVIEW,
+  KIND.SPLIT,
+  KIND.RETROSPECTIVE,
+  KIND.STRANDED
+]);
+var ISSUE_REFERENCE = /#(\d+)/u;
+function is_foreign_ship_event(event, issue) {
+  return SHIP_POSITION_KINDS.has(event.kind) && !event.text.startsWith(`${issue_cite.plain_for("program", issue)} `);
+}
+function is_own_ship_event(event, issue) {
+  return SHIP_POSITION_KINDS.has(event.kind) && !is_foreign_ship_event(event, issue);
+}
+function issue_named(event) {
+  return ISSUE_REFERENCE.exec(event.text)?.[1];
+}
+function names_issue(event, issue) {
+  return issue_named(event) === issue;
+}
+function is_lane_position(event, issue) {
+  return !BATCH_RECORD_KINDS.has(event.kind) && names_issue(event, issue);
+}
+function since_own_launch(events, issue) {
+  const launch = events.findLastIndex(
+    (event) => event.kind === KIND.CHILD_LAUNCH && names_issue(event, issue)
+  );
+  return events.slice(launch + 1);
+}
+function is_foreign_event(event, issue, is_lane_child) {
+  if (is_lane_child) return !is_lane_position(event, issue);
+  return is_foreign_ship_event(event, issue);
+}
+function last_issue_event(events, scope, issue, is_lane_child) {
+  const attempt = is_lane_child ? since_own_launch(events, issue) : events;
+  const own = attempt.filter((event) => !is_foreign_event(event, issue, is_lane_child));
+  if (scope.kind === SINCE_SCOPE) return last_scoped_event(own, scope);
+  return own.findLast((event) => is_own_ship_event(event, issue));
+}
+var LAUNCH_OR_SETTLE_KINDS = /* @__PURE__ */ new Set([
+  KIND.CHILD_LAUNCH,
+  KIND.MERGE,
+  KIND.PARK,
+  KIND.HUMAN_REVIEW,
+  KIND.SPLIT,
+  KIND.WITHDRAW
+]);
+function is_merge_owed(events, scope, issue) {
+  const newest = (scoped_events(events, scope) ?? []).findLast(
+    (event) => LAUNCH_OR_SETTLE_KINDS.has(event.kind) && names_issue(event, issue)
+  );
+  return newest?.kind === KIND.CHILD_LAUNCH;
+}
+function is_launch_or_withdrawal(event, issue) {
+  const is_kind = event.kind === KIND.CHILD_LAUNCH || event.kind === KIND.WITHDRAW;
+  return is_kind && names_issue(event, issue);
+}
+function is_withdrawn(events, issue) {
+  const newest = events.findLast((event) => is_launch_or_withdrawal(event, issue));
+  return newest?.kind === KIND.WITHDRAW;
+}
+var run_event_scope = {
+  UNKNOWN_EVENT_SCOPE,
+  is_merge_owed,
+  is_withdrawn,
+  issue_named,
+  last_issue_event,
+  last_scoped_event,
+  moment_of,
+  scope_of,
+  scoped_events,
+  since_own_launch
+};
+
+// scripts/run/event/run-event-stream-emit.ts
+import { statSync } from "node:fs";
+
+// scripts/lane/lane-spans.ts
+function next_start_ms(starts, issue, from_ms) {
+  const later = starts.filter((other) => other.issue === issue && other.at_ms > from_ms);
+  return Math.min(...later.map((other) => other.at_ms));
+}
+function issue_spans(pair) {
+  return pair.starts.map((start) => {
+    const until_ms = next_start_ms(pair.bounds, start.issue, start.at_ms);
+    return {
+      from_ms: start.at_ms,
+      end_ms: pair.ends.find(
+        (end) => end.issue === start.issue && end.at_ms >= start.at_ms && end.at_ms < until_ms
+      )?.at_ms
+    };
+  });
+}
+var lane_spans = { issue_spans };
+
+// scripts/run/board/run-board-lane-time.ts
+var KIND2 = run_event_stream.EVENT_KIND;
+var LAUNCH_KINDS = /* @__PURE__ */ new Set([KIND2.CHILD_LAUNCH, KIND2.RESTART]);
+var OFF_LANE_KINDS = /* @__PURE__ */ new Set([
+  KIND2.MERGE,
+  KIND2.PARK,
+  KIND2.HUMAN_REVIEW,
+  KIND2.WITHDRAW,
+  KIND2.OUTAGE,
+  KIND2.USAGE_LIMIT,
+  KIND2.SPLIT,
+  KIND2.STOP
+]);
+function moments_of(events, kinds) {
+  return events.filter((event) => kinds.has(event.kind)).map((event) => ({
+    issue: Number(run_event_scope.issue_named(event)),
+    at_ms: Date.parse(event.at)
+  }));
+}
+function spans_of(events) {
+  const launches = moments_of(events, LAUNCH_KINDS);
+  const ends = moments_of(events, OFF_LANE_KINDS);
+  const issues = new Set(launches.map((launch) => launch.issue));
+  return new Map(
+    [...issues].map((issue) => {
+      const starts = launches.filter((launch) => launch.issue === issue);
+      return [issue, lane_spans.issue_spans({ starts, bounds: starts, ends })];
+    })
+  );
+}
+function span_ms(span, until_ms, end_ms) {
+  return Math.max(0, Math.min(span.end_ms ?? until_ms, end_ms) - span.from_ms);
+}
+function in_lane_ms(spans, end_ms) {
+  return spans.reduce(
+    (total, span, index) => total + span_ms(span, spans[index + 1]?.from_ms ?? end_ms, end_ms),
+    0
+  );
+}
+function elapsed_of(spans, started_ms, ended_ms) {
+  return spans.length === 0 ? ended_ms - started_ms : in_lane_ms(spans, ended_ms);
+}
+function launched_ms(record) {
+  const launched_at = record?.launched_at;
+  return launched_at === void 0 ? void 0 : Date.parse(launched_at);
+}
+function counted_from(run, started_ms) {
+  return run === void 0 ? started_ms : Date.parse(run.started_at);
+}
+function is_ended(spans) {
+  return spans.at(-1)?.end_ms !== void 0;
+}
+function ending_elapsed(read) {
+  const started_ms = launched_ms(read.record);
+  if (started_ms === void 0) return void 0;
+  const from_ms = counted_from(read.record?.run, started_ms);
+  const spans = (spans_of(read.events).get(read.issue) ?? []).filter(
+    (span) => span.from_ms >= from_ms
+  );
+  return is_ended(spans) ? void 0 : elapsed_of(spans, started_ms, read.ended_ms);
+}
+var run_board_lane_time = {
+  LAUNCH_KINDS,
+  OFF_LANE_KINDS,
+  elapsed_of,
+  ending_elapsed,
+  in_lane_ms,
+  spans_of
+};
+
+// scripts/run/event/run-event-stream-emit.ts
+var UNRESOLVED_STREAM = "Could not resolve the run event stream.";
+function now_iso() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+async function stream_target() {
+  const repository = await run_carry.repository_directory();
+  return repository === void 0 ? void 0 : run_event_stream.target_of(repository);
+}
+async function lane_record(issue) {
+  try {
+    return await lane_state.read_state(issue);
+  } catch (error) {
+    error_text.trace_swallowed("run_event_stream_emit.lane_record", error);
+    return void 0;
+  }
+}
+async function ending_fields(target, event) {
+  const issue = run_event_scope.issue_named(event);
+  if (issue === void 0 || !run_board_lane_time.OFF_LANE_KINDS.has(event.kind)) return {};
+  const elapsed_ms = run_board_lane_time.ending_elapsed({
+    events: run_event_stream.read_events(target),
+    issue: Number(issue),
+    record: await lane_record(issue),
+    ended_ms: Date.parse(event.at)
+  });
+  return elapsed_ms === void 0 ? {} : { elapsed_ms };
+}
+async function append_with(target, event) {
+  return run_event_stream.append_event(target, {
+    ...event,
+    ...await ending_fields(target, event)
+  });
+}
+async function append_at(target, kind, text, at) {
+  return await append_with(target, { kind, text, at: at.toISOString() });
+}
+async function emit(kind, text, at = /* @__PURE__ */ new Date(), fields = {}) {
+  try {
+    const target = await stream_target();
+    if (target === void 0) return;
+    await append_with(target, { ...fields, kind, text, at: at.toISOString() });
+  } catch {
+  }
+}
+async function fresh_target(kind) {
+  const target = await stream_target();
+  if (target === void 0 || run_event_stream.read_last(target)?.kind === kind) return void 0;
+  return target;
+}
+async function emit_once(kind, text, before_append) {
+  try {
+    const target = await fresh_target(kind);
+    if (target === void 0) return false;
+    await before_append?.();
+    return run_event_stream.append(target, kind, text, now_iso()).appended;
+  } catch (error) {
+    error_text.trace_swallowed("run_event_stream_emit.emit_once", error);
+    return false;
+  }
+}
+function invocation_events(repository, target) {
+  const events = run_event_stream.read_events(target);
+  const scope = run_event_scope.scope_of(run_carry.read_carry(run_carry.carry_path(repository)));
+  return run_event_scope.scoped_events(events, scope) ?? events;
+}
+async function emit_once_since_with(kind, reset_kind, compose) {
+  try {
+    const repository = await run_carry.repository_directory();
+    if (repository === void 0) return void 0;
+    const target = run_event_stream.target_of(repository);
+    if (run_event_stream.has_since(invocation_events(repository, target), kind, reset_kind)) {
+      return void 0;
+    }
+    const text = await compose();
+    return run_event_stream.append(target, kind, text, now_iso()).appended ? text : void 0;
+  } catch (error) {
+    error_text.trace_swallowed("run_event_stream_emit.emit_once_since", error);
+    return void 0;
+  }
+}
+async function emit_once_since(kind, text, reset_kind) {
+  const appended = await emit_once_since_with(kind, reset_kind, async () => text);
+  return appended !== void 0;
+}
+async function emit_heartbeat(line) {
+  await emit(run_event_stream.EVENT_KIND.HEARTBEAT, line);
+}
+function read_current_events(repository, is_required) {
+  if (repository === void 0) throw new Error(UNRESOLVED_STREAM);
+  const read = run_carry.read_carry(run_carry.carry_path(repository));
+  const scope = run_event_scope.scope_of(read);
+  const events = run_event_stream.read_events(run_event_stream.target_of(repository), is_required);
+  const scoped = run_event_scope.scoped_events(events, scope);
+  if (scoped === void 0) throw new Error("Could not determine the run event scope.");
+  return scoped;
+}
+async function current_events(is_required = false) {
+  try {
+    return read_current_events(await run_carry.repository_directory(), is_required);
+  } catch (error) {
+    if (is_required) throw error;
+    return [];
+  }
+}
+async function invocation_or_all_events() {
+  try {
+    const repository = await run_carry.repository_directory();
+    return repository === void 0 ? [] : invocation_events(repository, run_event_stream.target_of(repository));
+  } catch {
+    return [];
+  }
+}
+function read_existing_events(target, is_required) {
+  if (is_required && statSync(target, { throwIfNoEntry: false }) === void 0) return [];
+  return run_event_stream.read_events(target, is_required);
+}
+function read_all_events(target, is_required) {
+  if (target === void 0 && is_required) throw new Error(UNRESOLVED_STREAM);
+  return target === void 0 ? [] : read_existing_events(target, is_required);
+}
+async function all_events(is_required = false) {
+  try {
+    const target = await stream_target();
+    return read_all_events(target, is_required);
+  } catch (error) {
+    if (is_required) throw error;
+    return [];
+  }
+}
+var run_event_stream_emit = {
+  all_events,
+  append_at,
+  current_events,
+  emit,
+  emit_heartbeat,
+  emit_once,
+  emit_once_since,
+  emit_once_since_with,
+  invocation_or_all_events,
+  stream_target
+};
+
+export {
+  lane_spans,
+  run_event_scope,
+  run_board_lane_time,
+  run_event_stream_emit
+};

package/dist/commands/chunk-XQDG56LP.js

@@ -0,0 +1,47 @@
+import {
+  git_spawn
+} from "./chunk-LZNACCHR.js";
+
+// scripts/lines/line-targets.ts
+import { existsSync } from "node:fs";
+import path from "node:path";
+var LINT_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".ts",
+  ".tsx",
+  ".mts",
+  ".cts",
+  ".js",
+  ".jsx",
+  ".mjs",
+  ".cjs",
+  ".svelte"
+]);
+var WHOLE_TREE_PATHSPEC = ":/";
+var LS_FILES_FLAGS = [
+  "ls-files",
+  "--cached",
+  "--others",
+  "--exclude-standard",
+  "--full-name",
+  "-z"
+];
+var NUL = "\0";
+function is_lint_target(relative_path) {
+  return LINT_EXTENSIONS.has(path.extname(relative_path));
+}
+function split_names(output) {
+  return output.split(NUL).filter((name) => name.length > 0);
+}
+async function lint_target_files(root) {
+  const output = await git_spawn.read([...LS_FILES_FLAGS, WHOLE_TREE_PATHSPEC]);
+  return split_names(output).filter((name) => is_lint_target(name)).map((name) => path.resolve(root, name)).filter((file_path) => existsSync(file_path));
+}
+var line_targets = {
+  is_lint_target,
+  lint_target_files,
+  split_names
+};
+
+export {
+  line_targets
+};

package/dist/commands/chunk-XSBLCTDI.js

@@ -0,0 +1,143 @@
+import {
+  backlogrun_parent_read_set,
+  lane_child_read_set
+} from "./chunk-XZQHP4JR.js";
+import {
+  document_byte_budget
+} from "./chunk-3QNEEG5O.js";
+import {
+  entry_read_set
+} from "./chunk-45RCSJGE.js";
+import {
+  PACKAGE_DIR
+} from "./chunk-3CCGKX7Y.js";
+
+// scripts/document/entry-read-budget.ts
+import { statSync } from "node:fs";
+import path from "node:path";
+
+// scripts/document/document-reachability.ts
+var RESIDENT_BASE = ["CLAUDE.md"];
+var WORKFLOW_DIRECTORY = ".claude/skills/workflow-commands";
+function workflow_path(name) {
+  return `${WORKFLOW_DIRECTORY}/${name}`;
+}
+function names_of(set) {
+  return [...set.files, ...set.sections.map((reference) => reference.file)];
+}
+function entry_read_names(root) {
+  const names = [...entry_read_set.entries(root), lane_child_read_set.LANE_CHILD].flatMap(
+    (entry) => names_of(entry_read_set.read_set(root, entry))
+  );
+  return new Set(names);
+}
+function resident_documents(root) {
+  return /* @__PURE__ */ new Set([
+    ...RESIDENT_BASE,
+    ...[...entry_read_names(root)].map((name) => workflow_path(name))
+  ]);
+}
+function point_of_use_documents() {
+  const per_entry = [...entry_read_set.POINT_OF_USE_BY_ENTRY.values()].flatMap((files) => [
+    ...files
+  ]);
+  return new Set(
+    [...entry_read_set.POINT_OF_USE_FILES, ...per_entry].map((name) => workflow_path(name))
+  );
+}
+function label_of(relative_path, resident, point_of_use) {
+  if (resident.has(relative_path)) return "resident";
+  return point_of_use.has(relative_path) ? "point-of-use" : "unreached";
+}
+function classify(corpus, root = process.cwd()) {
+  const resident = resident_documents(root);
+  const point_of_use = point_of_use_documents();
+  return new Map(corpus.map((one) => [one, label_of(one, resident, point_of_use)]));
+}
+function documents_labelled(label, corpus, root = process.cwd()) {
+  return [...classify(corpus, root)].filter(([, value]) => value === label).map(([one]) => one).toSorted((left, right) => left.localeCompare(right));
+}
+function covered_documents(root = process.cwd()) {
+  return [.../* @__PURE__ */ new Set([...resident_documents(root), ...point_of_use_documents()])].toSorted(
+    (left, right) => left.localeCompare(right)
+  );
+}
+function unreached_documents(corpus, root = process.cwd()) {
+  return documents_labelled("unreached", corpus, root);
+}
+var document_reachability = {
+  RESIDENT_BASE,
+  classify,
+  covered_documents,
+  documents_labelled,
+  unreached_documents
+};
+
+// scripts/document/entry-read-budget.ts
+var { block_ceiling } = document_byte_budget;
+var { LANE_CHILD } = lane_child_read_set;
+var { BACKLOGRUN } = backlogrun_parent_read_set;
+var NOTHING = 0;
+var RECHECK_COMMAND = "pnpm josh bytes";
+var ENTRY_READ_BUDGET = [
+  { entry: "kickoff", bytes: 36864 },
+  // joshuafolkken/kit#6094 trimmed restated prose from SKILL.md and entry-sequence.md, lowering
+  // `fullrun`, `halfrun`, `prrun` and `backlogrun` by a block each.
+  { entry: "fullrun", bytes: 49152 },
+  { entry: "halfrun", bytes: 45056 },
+  { entry: "prrun", bytes: 49152 },
+  // joshuafolkken/kit#5843 removed the duplicated backlogrun procedures, lowering the read by a block;
+  // joshuafolkken/kit#5920 moved the loop's section pointers into the driver hand-off, by another;
+  // joshuafolkken/kit#5946 moved the lane child's step 0 out of the chain section, by another
+  // (and lowered `prrun` and the lane child by one block each).
+  { entry: "backlogrun", bytes: 69632 },
+  // joshuafolkken/kit#5953 charged pre-gate-cut.md at the two sections run:cut prints, not whole;
+  // joshuafolkken/kit#5958 dropped the seam's pointer to the cut, lowering it by a block.
+  { entry: LANE_CHILD, bytes: 24576 }
+];
+function byte_size(root, relative_path) {
+  return statSync(path.join(root, relative_path)).size;
+}
+function entry_cost(root, entry) {
+  if (entry === LANE_CHILD) return lane_child_read_set.costed(root);
+  if (entry === BACKLOGRUN) return backlogrun_parent_read_set.costed(root);
+  return entry_read_set.costed(root, entry);
+}
+function total_read_bytes(cost) {
+  return entry_read_set.total([cost.scoped, ...cost.point_of_use.map((one) => one.cost)]).bytes;
+}
+function resident_base_bytes() {
+  return document_reachability.RESIDENT_BASE.reduce(
+    (sum, one) => sum + byte_size(PACKAGE_DIR, one),
+    NOTHING
+  );
+}
+function entry_total_bytes(root, entry) {
+  return total_read_bytes(entry_cost(root, entry)) + resident_base_bytes();
+}
+function recorded_bytes_for(entry) {
+  return ENTRY_READ_BUDGET.find((one) => one.entry === entry)?.bytes;
+}
+function over_budget_message(entry, current_bytes, recorded_bytes) {
+  const next = block_ceiling(current_bytes).toString();
+  const raise_hint = `raise its recorded size to ${next} in scripts/document/entry-read-budget.ts so the reason shows in the PR diff`;
+  return `entry ${entry} reads ${current_bytes.toString()} bytes, over its ${recorded_bytes.toString()}-byte ceiling. Trim what it reads, or ${raise_hint}. Recheck with \`${RECHECK_COMMAND}\`.`;
+}
+function stale_budget_message(entry, recorded_bytes, current_bytes) {
+  const next = block_ceiling(current_bytes).toString();
+  const lower_hint = `lower its recorded size to ${next} in scripts/document/entry-read-budget.ts so the ratchet holds the reduction`;
+  return `entry ${entry} records ${recorded_bytes.toString()} bytes but reads ${current_bytes.toString()}, more than a block above actual. ${lower_hint}.`;
+}
+var entry_read_budget = {
+  ENTRY_READ_BUDGET,
+  RECHECK_COMMAND,
+  entry_total_bytes,
+  over_budget_message,
+  recorded_bytes_for,
+  stale_budget_message
+};
+
+export {
+  document_reachability,
+  entry_read_budget
+};