@joshuafolkken/kit 1.3101.0 → 1.3125.0

package/dist/commands/chunk-OHZ6GLEJ.js

@@ -0,0 +1,74 @@
+import {
+  git_gh_issue_write
+} from "./chunk-C3Y42PHX.js";
+import {
+  JOSH_TMP_DIRECTORY
+} from "./chunk-LAYSCY4L.js";
+import {
+  lane_registry
+} from "./chunk-KXZR7UAE.js";
+import {
+  atomic_write
+} from "./chunk-KSR23NYN.js";
+import {
+  file_reader
+} from "./chunk-ZNX2LJCQ.js";
+
+// scripts/backlog/backlog-triage-approval.ts
+import { mkdirSync } from "node:fs";
+import path from "node:path";
+var HEADING = "## \u898F\u6A21\u627F\u8A8D\uFF08backlog:triage --adopt\uFF09";
+var JSON_INDENT = "	";
+async function file_of(issue) {
+  const root = await lane_registry.main_repository_root();
+  return path.join(root, JOSH_TMP_DIRECTORY, `size-approval-${issue}.json`);
+}
+async function existing_file(issue) {
+  const file = await file_of(issue);
+  return file_reader.read_if_readable(file) === void 0 ? void 0 : file;
+}
+function range_text({ range }) {
+  return [
+    HEADING,
+    "",
+    `- \u7BC4\u56F2\uFF08paths\uFF09: \`${range.paths.join("`, `")}\``,
+    `- declared_files: ${String(range.files.declared)} / max_files: ${String(range.files.max)}`,
+    `- declared_lines: ${String(range.lines.declared)} / max_lines: ${String(range.lines.max)}`
+  ].join("\n");
+}
+async function source_of(grant) {
+  const range = range_text(grant);
+  const written = grant.comments.find(
+    (comment) => comment.is_trusted === true && comment.body.startsWith(`${range}
+`)
+  )?.html_url;
+  return written ?? await git_gh_issue_write.issue_comment(grant.issue, `${range}
+- \u7406\u7531: ${grant.reason}`);
+}
+function json_of(grant, source) {
+  const { issue, reason, range } = grant;
+  const approval = {
+    issue: Number(issue),
+    paths: range.paths,
+    source,
+    rationale: reason,
+    declared_lines: range.lines.declared,
+    max_lines: range.lines.max,
+    declared_files: range.files.declared,
+    max_files: range.files.max
+  };
+  return `${JSON.stringify(approval, void 0, JSON_INDENT)}
+`;
+}
+async function write(approval) {
+  const source = await source_of(approval);
+  const file = await file_of(approval.issue);
+  mkdirSync(path.dirname(file), { recursive: true });
+  atomic_write.replace_file(file, json_of(approval, source));
+  return file;
+}
+var backlog_triage_approval = { existing_file, write };
+
+export {
+  backlog_triage_approval
+};

package/dist/commands/chunk-OJO5AADO.js

