@joshuafolkken/kit 1.3099.0 → 1.3125.0

package/dist/commands/chunk-RKCENL5P.js

@@ -0,0 +1,271 @@
+import {
+  test_related
+} from "./chunk-ZJ5C6KVM.js";
+import {
+  test_unit_guard
+} from "./chunk-TXXEXJAV.js";
+import {
+  gate_log,
+  verification_tail
+} from "./chunk-VCWNMRH7.js";
+import {
+  moved_paths
+} from "./chunk-NR4BD5DD.js";
+import {
+  review_tree
+} from "./chunk-3OSUM6DM.js";
+import {
+  file_map_stamp
+} from "./chunk-M32UPB2D.js";
+import {
+  verification_inputs
+} from "./chunk-HQ5U6OZR.js";
+import {
+  NOTHING_TO_CHECK_MARKER,
+  NOT_USED_MARKER
+} from "./chunk-IW6NWCSN.js";
+import {
+  josh_verdict
+} from "./chunk-JTU5A4JI.js";
+import {
+  status_icons
+} from "./chunk-65E4OZJ7.js";
+import {
+  gate_labels
+} from "./chunk-WQ6FS544.js";
+import {
+  GATE_COMMAND
+} from "./chunk-TBIX5FRN.js";
+import {
+  stamp_file
+} from "./chunk-VLN6TSPJ.js";
+import {
+  PROJECT_ROOT
+} from "./chunk-3CCGKX7Y.js";
+import {
+  buffered_process
+} from "./chunk-JZHY7D6D.js";
+import {
+  git_command
+} from "./chunk-KMED24C4.js";
+import {
+  MS_PER_SECOND
+} from "./chunk-WPAQUMHC.js";
+
+// scripts/gate/gate-report.ts
+var { FAIL_ICON, PASS_ICON, WARN_ICON } = status_icons;
+function is_gate_step_failed(result) {
+  return buffered_process.is_process_failed(result);
+}
+function is_skip_notice(result) {
+  return result.output.includes(test_unit_guard.SKIP_MARKER);
+}
+var WARNING_MARKERS = ["warning", "Warning", "\u26A0"];
+function has_warnings(result) {
+  return WARNING_MARKERS.some((marker) => result.output.includes(marker));
+}
+var SAFE_CHAIN_BANNER = "safe-chain is not available";
+var PNPM_SCRIPT_HEADER = "$ ";
+var LINT_FILE_PREFIX = "  - ";
+function checker_lines(result) {
+  return result.output.split("\n").filter((line) => !line.includes(SAFE_CHAIN_BANNER) && !line.startsWith(PNPM_SCRIPT_HEADER));
+}
+function has_checker_warning(result) {
+  if (!gate_labels.WARNING_CHECKER_LABELS.includes(result.label)) return false;
+  return checker_lines(result).filter((line) => result.label !== gate_labels.LINT_LABEL || !line.startsWith(LINT_FILE_PREFIX)).some((line) => WARNING_MARKERS.some((marker) => line.includes(marker)));
+}
+function is_unverified_skip(result) {
+  return checker_lines(result).some(
+    (line) => line.includes(test_unit_guard.SKIP_MARKER) && !line.includes(NOT_USED_MARKER)
+  );
+}
+function has_nothing_to_say(result) {
+  return !is_unverified_skip(result) && !has_checker_warning(result);
+}
+var IDLE_MARKERS = [test_unit_guard.SKIP_MARKER, NOTHING_TO_CHECK_MARKER];
+function is_idle_line(line) {
+  return IDLE_MARKERS.some((marker) => line.includes(marker));
+}
+function is_tool_line(line) {
+  return line.trim() !== "";
+}
+function is_idle(result) {
+  const lines = checker_lines(result).filter((line) => is_tool_line(line));
+  return lines.length > 0 && lines.every((line) => is_idle_line(line));
+}
+function should_print_body(result, is_verbose) {
+  if (is_verbose || is_gate_step_failed(result)) return true;
+  return is_skip_notice(result) || has_warnings(result);
+}
+var SECONDS_DECIMALS = 1;
+function format_seconds(elapsed_ms) {
+  return `${(elapsed_ms / MS_PER_SECOND).toFixed(SECONDS_DECIMALS)}s`;
+}
+function gate_step_header(result) {
+  const icon = is_gate_step_failed(result) ? FAIL_ICON : PASS_ICON;
+  const timing = result.reused_at === void 0 ? format_seconds(result.elapsed_ms) : `reused \u2014 inputs unchanged since it passed at ${result.reused_at}`;
+  return `${icon} ${result.label} (pnpm ${result.command}) ${timing}`;
+}
+function print_gate_step(result, is_verbose) {
+  process.stdout.write(`
+${gate_step_header(result)}
+`);
+  if (should_print_body(result, is_verbose) && result.output) {
+    process.stdout.write(`${result.output}
+`);
+  }
+}
+function format_failure_actions(failed) {
+  if (failed.length === 0) return "";
+  const lines = failed.map(
+    (result) => verification_tail.format_rerun(result.label, `pnpm ${result.command}`)
+  );
+  return `${GATE_COMMAND} \u2014 next:
+${lines.join("\n")}
+`;
+}
+function format_budget_notes(results) {
+  const lines = results.flatMap(
+    (result) => result.budget_note === void 0 ? [] : `  ${WARN_ICON} ${result.label} \u2014 ${result.budget_note}`
+  );
+  return lines.length === 0 ? "" : `${lines.join("\n")}
+`;
+}
+function format_green_verdict(results, total) {
+  const has_skip = results.some((result) => is_skip_notice(result));
+  const skipped = has_skip ? results.filter((result) => is_idle(result)).length : 0;
+  const ran = results.length - skipped;
+  if (ran === 0) return josh_verdict.format_gate_unverified(skipped, total);
+  return josh_verdict.format_gate_passed({ ran, skipped }, total);
+}
+function print_gate_summary(results, report, log_path) {
+  const failed = results.filter((result) => is_gate_step_failed(result));
+  const total = format_seconds(report.elapsed_ms);
+  const verdict = failed.length === 0 ? format_green_verdict(results, total) : josh_verdict.format_gate_failed(failed.map((result) => result.label).join(", "), total);
+  const failures = `${format_budget_notes(results)}${format_failure_actions(failed)}`;
+  process.stdout.write(
+    `
+${verification_tail.format_tail({ failures, log: { path: log_path }, verdict })}`
+  );
+}
+function report_gate_steps(results, report) {
+  for (const result of results) print_gate_step(result, report.is_verbose);
+  const entries = results.map((result) => ({
+    header: gate_step_header(result),
+    output: result.output
+  }));
+  const written_log = gate_log.write_gate_log(entries, report.log_path);
+  print_gate_summary(results, report, written_log);
+  return results.filter((result) => is_gate_step_failed(result)).map((result) => result.label);
+}
+var gate_report = {
+  format_budget_notes,
+  format_failure_actions,
+  has_checker_warning,
+  has_nothing_to_say,
+  is_gate_step_failed,
+  report_gate_steps
+};
+
+// scripts/gate/check-inputs.ts
+import path from "node:path";
+function prettier_ignored(root) {
+  const ignore_path = verification_inputs.PRETTIER_IGNORE_FILES.map((name) => path.join(root, name));
+  return async function is_ignored(relative) {
+    try {
+      const prettier = await import("prettier");
+      const info = await prettier.getFileInfo(path.join(root, relative), {
+        ignorePath: ignore_path
+      });
+      return info.ignored;
+    } catch {
+      return false;
+    }
+  };
+}
+async function reads_any(declaration, paths, is_ignored, root) {
+  if (declaration.reads === "recorded") return await test_related.reaches_tests(root, paths);
+  const { is_input } = declaration;
+  if (is_input === void 0) return true;
+  const answers = await Promise.all(
+    paths.map(async (relative) => await is_input(relative, is_ignored))
+  );
+  return answers.includes(true);
+}
+async function touches_inputs(label, paths, is_ignored, root = PROJECT_ROOT) {
+  const declaration = verification_inputs.declaration_of(label);
+  if (declaration === void 0 || verification_inputs.configures(label, paths, root)) return true;
+  return await reads_any(declaration, paths, is_ignored, root);
+}
+var check_inputs = { prettier_ignored, touches_inputs };
+
+// scripts/gate/check-reuse.ts
+var CHECK_PREFIX = "josh-gate-check-";
+function declared_inputs(label) {
+  if (!verification_inputs.is_declared(label)) return void 0;
+  return {
+    fingerprint: () => verification_inputs.fingerprint([label]),
+    touches: async (moved, context) => await check_inputs.touches_inputs(label, moved, context.is_ignored, context.root)
+  };
+}
+function check_stamp(inputs) {
+  return file_map_stamp.create(CHECK_PREFIX, PROJECT_ROOT, inputs.fingerprint);
+}
+function default_records(label) {
+  return stamp_file.stamp_path(`${CHECK_PREFIX}${label}-`, PROJECT_ROOT);
+}
+async function is_stamp_reusable(inputs, stamp, context) {
+  const moved = await moved_paths.moved_since(stamp, context.tree);
+  if (moved === void 0 || !check_stamp(inputs).describes_inputs(stamp)) return false;
+  return !await inputs.touches(moved, context);
+}
+async function reused_at(label, inputs, context) {
+  if (inputs === void 0) return void 0;
+  const stamp = check_stamp(inputs).read(context.records(label));
+  if (stamp === void 0) return void 0;
+  return await is_stamp_reusable(inputs, stamp, context) ? stamp.taken_at : void 0;
+}
+async function read_root() {
+  try {
+    return await git_command.repository_root();
+  } catch {
+    return void 0;
+  }
+}
+async function reusable_checks(labels, tree, records = default_records, inputs_of = declared_inputs) {
+  const root = await read_root();
+  if (root === void 0) return /* @__PURE__ */ new Map();
+  const context = { tree, records, root, is_ignored: check_inputs.prettier_ignored(root) };
+  const answers = await Promise.all(
+    labels.map(
+      async (label) => [label, await reused_at(label, inputs_of(label), context)]
+    )
+  );
+  return new Map(answers.flatMap(([label, at]) => at === void 0 ? [] : [[label, at]]));
+}
+function recordable_inputs(result, inputs_of) {
+  const is_quiet_pass = !gate_report.is_gate_step_failed(result) && gate_report.has_nothing_to_say(result);
+  return is_quiet_pass ? inputs_of(result.label) : void 0;
+}
+function write_records(results, tree, records, inputs_of) {
+  for (const result of results) {
+    const inputs = recordable_inputs(result, inputs_of);
+    if (inputs !== void 0) {
+      check_stamp(inputs).write(tree.files, records(result.label), tree.base);
+    }
+  }
+}
+async function record_green_checks(results, tree, records = default_records, inputs_of = declared_inputs) {
+  try {
+    const after = await review_tree.read_changed_tree();
+    if (JSON.stringify(after) !== JSON.stringify(tree.files)) return;
+    write_records(results, { files: after, base: tree.base }, records, inputs_of);
+  } catch {
+  }
+}
+var check_reuse = { DEFAULT_RECORDS: default_records, record_green_checks, reusable_checks };
+
+export {
+  gate_report,
+  check_reuse
+};

