@joshuafolkken/kit 1.3044.0 → 1.3099.0

package/dist/commands/chunk-N4EMFHQ6.js

@@ -0,0 +1,114 @@
+import {
+  whole_suite_files
+} from "./chunk-WEUUJIWQ.js";
+import {
+  test_declared_logic
+} from "./chunk-7HCPRVMB.js";
+import {
+  git_spawn
+} from "./chunk-B5HP6T4L.js";
+
+// scripts/test/direct-importers.ts
+import { readFileSync } from "node:fs";
+import path from "node:path";
+var PACKAGE_FILE = "package.json";
+var WILDCARD = "*";
+var CURRENT_DIRECTORY_PREFIX = "./";
+var NUL = "\0";
+var SPECIFIER_PATTERN = /(?:\bfrom\s+|\bimport\s*\(\s*|\bimport\s+|\bmock\(\s*)["']([^"']+)["']/gu;
+function module_key(file) {
+  const posix = file.split(path.sep).join(path.posix.sep);
+  return posix.slice(0, posix.length - path.posix.extname(posix).length);
+}
+function specifiers_of(source) {
+  return [...source.matchAll(SPECIFIER_PATTERN)].flatMap((match) => match.slice(1));
+}
+function alias_target(specifier, imports) {
+  const exact = imports[specifier];
+  if (exact !== void 0) return exact;
+  const key = Object.keys(imports).find(
+    (pattern) => pattern.endsWith(WILDCARD) && specifier.startsWith(pattern.slice(0, -1))
+  );
+  if (key === void 0) return void 0;
+  return imports[key]?.split(WILDCARD).join(specifier.slice(key.length - 1));
+}
+function relative_target(specifier, from) {
+  return path.posix.join(path.posix.dirname(from), specifier);
+}
+function resolve_specifier(specifier, from, imports) {
+  if (specifier.startsWith(".")) return module_key(relative_target(specifier, from));
+  const target = alias_target(specifier, imports);
+  if (target === void 0) return void 0;
+  return module_key(path.posix.normalize(target.replace(CURRENT_DIRECTORY_PREFIX, "")));
+}
+function names_any(source, from, scoped, imports) {
+  return specifiers_of(source).some((specifier) => {
+    const resolved = resolve_specifier(specifier, from, imports);
+    return resolved !== void 0 && scoped.has(resolved);
+  });
+}
+function read_imports(root) {
+  try {
+    const parsed = JSON.parse(readFileSync(path.join(root, PACKAGE_FILE), "utf8"));
+    const imports = Reflect.get(new Object(parsed), "imports");
+    if (typeof imports !== "object" || imports === null) return {};
+    return Object.fromEntries(
+      Object.entries(imports).filter(
+        (entry) => typeof entry[1] === "string"
+      )
+    );
+  } catch {
+    return {};
+  }
+}
+function read_source_at(root, file) {
+  try {
+    return readFileSync(path.join(root, file), "utf8");
+  } catch {
+    return void 0;
+  }
+}
+function source_reader(root) {
+  return { imports: read_imports(root), read_source: (file) => read_source_at(root, file) };
+}
+async function test_files(root) {
+  const listed = await git_spawn.read(["-C", root, "ls-files", "-coz", "--exclude-standard"]);
+  return listed.split(NUL).filter((file) => test_declared_logic.is_test_file(file));
+}
+function importers_among(file, tests, reader) {
+  const scoped = /* @__PURE__ */ new Set([module_key(file)]);
+  return tests.filter((test) => {
+    const source = reader.read_source(test);
+    return source !== void 0 && names_any(source, test, scoped, reader.imports);
+  });
+}
+function every_test_imports_of(files) {
+  return files.filter((file) => whole_suite_files.EVERY_TEST_IMPORTS.has(path.normalize(file)));
+}
+function is_every_test_import(root, argument) {
+  return whole_suite_files.EVERY_TEST_IMPORTS.has(path.relative(root, path.resolve(argument)));
+}
+async function importers_of(root, files) {
+  if (files.length === 0) return /* @__PURE__ */ new Map();
+  const tests = await test_files(root);
+  const reader = source_reader(root);
+  return new Map(files.map((file) => [file, importers_among(file, tests, reader)]));
+}
+async function every_test_importers(root, files) {
+  return await importers_of(root, every_test_imports_of(files));
+}
+var direct_importers = {
+  every_test_importers,
+  every_test_imports_of,
+  importers_of,
+  is_every_test_import,
+  module_key,
+  names_any,
+  resolve_specifier,
+  source_reader,
+  specifiers_of
+};
+
+export {
+  direct_importers
+};

package/dist/commands/chunk-N4P64UIH.js

@@ -0,0 +1,211 @@
+import {
+  run_merge,
+  run_merge_cli
+} from "./chunk-LJVZWE3A.js";
+import {
+  run_wake_handoff
+} from "./chunk-ICPVBHIX.js";
+import {
+  issue_merged
+} from "./chunk-E3YKMCCJ.js";
+import {
+  backlog_drive_adopt
+} from "./chunk-GMVN6ZP2.js";
+import {
+  issue_state_cli
+} from "./chunk-E4PFCTXN.js";
+import {
+  run_carry_ended
+} from "./chunk-KPAJBJXG.js";
+import {
+  stash_orphans
+} from "./chunk-WR5PKCQW.js";
+import {
+  telegram_notify
+} from "./chunk-MDKRTUE4.js";
+import {
+  git_stash
+} from "./chunk-WROJTXWZ.js";
+import {
+  backlogrun_launch
+} from "./chunk-QTQAI2M2.js";
+import {
+  lane_handoff
+} from "./chunk-BRMJVCP7.js";
+import {
+  session_cite
+} from "./chunk-22DVQCP6.js";
+import {
+  bounded_pool
+} from "./chunk-EBVS2LKX.js";
+import {
+  run_carry
+} from "./chunk-DS53UUDH.js";
+
+// scripts/backlog/backlog-preflight.ts
+function launch_started(git_directory) {
+  const started_at = backlogrun_launch.pending_launch(git_directory)?.started_at;
+  return started_at === void 0 ? void 0 : new Date(started_at);
+}
+function launcher_owner(provider) {
+  return { ...run_carry.owner_of(process.pid), transcript: void 0, provider };
+}
+function preflight(request) {
+  const target = run_carry.carry_path(request.git_directory);
+  const owner = launcher_owner(request.provider);
+  const started = launch_started(request.git_directory);
+  const begun = run_carry.begin_carry(target, request.invocation, owner, started);
+  if (begun === void 0) return { kind: "standing" };
+  run_wake_handoff.hand_off(target);
+  return { kind: "handed-off", carry: { ...begun, is_handed_off: true } };
+}
+function is_driven_for(git_directory, carry, owner) {
+  const parent = backlogrun_launch.running_parent(git_directory);
+  return parent !== void 0 && parent === owner.pid && carry.owner_pid !== parent;
+}
+var backlog_preflight = { is_driven_for, preflight };
+
+// scripts/run/merge/run-merge-collect.ts
+async function closed_merge(child) {
+  return await issue_merged.read_merged(child) ? { merged_pr: void 0 } : void 0;
+}
+async function open_merge(child, read) {
+  const merged_pr = await run_merge_cli.read_merged_pr(child, read);
+  return merged_pr === void 0 ? void 0 : { merged_pr };
+}
+async function merge_of(child) {
+  const read = await issue_state_cli.read_issue(child);
+  if (read.kind !== "state") return void 0;
+  const is_closed = run_merge.classify_child(read.state) === "merged";
+  return is_closed ? await closed_merge(child) : await open_merge(child, read);
+}
+async function collect_lane(lane, owner) {
+  if (lane_handoff.is_ship_running(lane.issue, process.cwd())) return;
+  const merge = await merge_of(lane.issue);
+  if (merge === void 0) return;
+  const ctx = { child: lane.issue, epic: void 0, repo: void 0, over: void 0, owner };
+  await run_merge_cli.record_merged({ ...ctx, merged_pr: merge.merged_pr });
+}
+async function collect_all(lanes, owner) {
+  for (const lane of lanes) {
+    try {
+      await collect_lane(lane, owner);
+    } catch (error) {
+      console.error(
+        `run:carry: lane ${session_cite.issue(lane.issue)} was not collected: ${String(error)}`
+      );
+    }
+  }
+}
+function owner_of(carry) {
+  return { pid: carry.owner_pid, start: carry.owner_start, transcript: carry.owner_transcript };
+}
+async function collect_carried(carry) {
+  await collect_all(await backlog_drive_adopt.active_lanes(), owner_of(carry));
+}
+async function collect_merged(directory) {
+  const read = run_carry.read_carry(run_carry.carry_path(directory));
+  if (read.kind !== "carried") return;
+  try {
+    await collect_carried(read.carry);
+  } catch (error) {
+    console.error(`run:carry: the run's merged lanes were not collected: ${String(error)}`);
+  }
+}
+var run_merge_collect = { collect_merged };
+
+// scripts/run/run-stop-notify.ts
+var STOP_TITLE = "backlogrun stopped";
+var STOP_RECOVERY = "If this did not arrive, `pnpm josh run:wake --list` relays the last progress line.";
+function plan(read, reason) {
+  if (reason === void 0 || reason.length === 0 || read.kind !== "carried") return void 0;
+  return { reason };
+}
+async function announce(notice) {
+  return await telegram_notify.confirm({
+    issue_title: STOP_TITLE,
+    body: notice.reason,
+    recovery: STOP_RECOVERY,
+    recommended: "Resolve the reason above, then run `backlogrun` again",
+    alternatives: ["Leave the backlog stopped until a later session"]
+  });
+}
+var run_stop_notify = {
+  announce,
+  plan
+};
+
+// scripts/run/carry/run-carry-stash.ts
+var READ_CONCURRENCY = 8;
+var CLOSED_STATE = "CLOSED";
+var FAILURE_NOTE = "The closed-issue stash check failed; review the stack by hand with `git stash list`.";
+async function verdict_of(issue) {
+  const read = await issue_state_cli.read_issue(issue);
+  if (read.kind !== "state") return "unreadable";
+  return read.state.state === CLOSED_STATE ? "closed" : "open";
+}
+async function read_closed(issues) {
+  const verdicts = await bounded_pool.bounded_map(
+    issues,
+    READ_CONCURRENCY,
+    async (issue) => await verdict_of(issue)
+  );
+  return {
+    closed: new Set(issues.filter((_issue, index) => verdicts[index] === "closed")),
+    unreadable: issues.filter((_issue, index) => verdicts[index] === "unreadable")
+  };
+}
+function unreadable_note(unreadable) {
+  const issues = unreadable.map((issue) => session_cite.issue(issue)).join(", ");
+  return `Could not read ${issues}, so a stash of theirs may be missing above; ${FAILURE_NOTE}`;
+}
+async function report_orphans() {
+  try {
+    const entries = await git_stash.list();
+    const read = await read_closed(stash_orphans.issues_of(entries));
+    const report = stash_orphans.format_report(stash_orphans.orphans(entries, read.closed));
+    if (report !== void 0) console.error(report);
+    if (read.unreadable.length > 0) console.error(unreadable_note(read.unreadable));
+  } catch {
+    console.error(FAILURE_NOTE);
+  }
+}
+var run_carry_stash = { FAILURE_NOTE, report_orphans };
+
+// scripts/run/carry/run-carry-end.ts
+async function announce_stop(read, request) {
+  if (!request.is_announced) return;
+  const notice = run_stop_notify.plan(read, request.stopped);
+  if (notice !== void 0) await run_stop_notify.announce(notice);
+}
+async function report_end(read) {
+  if (read.kind === "none") return;
+  await run_carry_stash.report_orphans();
+}
+function keep_ended(directory, read, stopped) {
+  try {
+    run_carry_ended.record_ended(run_carry_ended.ended_path(directory), read, /* @__PURE__ */ new Date(), stopped);
+  } catch (error) {
+    console.error(`run:carry: the ended run was not recorded for run:board: ${String(error)}`);
+  }
+}
+function close_record(directory, stopped) {
+  const target = run_carry.carry_path(directory);
+  const read = run_carry.read_carry(target);
+  keep_ended(directory, read, stopped);
+  run_carry.end_carry(target);
+  return read;
+}
+async function end_run(directory, request) {
+  await run_merge_collect.collect_merged(directory);
+  const read = close_record(directory, request.stopped);
+  await announce_stop(read, request);
+  await report_end(read);
+  return read;
+}
+var run_carry_end = { end_run };
+
+export {
+  backlog_preflight,
+  run_carry_end
+};

package/dist/commands/chunk-NABSSY4P.js

@@ -0,0 +1,204 @@
+import {
+  acceptance_map
+} from "./chunk-5PCK53WP.js";
+import {
+  git_gh_command
+} from "./chunk-NRULNBYI.js";
+import {
+  pr_classification
+} from "./chunk-RS5HBJY6.js";
+import {
+  animation_helpers
+} from "./chunk-GO3GH7FG.js";
+import {
+  pr_info_schema
+} from "./chunk-34DND4BA.js";
+import {
+  session_cite
+} from "./chunk-22DVQCP6.js";
+import {
+  issue_cite
+} from "./chunk-HQ2HSZBN.js";
+import {
+  json_value
+} from "./chunk-HIU2WXB6.js";
+
+// scripts/gh/git-pr-error.ts
+function is_pr_already_exists_message(message) {
+  return message === "PR_ALREADY_EXISTS";
+}
+function has_error_cause(error) {
+  return error.cause instanceof Error && is_pr_already_exists_message(error.cause.message);
+}
+function is_pr_already_exists_error(error) {
+  if (error instanceof Error) {
+    if (is_pr_already_exists_message(error.message)) return true;
+    return has_error_cause(error);
+  }
+  return false;
+}
+var git_pr_error = {
+  is_pr_already_exists_error
+};
+
+// scripts/gh/git-pr-messages.ts
+function display_pr_opened_message() {
+  console.info("");
+  console.info("\u2705 Pull request opened.");
+  console.info("");
+  console.info("`pnpm josh followup` waits for the checks and merges.");
+}
+function display_pr_url(pr_url) {
+  console.info("");
+  console.info(`\u{1F517} PR: ${pr_url}`);
+}
+function display_merged_pr_message() {
+  console.info("");
+  console.info("\u2139\uFE0F  Existing PR is already merged. Creating a new PR...");
+  console.info("");
+}
+function display_pr_exists_message() {
+  console.info("");
+  console.info("\u2139\uFE0F  Pull request already exists.");
+  console.info("");
+}
+var git_pr_messages = {
+  display_pr_opened_message,
+  display_merged_pr_message,
+  display_pr_exists_message,
+  display_pr_url
+};
+
+// scripts/gh/git-pr.ts
+async function create_pr(title, body, label) {
+  const config = {
+    icon_selector: () => "\u2705",
+    error_message: "Failed to create PR",
+    result_formatter: () => "PR created."
+  };
+  try {
+    return await animation_helpers.execute_with_animation(
+      "Creating pull request...",
+      async () => await git_gh_command.pr_create(title, body, label),
+      config
+    );
+  } catch (error) {
+    if (git_pr_error.is_pr_already_exists_error(error)) {
+      git_pr_messages.display_pr_exists_message();
+      return void 0;
+    }
+    throw error;
+  }
+}
+async function display_pr_url_if_available(branch_name) {
+  const pr_url = await git_gh_command.pr_get_url(branch_name);
+  if (pr_url !== void 0) {
+    git_pr_messages.display_pr_url(pr_url);
+  }
+}
+async function report_open_pr(branch_name, created_url) {
+  git_pr_messages.display_pr_opened_message();
+  if (created_url !== void 0 && created_url.length > 0) {
+    git_pr_messages.display_pr_url(created_url);
+    return;
+  }
+  await display_pr_url_if_available(branch_name);
+}
+var PR_STATE_MERGED = "MERGED";
+async function create_and_report(title, body, branch_name, label) {
+  const created_url = await create_pr(title, body, label);
+  await report_open_pr(branch_name, created_url);
+}
+function parse_pr_state(pr_info_json) {
+  return json_value.parse_with(pr_info_json, pr_info_schema)?.state;
+}
+async function get_pr_state(branch_name) {
+  const pr_info_json = await git_gh_command.pr_view(branch_name);
+  if (pr_info_json.length === 0) return void 0;
+  return parse_pr_state(pr_info_json);
+}
+function is_pr_state_merged(pr_state) {
+  return pr_state === PR_STATE_MERGED;
+}
+async function report_existing_pr(body, branch_name, should_replace_body, label) {
+  await git_gh_command.pr_ensure_classification(branch_name, label);
+  if (should_replace_body) await git_gh_command.pr_update_body(branch_name, body);
+  await report_open_pr(branch_name);
+}
+async function handle_existing_pr(title, body, branch_name, options) {
+  const pr_state_result = await get_pr_state(branch_name);
+  if (is_pr_state_merged(pr_state_result)) {
+    git_pr_messages.display_merged_pr_message();
+    await create_and_report(title, body, branch_name, options.label);
+    return;
+  }
+  await report_existing_pr(body, branch_name, options.should_replace_body, options.label);
+}
+async function create(title, body, branch_name, options) {
+  const { label, should_replace_body = false } = options;
+  const has_pr = await git_gh_command.pr_exists(branch_name);
+  if (!has_pr) {
+    await create_and_report(title, body, branch_name, label);
+    return;
+  }
+  await handle_existing_pr(title, body, branch_name, { label, should_replace_body });
+}
+function build_title(issue_info) {
+  return `${issue_info.title} ${issue_cite.plain_for("github", issue_info.number)}`;
+}
+function build_body(issue_info, extra_body) {
+  const closes = `closes ${issue_cite.plain_for("github", issue_info.number)}`;
+  if (extra_body === void 0) return closes;
+  return `${closes}
+
+${extra_body}`;
+}
+async function body_with_map(issue_info, extra_body) {
+  const body = build_body(issue_info, extra_body);
+  if (acceptance_map.has_map(body)) return body;
+  const map = acceptance_map.skeleton(await git_gh_command.issue_get_body(issue_info.number));
+  return map === void 0 ? body : `${body}
+
+${map}`;
+}
+async function existing_pr_label(branch_name) {
+  if (!await git_gh_command.pr_exists(branch_name) || is_pr_state_merged(await get_pr_state(branch_name))) {
+    return void 0;
+  }
+  return await git_gh_command.pr_get_classification(branch_name);
+}
+async function create_for_issue(issue_info, extra_body, label) {
+  await create(
+    build_title(issue_info),
+    await body_with_map(issue_info, extra_body),
+    issue_info.branch_name,
+    {
+      label,
+      should_replace_body: extra_body !== void 0
+    }
+  );
+}
+async function release_classification(issue_number, branch_name) {
+  const existing_label = await existing_pr_label(branch_name);
+  if (existing_label !== void 0) return existing_label;
+  const issue_json = await git_gh_command.issue_view_json(issue_number, "labels,body");
+  if (issue_json === void 0) {
+    throw new Error(
+      `Could not read issue ${session_cite.issue(issue_number)} for release classification`
+    );
+  }
+  return pr_classification.select_issue_classification(issue_json);
+}
+async function create_with_issue_info(issue_info, extra_body) {
+  const label = await release_classification(issue_info.number, issue_info.branch_name);
+  await create_for_issue(issue_info, extra_body, label);
+}
+var git_pr = {
+  create,
+  create_with_issue_info,
+  release_classification
+};
+
+export {
+  git_pr
+};

package/dist/commands/chunk-NDQIJBRQ.js

@@ -0,0 +1,100 @@
+import {
+  epic_live
+} from "./chunk-DF6QD4AF.js";
+import {
+  run_label
+} from "./chunk-KN46UC77.js";
+import {
+  epic_cross_repo
+} from "./chunk-YTXCLGGL.js";
+import {
+  issue_publication_state
+} from "./chunk-G2DNS74C.js";
+import {
+  issue_not_before
+} from "./chunk-PCZROH3R.js";
+import {
+  issue_sample_prime
+} from "./chunk-WWLCQREY.js";
+import {
+  git_gh_command
+} from "./chunk-NRULNBYI.js";
+import {
+  lane_state
+} from "./chunk-7EAYFMDN.js";
+import {
+  session_cite
+} from "./chunk-22DVQCP6.js";
+import {
+  lane_state_record
+} from "./chunk-UUH3DE77.js";
+import {
+  error_text
+} from "./chunk-CDY4NFQG.js";
+
+// scripts/lane/lane-dispatch-dependency.ts
+import { performance } from "node:perf_hooks";
+var WAIT_EXIT_CODE = 75;
+var WAIT_COMMAND = lane_state_record.DEPENDENCY_WAIT_COMMAND;
+async function unresolved(child) {
+  const references = await epic_live.blockers(child.number, child.repo);
+  const blockers = await Promise.all(
+    references.map(async (reference) => await epic_live.child(reference.number, reference.repo))
+  );
+  epic_cross_repo.reset_publish_cache();
+  return blockers.filter(
+    (blocker) => epic_cross_repo.resolve_cross_repo(blocker, child) !== "resolved"
+  );
+}
+async function start_wait(child) {
+  if (issue_publication_state.is_pending(child.body)) return "publication is pending";
+  if (child.state !== "OPEN") return "issue is no longer open";
+  await issue_sample_prime.prime([child.body]);
+  return issue_not_before.waiting_reason(child.body);
+}
+async function reason_of(issue) {
+  const repo = await git_gh_command.repo_get_name_with_owner();
+  if (repo === void 0) throw new Error("Cannot resolve launch repository");
+  const child = await epic_live.child(Number(issue), repo);
+  const wait = await start_wait(child);
+  if (wait !== void 0) return wait;
+  const blockers = await unresolved(child);
+  if (blockers.length === 0) return void 0;
+  const names = blockers.map(
+    (blocker) => session_cite.issue(blocker.number, void 0, blocker.repo)
+  );
+  return `unfinished blockers: ${names.join(", ")}`;
+}
+function waiting(issue, reason, started) {
+  const elapsed = Math.round(performance.now() - started);
+  console.error(`Lane ${session_cite.issue(issue)} waiting (${String(elapsed)} ms): ${reason}`);
+  return { kind: "dependency-wait", reason };
+}
+async function check(issue) {
+  const started = performance.now();
+  try {
+    const reason = await reason_of(issue);
+    if (reason === void 0) return void 0;
+    return waiting(issue, reason, started);
+  } catch (error) {
+    return waiting(issue, `unknown dependency state: ${error_text.message_of(error)}`, started);
+  }
+}
+async function defer(issue) {
+  await lane_state.record_change({ issue, state: "paused", command: WAIT_COMMAND });
+  await run_label.unmark(issue);
+}
+async function deferred(issue) {
+  const state = await lane_state.read_state(issue);
+  return state?.changed_by === WAIT_COMMAND ? ["launch dependency confirmation"] : [];
+}
+async function begin(issue) {
+  const waits = await deferred(issue);
+  if (waits.length === 0) return;
+  await lane_state.record_change({ issue, state: "running", command: "lane:dispatch" });
+}
+var lane_dispatch_dependency = { check, defer, deferred, begin, WAIT_EXIT_CODE };
+
+export {
+  lane_dispatch_dependency
+};

package/dist/commands/chunk-NDR4PCVG.js

@@ -0,0 +1,29 @@
+import {
+  run_event_scope,
+  run_event_stream_emit
+} from "./chunk-26JL4UU4.js";
+import {
+  run_event_stream
+} from "./chunk-KGSEWOKI.js";
+import {
+  issue_cite
+} from "./chunk-HQ2HSZBN.js";
+
+// scripts/run/event/run-event-plan.ts
+var KIND = run_event_stream.EVENT_KIND.PLAN;
+var PLAN_VERB = "planned";
+function plan_text(issue) {
+  return `${PLAN_VERB} ${issue_cite.plain_for("program", issue)}`;
+}
+function has_plan(events, issue) {
+  return run_event_scope.since_own_launch(events, issue).some((event) => event.kind === KIND && run_event_scope.issue_named(event) === issue);
+}
+async function emit_plan(issue) {
+  if (has_plan(await run_event_stream_emit.invocation_or_all_events(), issue)) return;
+  await run_event_stream_emit.emit(KIND, plan_text(issue));
+}
+var run_event_plan = { emit_plan, plan_text };
+
+export {
+  run_event_plan
+};