@@ -0,0 +1,322 @@
+import {
+  backlog_hold_codes
+} from "./chunk-MXPCEZL5.js";
+import {
+  backlog_next_shared
+} from "./chunk-TJAGKUS2.js";
+import {
+  backlog_wait_cause
+} from "./chunk-YSBLGTDZ.js";
+import {
+  lane_room
+} from "./chunk-Z7R6JWN7.js";
+import {
+  lane_capacity
+} from "./chunk-6HJ5CJSJ.js";
+import {
+  epic_triage
+} from "./chunk-VQRT32JB.js";
+import {
+  backlog_drive_restore,
+  backlog_offer_exclude
+} from "./chunk-52CGT2IN.js";
+import {
+  git_gh_command
+} from "./chunk-VJNE7W7O.js";
+import {
+  lane_ledger
+} from "./chunk-I2RBOH4F.js";
+import {
+  run_headless
+} from "./chunk-UACWDTJ5.js";
+import {
+  lane_registry
+} from "./chunk-KXZR7UAE.js";
+import {
+  run_event_scope,
+  run_event_stream_emit
+} from "./chunk-XO7S2BTY.js";
+import {
+  run_event_stream
+} from "./chunk-373P5MM2.js";
+import {
+  issue_cite
+} from "./chunk-HQ2HSZBN.js";
+import {
+  run_invocation
+} from "./chunk-JSJS3OT7.js";
+import {
+  issue_number_shape
+} from "./chunk-G75GWNNY.js";
+import {
+  MS_PER_MINUTE
+} from "./chunk-WPAQUMHC.js";
+
+// scripts/backlog/backlog-hold-text.ts
+var {
+  DRAINED_REASON,
+  DRIVERLESS_PREFIX,
+  HAND_BACK_PREFIX,
+  MEMORY_REASON,
+  OFFER_PREFIX,
+  REASON_SEPARATOR,
+  USAGE_LIMIT_REASON
+} = backlog_hold_codes;
+var NOT_FOUND = -1;
+var AWAIT_TRIAGE = "open issues await your triage";
+var HAND_BACK_TEXT = /* @__PURE__ */ new Map([
+  ["judge", AWAIT_TRIAGE],
+  ["triage", "a parked issue awaits your triage"],
+  ["merge", "the driver paused after a merge; the session restarts it"],
+  ["launch", "a lane launch failed; the session restarts the driver"],
+  ["offer", "the backlog offer failed; the session restarts the driver"],
+  ["window", "the run's time window closed; the session restarts the driver"],
+  [DRAINED_REASON, "the backlog had nothing to start; the session restarts the driver"]
+]);
+var PERSON_HAND_BACKS = /* @__PURE__ */ new Set(["judge", "triage"]);
+var OFFER_TEXT = /* @__PURE__ */ new Map([
+  ["solo", "a run:solo issue must finish first"],
+  ["blocked", "every queued issue is blocked"],
+  ["exhausted", "the backlog has nothing left to start"],
+  ["untriaged", AWAIT_TRIAGE],
+  ["parked", "parked issues await your decision"],
+  ["unreadable", "the backlog could not be read"]
+]);
+var CAUSE_TEXT = {
+  chain: "other issues",
+  gate: "a start condition",
+  publication: "their publication",
+  lane: "a running lane"
+};
+var CAUSE_JOINER = " or ";
+var MEMORY_TEXT = "memory pressure is high; lanes resume when it eases";
+var USAGE_LIMIT_TEXT = "the usage limit is reached; lanes resume when it resets";
+var DRIVERLESS_TEXT = "no driver is running";
+function rest_after(code, prefix) {
+  const head = `${prefix}${REASON_SEPARATOR}`;
+  return code.startsWith(head) ? code.slice(head.length) : void 0;
+}
+function hand_back_text(reason) {
+  return HAND_BACK_TEXT.get(reason) ?? `the driver paused (${reason}); the session restarts it`;
+}
+function cause_text(detail) {
+  const causes = backlog_wait_cause.causes_of_tag(detail);
+  if (causes === void 0) return void 0;
+  return `queued issues wait on ${causes.map((cause) => CAUSE_TEXT[cause]).join(CAUSE_JOINER)}`;
+}
+function offer_text(rest) {
+  const index = rest.indexOf(REASON_SEPARATOR);
+  const detail = index === NOT_FOUND ? "" : rest.slice(index + REASON_SEPARATOR.length);
+  return OFFER_TEXT.get(detail) ?? cause_text(detail) ?? `the backlog is waiting (${rest})`;
+}
+function prefixed_text(code) {
+  const hand_back = rest_after(code, HAND_BACK_PREFIX);
+  if (hand_back !== void 0) return hand_back_text(hand_back);
+  const offer = rest_after(code, OFFER_PREFIX);
+  return offer === void 0 ? void 0 : offer_text(offer);
+}
+function whole_text(code) {
+  if (code === MEMORY_REASON) return MEMORY_TEXT;
+  return code === USAGE_LIMIT_REASON ? USAGE_LIMIT_TEXT : void 0;
+}
+function text_of(code) {
+  if (code.startsWith(DRIVERLESS_PREFIX)) {
+    return `${DRIVERLESS_TEXT}; ${text_of(code.slice(DRIVERLESS_PREFIX.length))}`;
+  }
+  return prefixed_text(code) ?? whole_text(code) ?? code;
+}
+function is_driver_restart(code) {
+  const own = code.startsWith(DRIVERLESS_PREFIX) ? code.slice(DRIVERLESS_PREFIX.length) : code;
+  const reason = rest_after(own, HAND_BACK_PREFIX);
+  return reason !== void 0 && !PERSON_HAND_BACKS.has(reason);
+}
+var backlog_hold_text = { is_driver_restart, text_of };
+
+// scripts/backlog/backlog-stalled.ts
+var STALL_THRESHOLD_MINUTES = 10;
+var STALL_THRESHOLD_MS = STALL_THRESHOLD_MINUTES * MS_PER_MINUTE;
+var NONE = 0;
+var STALLED = "stalled";
+var OK = "ok";
+var UNREADABLE = "unreadable";
+function is_stalled(reading, threshold_ms) {
+  return reading.ready_count > NONE && reading.free_lanes > NONE && reading.waiting_ms > threshold_ms;
+}
+function assess(reading, threshold_ms) {
+  if (reading === void 0) return UNREADABLE;
+  if (is_stalled(reading, threshold_ms)) return STALLED;
+  return OK;
+}
+function dispatch_reference_iso(events) {
+  const last_launch = events.findLast(
+    (event) => event.kind === run_event_stream.EVENT_KIND.CHILD_LAUNCH
+  );
+  return last_launch?.at ?? events[0]?.at;
+}
+function dispatch_reference_ms(events) {
+  const iso = dispatch_reference_iso(events);
+  const at = iso === void 0 ? NaN : Date.parse(iso);
+  return Number.isNaN(at) ? void 0 : at;
+}
+function dispatch_age_ms(events, now_ms) {
+  const at = dispatch_reference_ms(events);
+  return at === void 0 ? void 0 : now_ms - at;
+}
+function open_offerable_ms(entries, reference_ms) {
+  const newest = entries.findLast(
+    (entry) => entry.kind === lane_ledger.KIND.OFFERABLE && Date.parse(entry.at) >= reference_ms
+  );
+  if (newest?.kind !== lane_ledger.KIND.OFFERABLE || !newest.is_offerable) return void 0;
+  return Date.parse(newest.at);
+}
+function open_hold(entries) {
+  const { HELD, RELEASED, DISPATCH } = lane_ledger.KIND;
+  const hold_kinds = /* @__PURE__ */ new Set([HELD, RELEASED, DISPATCH]);
+  const newest = entries.findLast((entry) => hold_kinds.has(entry.kind));
+  return newest?.kind === lane_ledger.KIND.HELD ? newest.reason : void 0;
+}
+function describe(reading) {
+  const minutes = Math.floor(reading.waiting_ms / MS_PER_MINUTE);
+  const held = reading.hold === void 0 ? "" : ` (${backlog_hold_text.text_of(reading.hold)})`;
+  return `${String(reading.ready_count)} ready, ${String(reading.free_lanes)} free lane(s), ${String(minutes)}m waiting with both${held}`;
+}
+function ready_tokens(out) {
+  return out.split("\n").map((token) => token.trim()).filter((token) => issue_number_shape.is_issue_number(token));
+}
+function count_ready_tokens(out) {
+  return ready_tokens(out).length;
+}
+function needs_triage(out) {
+  return out.split("\n").some((token) => token.trim() === epic_triage.TRIAGE_VERDICT);
+}
+var backlog_stalled = {
+  STALLED,
+  OK,
+  UNREADABLE,
+  STALL_THRESHOLD_MS,
+  assess,
+  count_ready_tokens,
+  describe,
+  dispatch_age_ms,
+  needs_triage,
+  open_hold,
+  open_offerable_ms,
+  ready_tokens
+};
+
+// scripts/backlog/backlog-ready.ts
+var NO_FREE = 0;
+var NONE2 = 0;
+var lane_room2 = lane_room.read;
+async function lane_use(lanes) {
+  const room = await lane_room2(lanes);
+  return room.use;
+}
+function free_of(limit, use) {
+  return lane_capacity.free_lanes(limit, use.occupied, use.seated);
+}
+async function count_in(room) {
+  const limit = await lane_capacity.lane_limit();
+  if (limit.kind !== "limit") return void 0;
+  return { limit: limit.limit, free: free_of(limit.limit, room.use) };
+}
+async function free_lanes_beside(lanes) {
+  const count = await count_in(await lane_room2(lanes));
+  return count?.free;
+}
+async function free_under(limit) {
+  return free_of(limit, await lane_use());
+}
+async function free_lane_count() {
+  return await free_lanes_beside(await lane_registry.list_lanes()) ?? NO_FREE;
+}
+async function drive_limit() {
+  const limit = await lane_capacity.lane_limit();
+  if (limit.kind !== "limit") throw new Error(limit.problem);
+  return limit.limit;
+}
+async function drive_free_lane_count() {
+  return await free_under(await drive_limit());
+}
+async function drive_limit_room() {
+  const limit = await drive_limit();
+  const use = await lane_use();
+  return lane_capacity.limit_room(limit, use.occupied);
+}
+function drains_pool(carry) {
+  return carry === void 0 || !run_invocation.has_only(carry.invocation);
+}
+async function stream_exclude(carry) {
+  const target = await run_event_stream_emit.stream_target();
+  if (target === void 0 || carry === void 0) return [];
+  const scope = run_event_scope.scope_of({ kind: "carried", carry });
+  const events = run_event_scope.scoped_events(run_event_stream.read_events(target), scope) ?? [];
+  return backlog_drive_restore.offer_exclude(events);
+}
+async function read_backlog_next(timeout_ms) {
+  const carry = await run_headless.current_carry();
+  if (!drains_pool(carry)) return void 0;
+  const argv = ["backlog:next", ...backlog_offer_exclude.exclude_argv(await stream_exclude(carry))];
+  return await backlog_next_shared.read(argv, timeout_ms === void 0, timeout_ms);
+}
+async function ready_issues() {
+  const result = await read_backlog_next();
+  return result === void 0 ? [] : backlog_stalled.ready_tokens(result.out);
+}
+var DEFAULT_PORTS = { free_lane_count, ready_issues };
+async function read_ready(ports = DEFAULT_PORTS) {
+  const free_lanes = await ports.free_lane_count();
+  if (free_lanes <= NO_FREE) return { issues: [], free_lanes };
+  return { issues: await ports.ready_issues(), free_lanes };
+}
+function ready_line(reading, slug) {
+  if (reading.issues.length === NONE2 || reading.free_lanes <= NO_FREE) return void 0;
+  const cite = issue_cite.citer(slug, /* @__PURE__ */ new Map());
+  const issues = reading.issues.map((issue) => cite(issue)).join(" ");
+  return `ready ${issues} \xB7 free lanes ${String(reading.free_lanes)}`;
+}
+async function parent_ready_line(ports, is_parent, read_repo) {
+  if (!await is_parent()) return void 0;
+  const reading = await read_ready(ports);
+  return reading.issues.length === NONE2 ? void 0 : ready_line(reading, await read_repo());
+}
+function print_line(line) {
+  if (line !== void 0) console.info(line);
+}
+async function print_ready_line(ports = DEFAULT_PORTS, is_parent = run_headless.is_backlog_parent, read_repo = git_gh_command.repo_get_name_with_owner) {
+  try {
+    print_line(await parent_ready_line(ports, is_parent, read_repo));
+  } catch {
+  }
+}
+var OFFER_HINT = "\u21BB backlogrun parent: a child just entered an epic \u2014 run `pnpm josh backlog:offer` next, so a runnable filing is dispatched now rather than on the next wake.";
+async function print_offer_hint(is_parent = run_headless.is_backlog_parent) {
+  try {
+    if (await is_parent()) console.info(OFFER_HINT);
+  } catch {
+  }
+}
+var backlog_ready = {
+  DEFAULT_PORTS,
+  OFFER_HINT,
+  read_backlog_next,
+  print_offer_hint,
+  free_lane_count,
+  free_lanes_beside,
+  count_in,
+  lane_room: lane_room2,
+  lane_use,
+  drive_free_lane_count,
+  drive_limit_room,
+  drains_pool,
+  print_ready_line,
+  read_ready,
+  ready_issues,
+  ready_line
+};
+
+export {
+  backlog_hold_text,
+  backlog_stalled,
+  backlog_ready
+};