package/dist/commands/chunk-RLWK2CP3.js

@@ -0,0 +1,82 @@
+import {
+  run_board_closed
+} from "./chunk-2TUA6V4F.js";
+import {
+  lane_withdraw
+} from "./chunk-5I3M4B3H.js";
+import {
+  lane_registry
+} from "./chunk-KXZR7UAE.js";
+import {
+  run_event_scope,
+  run_event_stream_emit
+} from "./chunk-XO7S2BTY.js";
+import {
+  session_cite
+} from "./chunk-22DVQCP6.js";
+import {
+  error_text
+} from "./chunk-CDY4NFQG.js";
+import {
+  git_command
+} from "./chunk-KMED24C4.js";
+
+// scripts/lane/lane-withdraw-closed.ts
+var SWEEP_REASON = "its issue was closed as not planned while the lane was still open";
+function is_not_planned(read) {
+  return read !== void 0 && read.is_not_planned && !read.is_merged;
+}
+async function closed_lanes() {
+  const listed = await lane_registry.list_lanes();
+  const lanes = listed.filter((lane) => !lane.is_stranded);
+  const { closed } = await run_board_closed.read_all(lanes.map((lane) => Number(lane.issue)));
+  return lanes.filter((lane) => is_not_planned(closed.get(Number(lane.issue))));
+}
+async function has_unpushed(branch) {
+  try {
+    return await git_command.commit_count_unpushed(branch) > 0;
+  } catch (error) {
+    error_text.trace_swallowed("lane_withdraw_closed.has_unpushed", error);
+    return true;
+  }
+}
+function kept_note(issue, by) {
+  const settled = by === "yield" ? "gave its lane back" : "is closed without a merge";
+  return `${session_cite.issue(issue)} ${settled}, but its branch has commits on no remote, so its lane is kept \u2014 run \`pnpm josh lane:withdraw ${issue}\` by hand.`;
+}
+async function withdraw_lane(lane, reason, by) {
+  if (await has_unpushed(lane.branch)) return { note: kept_note(lane.issue, by), is_retry: false };
+  const outcome = await lane_withdraw.withdraw(lane.issue, reason, by);
+  return {
+    note: lane_withdraw.describe(outcome, lane.issue),
+    is_retry: outcome.kind === "unreadable"
+  };
+}
+async function sweep_lane(lane, events) {
+  if (run_event_scope.is_withdrawn(events, lane.issue)) return void 0;
+  const { note } = await withdraw_lane(lane, SWEEP_REASON, "supervisor");
+  return note;
+}
+async function try_sweep_lane(lane, events) {
+  try {
+    return await sweep_lane(lane, events);
+  } catch (error) {
+    error_text.trace_swallowed("lane_withdraw_closed.sweep_lane", error);
+    return `${session_cite.issue(lane.issue)} could not be withdrawn (${error_text.message_of(error)}); the next pass tries again.`;
+  }
+}
+async function withdraw_closed() {
+  const lanes = await closed_lanes();
+  const events = await run_event_stream_emit.current_events();
+  const notes = [];
+  for (const lane of lanes) {
+    const note = await try_sweep_lane(lane, events);
+    if (note !== void 0) notes.push(note);
+  }
+  return notes;
+}
+var lane_withdraw_closed = { SWEEP_REASON, withdraw_closed, withdraw_lane };
+
+export {
+  lane_withdraw_closed
+};

