@joshuafolkken/kit 1.3101.0 → 1.3125.0

package/dist/commands/chunk-N4P64UIH.js

@@ -1,211 +0,0 @@
-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

@@ -1,204 +0,0 @@
-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

@@ -1,100 +0,0 @@
-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

@@ -1,29 +0,0 @@
-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
-};