package/dist/commands/chunk-ORFXTHXU.js

@@ -0,0 +1,108 @@
+import {
+  git_gh_etag_read
+} from "./chunk-V6WWW6HX.js";
+import {
+  MEASURED_LABEL
+} from "./chunk-QQBMVC5W.js";
+import {
+  git_gh_api_path
+} from "./chunk-RDRN56E4.js";
+import {
+  git_gh_exec,
+  read_json_listing
+} from "./chunk-NAZ753DE.js";
+
+// scripts/issue/issue-merged.ts
+import { z } from "zod";
+var CLOSED_EVENT = "closed";
+var REOPENED_EVENT = "reopened";
+var LABELED_EVENT = "labeled";
+var UNLABELED_EVENT = "unlabeled";
+var CROSS_REFERENCED_EVENT = "cross-referenced";
+var MERGED_REFERENCE = "merged-reference";
+var PER_PAGE = 100;
+var COMPLETED_REASONS = /* @__PURE__ */ new Set(["", "completed"]);
+var FIELD_SEPARATOR = "	";
+var LINE_SEPARATOR = "\n";
+var TIMELINE_FILTER = [
+  ".[]",
+  `| if .event == "${CROSS_REFERENCED_EVENT}" and .source.issue.pull_request.merged_at != null`,
+  String.raw`then "${MERGED_REFERENCE}\t"`,
+  `elif .event == "${CLOSED_EVENT}" or .event == "${REOPENED_EVENT}"`,
+  String.raw`then "\(.event)\t\(.state_reason // "")"`,
+  `elif (.event == "${LABELED_EVENT}" or .event == "${UNLABELED_EVENT}") and .label.name == "${MEASURED_LABEL}"`,
+  String.raw`then "\(.event)\t"`,
+  "else empty end"
+].join(" ");
+function parse_rows(raw) {
+  return raw.split(LINE_SEPARATOR).filter((line) => line !== "").map((line) => {
+    const [event = "", reason = ""] = line.split(FIELD_SEPARATOR);
+    return { event, reason };
+  });
+}
+function is_measured(rows) {
+  const last = rows.findLast((row) => row.event === LABELED_EVENT || row.event === UNLABELED_EVENT);
+  return last?.event === LABELED_EVENT;
+}
+function is_merged_close(rows) {
+  const last = rows.findLast((row) => row.event === CLOSED_EVENT || row.event === REOPENED_EVENT);
+  if (last?.event !== CLOSED_EVENT || !COMPLETED_REASONS.has(last.reason)) return false;
+  return is_measured(rows) || rows.some((row) => row.event === MERGED_REFERENCE);
+}
+var pull_request_schema = z.object({ merged_at: z.string().nullish() });
+var source_schema = z.object({
+  issue: z.object({ pull_request: pull_request_schema.optional() }).optional()
+});
+var event_schema = z.object({
+  event: z.string().default(""),
+  state_reason: z.string().nullish().transform((reason) => reason ?? ""),
+  label: z.object({ name: z.string() }).optional(),
+  source: source_schema.optional()
+});
+var STATE_EVENTS = /* @__PURE__ */ new Set([CLOSED_EVENT, REOPENED_EVENT]);
+var LABEL_EVENTS = /* @__PURE__ */ new Set([LABELED_EVENT, UNLABELED_EVENT]);
+function merged_at_of(entry) {
+  return entry.source?.issue?.pull_request?.merged_at;
+}
+function is_merged_reference(entry) {
+  return entry.event === CROSS_REFERENCED_EVENT && typeof merged_at_of(entry) === "string";
+}
+function is_measured_change(entry) {
+  return LABEL_EVENTS.has(entry.event) && entry.label?.name === MEASURED_LABEL;
+}
+function row_of(entry) {
+  if (is_merged_reference(entry)) return [{ event: MERGED_REFERENCE, reason: "" }];
+  if (STATE_EVENTS.has(entry.event)) return [{ event: entry.event, reason: entry.state_reason }];
+  return is_measured_change(entry) ? [{ event: entry.event, reason: "" }] : [];
+}
+function page_rows(raw) {
+  const page = read_json_listing(raw, event_schema);
+  if (page.kind !== "read" || page.rows.length >= PER_PAGE) return void 0;
+  return page.rows.flatMap((entry) => row_of(entry));
+}
+async function read_rows(issue) {
+  const path = `${git_gh_api_path.issue_api_path(issue)}/timeline?per_page=${String(PER_PAGE)}`;
+  const rows = page_rows(await git_gh_etag_read.read(path));
+  if (rows !== void 0) return rows;
+  const raw = await git_gh_exec.exec_gh_api({
+    path,
+    should_paginate: true,
+    jq_filter: TIMELINE_FILTER
+  });
+  return parse_rows(raw);
+}
+async function read_merge_state(issue) {
+  try {
+    return is_merged_close(await read_rows(issue));
+  } catch {
+    return void 0;
+  }
+}
+async function read_merged(issue) {
+  return await read_merge_state(issue) ?? false;
+}
+var issue_merged = { is_merged_close, page_rows, parse_rows, read_merge_state, read_merged };
+
+export {
+  issue_merged
+};