package/dist/commands/chunk-RMDQQKXD.js

@@ -0,0 +1,179 @@
+import {
+  issue_watch_diff
+} from "./chunk-44UIURBQ.js";
+import {
+  git_gh_issue_read
+} from "./chunk-U6SMBYTN.js";
+import {
+  gh_author_association
+} from "./chunk-DM6I4PYD.js";
+import {
+  git_gh_conditional
+} from "./chunk-V6WWW6HX.js";
+import {
+  git_gh_api_path
+} from "./chunk-RDRN56E4.js";
+import {
+  stamp_file
+} from "./chunk-VLN6TSPJ.js";
+import {
+  PROJECT_ROOT
+} from "./chunk-3CCGKX7Y.js";
+import {
+  git_command
+} from "./chunk-KMED24C4.js";
+import {
+  json_value
+} from "./chunk-HIU2WXB6.js";
+
+// scripts/issue/issue-watch.ts
+import { z } from "zod";
+var RECORD_PREFIX = "josh-issue-watch-";
+var CLOSED_STATE = "closed";
+var record_schema = z.object({
+  issue: z.string(),
+  body: z.string(),
+  last_comment_id: z.number(),
+  acknowledged_at: z.string(),
+  checked_at: z.string(),
+  etag: z.string().optional(),
+  pending: z.string().optional(),
+  // A body edit withheld from the run (`issue_watch_diff.withheld_notice`) — shown, never a hold.
+  notice: z.string().optional(),
+  shown: z.string().optional()
+});
+var issue_schema = z.looseObject({
+  body: z.string().nullish(),
+  state: z.string(),
+  updated_at: z.string().optional(),
+  ...gh_author_association.author_fields_schema
+});
+var UNREADABLE = { kind: "unreadable" };
+function record_path(root = PROJECT_ROOT) {
+  return stamp_file.stamp_path(RECORD_PREFIX, root);
+}
+function read_record(root) {
+  const raw = stamp_file.read_stamp_text(record_path(root));
+  return raw === void 0 ? void 0 : json_value.parse_with(raw, record_schema);
+}
+function write_record(record, root) {
+  stamp_file.replace_stamp(record_path(root), record);
+  return record;
+}
+function clear(root) {
+  stamp_file.remove_stamp(record_path(root));
+}
+async function read_comments(request) {
+  return await issue_watch_diff.parse_comments(
+    await git_gh_issue_read.issue_list_comments(request.issue, request.timeout_ms),
+    request.timeout_ms
+  );
+}
+async function read_snapshot(request, issue, etag) {
+  const [comments, is_body_trusted] = await Promise.all([
+    read_comments(request),
+    gh_author_association.trust_of(gh_author_association.author_of(issue, request.timeout_ms))
+  ]);
+  if (comments === void 0) return UNREADABLE;
+  const snapshot = { body: issue.body ?? "", is_body_trusted, comments };
+  return { kind: "read", snapshot, etag, ...issue.updated_at && { updated_at: issue.updated_at } };
+}
+async function fetch_issue(request) {
+  const read = await git_gh_conditional.read_conditional(
+    git_gh_api_path.issue_api_path(request.issue),
+    request.etag,
+    request.timeout_ms
+  );
+  if (read.kind !== "changed") return read;
+  const fields = json_value.parse_with(read.body, issue_schema);
+  if (fields === void 0) return UNREADABLE;
+  if (fields.state === CLOSED_STATE) return { kind: "closed" };
+  return await read_snapshot(request, fields, read.etag);
+}
+function fresh_record(issue, fetched, now, acknowledged_at = now.toISOString()) {
+  const baseline = issue_watch_diff.baseline_of(fetched.snapshot);
+  const checked_at = now.toISOString();
+  return { issue, ...baseline, acknowledged_at, checked_at, etag: fetched.etag };
+}
+function kept_acknowledgement(previous, issue, fetched) {
+  if (previous?.issue !== issue) return void 0;
+  const diff = issue_watch_diff.unread_diff(previous, fetched.snapshot);
+  return diff === void 0 ? previous.acknowledged_at : void 0;
+}
+async function record_baseline(issue, root, now = /* @__PURE__ */ new Date()) {
+  const fetched = await fetch_issue({ issue });
+  if (fetched.kind !== "read") return false;
+  const acknowledged_at = kept_acknowledgement(read_record(root), issue, fetched);
+  write_record(fresh_record(issue, fetched, now, acknowledged_at), root);
+  return true;
+}
+async function record_baseline_here(issue) {
+  return await record_baseline(issue, await git_command.repository_root());
+}
+async function clear_here() {
+  clear(await git_command.repository_root());
+}
+function with_fetched(record, fetched, checked_at) {
+  if (fetched.kind !== "read") return { ...record, checked_at };
+  const pending = issue_watch_diff.unread_diff(record, fetched.snapshot);
+  const notice = issue_watch_diff.withheld_notice(record, fetched.snapshot);
+  return { ...record, checked_at, etag: fetched.etag, pending, notice };
+}
+function is_due(record, options, now) {
+  return now.getTime() - Date.parse(record.checked_at) >= options.interval_ms;
+}
+async function refresh(record, options, now, root) {
+  const fetched = await fetch_issue({
+    issue: record.issue,
+    etag: record.etag,
+    timeout_ms: options.timeout_ms
+  });
+  if (fetched.kind === "closed") {
+    clear(root);
+    return void 0;
+  }
+  return write_record(with_fetched(record, fetched, now.toISOString()), root);
+}
+async function poll(options, root) {
+  const record = read_record(root);
+  const now = options.now ?? /* @__PURE__ */ new Date();
+  if (record === void 0 || !is_due(record, options, now)) return record;
+  return await refresh(record, options, now, root);
+}
+function news_of(record) {
+  return record.pending ?? record.notice;
+}
+function mark_shown(record, root) {
+  return write_record({ ...record, shown: news_of(record) }, root);
+}
+function landed_at(record, fetched, now) {
+  const times = issue_watch_diff.landed_times(record, fetched.snapshot, fetched.updated_at ?? "");
+  const landed = times.map((time) => Math.min(Date.parse(time) || now.getTime(), now.getTime()));
+  return new Date(Math.max(...landed, Date.parse(record.acknowledged_at) || 0)).toISOString();
+}
+async function acknowledge(root, now = /* @__PURE__ */ new Date()) {
+  const record = read_record(root);
+  if (record === void 0) return void 0;
+  const fetched = await fetch_issue({ issue: record.issue });
+  if (fetched.kind !== "read") return void 0;
+  const diff = issue_watch_diff.unread_diff(record, fetched.snapshot);
+  const acknowledged_at = diff === void 0 ? record.acknowledged_at : landed_at(record, fetched, now);
+  write_record(fresh_record(record.issue, fetched, now, acknowledged_at), root);
+  return { issue: record.issue, diff };
+}
+var issue_watch = {
+  acknowledge,
+  clear,
+  clear_here,
+  mark_shown,
+  news_of,
+  poll,
+  read_record,
+  record_baseline,
+  record_baseline_here,
+  record_path
+};
+
+export {
+  issue_watch
+};