@joshuafolkken/kit 1.3101.0 → 1.3125.0

package/dist/commands/chunk-YSBLGTDZ.js

@@ -0,0 +1,339 @@
+import {
+  epic_report
+} from "./chunk-4HOTJAO6.js";
+import {
+  epic_triage
+} from "./chunk-VQRT32JB.js";
+import {
+  auto_ok_cli,
+  epic_bundle_gaps
+} from "./chunk-N2EE7MMH.js";
+import {
+  run_prep_locate
+} from "./chunk-T5D3BW3D.js";
+import {
+  epic_cross_repo
+} from "./chunk-AQGVQMWF.js";
+import {
+  issue_not_before
+} from "./chunk-JUXKVN77.js";
+import {
+  issue_publication_state
+} from "./chunk-5RCBXYYD.js";
+import {
+  size_estimate
+} from "./chunk-IAA73DWD.js";
+import {
+  split_assess
+} from "./chunk-OYGNL5RO.js";
+import {
+  issue_body_keys
+} from "./chunk-4DNAAFF4.js";
+import {
+  IN_PROGRESS_LABEL,
+  SPLIT_ROUTE_LABEL,
+  has_label_name
+} from "./chunk-QQBMVC5W.js";
+import {
+  issue_citation,
+  session_cite
+} from "./chunk-22DVQCP6.js";
+import {
+  issue_cite
+} from "./chunk-HQ2HSZBN.js";
+import {
+  line_budget
+} from "./chunk-QFIKPGMC.js";
+
+// scripts/issue/issue-cap-files.ts
+import path from "node:path";
+var PERCENT = 100;
+var CAP_PERCENT = 90;
+var CAP_FRACTION = CAP_PERCENT / PERCENT;
+var NO_LINES_PREFIX = issue_body_keys.prefix("no_lines");
+var REFACTOR_PREFIX = issue_body_keys.prefix("refactor_first");
+var ISSUE_REFERENCE = /^#\d+$/u;
+var REFACTOR_GUIDE = "prompts/refactoring.md";
+var CODE_FILE = /\.(?:[cm]?[jt]sx?|svelte)$/u;
+function counted_paths(body, project_root) {
+  return run_prep_locate.names_of(body).filter((name) => CODE_FILE.test(name)).filter((name) => line_budget.is_lintable_path(path.resolve(project_root, name)));
+}
+function is_near_cap(budget) {
+  if (budget === void 0) return false;
+  return budget.code_lines >= Math.ceil(budget.limit * CAP_FRACTION);
+}
+function is_declared(body) {
+  if ((size_estimate.declared(body, NO_LINES_PREFIX) ?? "") !== "") return true;
+  return ISSUE_REFERENCE.test(size_estimate.declared(body, REFACTOR_PREFIX) ?? "");
+}
+function near_of(named, budgets) {
+  const near = budgets.filter((entry) => is_near_cap(entry.budget));
+  return named.map((paths) => near.filter((entry) => paths.includes(entry.file_path)));
+}
+async function near_cap_by_body(bodies, project_root) {
+  const named = bodies.map((body) => is_declared(body) ? [] : counted_paths(body, project_root));
+  const paths = [...new Set(named.flat())];
+  if (paths.length === 0) return named.map(() => []);
+  return near_of(named, await line_budget.budgets_for(paths, project_root));
+}
+async function near_cap(body, project_root) {
+  const [near] = await near_cap_by_body([body], project_root);
+  return near ?? [];
+}
+function described(entry) {
+  const { budget } = entry;
+  return budget === void 0 ? entry.file_path : `${entry.file_path} (${line_budget.describe(budget)})`;
+}
+function named_line(near) {
+  return `names ${near.map((entry) => described(entry)).join(", ")}, at or past ${String(CAP_PERCENT)}% of the code-line limit`;
+}
+function problem(near) {
+  if (near.length === 0) return void 0;
+  return `${named_line(near)} \u2014 file a refactor Issue that splits it first (${REFACTOR_GUIDE}), refile this one declaring \`${REFACTOR_PREFIX} #<refactor>\`, then \`pnpm josh backlog:triage --apply <N> --blocked-by <refactor> --reason "<why>"\`; or declare \`${NO_LINES_PREFIX} <\u7406\u7531>\` when the change adds no lines to it`;
+}
+function note(near) {
+  if (near.length === 0) return void 0;
+  return `${named_line(near)} with no \`${NO_LINES_PREFIX}\` \u2014 split it first (${REFACTOR_GUIDE})`;
+}
+var issue_cap_files = {
+  NO_LINES_PREFIX,
+  REFACTOR_PREFIX,
+  near_cap,
+  near_cap_by_body,
+  note,
+  problem
+};
+
+// scripts/backlog/backlog-next-size.ts
+function remedy_of(route) {
+  return route === SPLIT_ROUTE_LABEL ? `on a \`${SPLIT_ROUTE_LABEL}\` child \u2014 split it further` : `with no \`${split_assess.REASON_PREFIX}\``;
+}
+function limit_note(body, route, rate, growth) {
+  const capped = size_estimate.over_cap(body, route, rate, growth);
+  return capped === void 0 ? size_estimate.budget_note(body, rate, growth) : size_estimate.capped(capped, rate, growth);
+}
+function guide_note(body, route, rate, growth) {
+  const guide = size_estimate.over_guide(body, route, rate, growth) ?? size_estimate.split_over_guide(body, route, rate, growth);
+  return guide === void 0 ? void 0 : `${size_estimate.exceeded(guide, rate, growth)} ${remedy_of(route)}`;
+}
+function size_note(row, context) {
+  const route = size_estimate.route_of(row.labels);
+  const body = row.body ?? "";
+  const { implement_rate, growth } = context;
+  return limit_note(body, route, implement_rate, growth) ?? guide_note(body, route, implement_rate, growth);
+}
+function note_of(row, context) {
+  const note2 = size_note(row, context);
+  if (note2 === void 0) return void 0;
+  const cited2 = session_cite.issue(row.number, void 0, row.repo);
+  return `${cited2} ${note2} \u2014 split-assessment.md \u2192 "${split_assess.QUESTION_SECTION}"`;
+}
+function cap_note_of(row, near = []) {
+  const note2 = issue_cap_files.note(near);
+  return note2 === void 0 ? void 0 : `${session_cite.issue(row.number, void 0, row.repo)} ${note2}`;
+}
+async function warn_over_guide(offered, context) {
+  const bodies = offered.map((row) => row.body ?? "");
+  const near = await issue_cap_files.near_cap_by_body(bodies, process.cwd());
+  const notes = offered.flatMap((row, index) => [
+    note_of(row, context),
+    cap_note_of(row, near[index])
+  ]);
+  for (const note2 of notes) if (note2 !== void 0) console.error(note2);
+}
+var backlog_next_size = { warn_over_guide };
+
+// scripts/backlog/backlog-wait-cause.ts
+var CAUSES = ["chain", "gate", "publication", "lane"];
+var MARKS = {
+  chain: "Waiting on a dependency chain:",
+  gate: "Waiting on a start condition:",
+  publication: "Waiting on publication:",
+  lane: "Waiting on a running lane:"
+};
+var TAG_SEPARATOR = "+";
+var ISSUE_PATTERN = /#(\d+)/gu;
+var DEADLINE_MARK = "Next start time: ";
+var RESOLVED_VERDICT = "resolved";
+function has_pending_blocker(child) {
+  return child.blocked_by.some(
+    (blocker) => epic_cross_repo.resolve_cross_repo(
+      { ...blocker, state: blocker.state ?? "OPEN", labels: [], blocked_by: [] },
+      child
+    ) !== RESOLVED_VERDICT
+  );
+}
+function cause_of(child) {
+  if (has_label_name(child.labels, IN_PROGRESS_LABEL)) return void 0;
+  if (issue_publication_state.is_pending(child.body)) return "publication";
+  if (!issue_not_before.is_due(child.body)) return "gate";
+  return has_pending_blocker(child) ? "chain" : "lane";
+}
+function deadline_of(children) {
+  const dates = children.filter((child) => cause_of(child) === "gate").map((child) => issue_not_before.waiting_ms(child.body)).filter((date) => date !== void 0);
+  return dates.length === 0 ? {} : { not_before_ms: Math.min(...dates) };
+}
+function numbers_with(children, cause) {
+  return children.filter((child) => cause_of(child) === cause).map((child) => child.number);
+}
+function classify(children, repo) {
+  const here = children.filter((child) => child.repo === repo);
+  return {
+    chain: numbers_with(here, "chain"),
+    gate: numbers_with(here, "gate"),
+    publication: numbers_with(here, "publication"),
+    lane: numbers_with(here, "lane"),
+    ...deadline_of(here)
+  };
+}
+function cited(numbers) {
+  return numbers.map((number) => issue_cite.plain_for("program", number)).join(" ");
+}
+function lines_of(causes) {
+  const lines = CAUSES.filter((cause) => causes[cause].length > 0).map(
+    (cause) => `${MARKS[cause]} ${cited(causes[cause])}`
+  );
+  return causes.not_before_ms === void 0 ? lines : [...lines, `${DEADLINE_MARK}${String(causes.not_before_ms)}`];
+}
+function numbers_on(text, cause) {
+  const line = text.split("\n").find((candidate) => candidate.startsWith(MARKS[cause]));
+  return [...(line ?? "").matchAll(ISSUE_PATTERN)].map((match) => Number(match[1]));
+}
+function parse(text) {
+  const deadline = text.split("\n").find((line) => line.startsWith(DEADLINE_MARK));
+  const not_before_ms = Number(deadline?.slice(DEADLINE_MARK.length));
+  return {
+    chain: numbers_on(text, "chain"),
+    gate: numbers_on(text, "gate"),
+    publication: numbers_on(text, "publication"),
+    lane: numbers_on(text, "lane"),
+    ...Number.isFinite(not_before_ms) && { not_before_ms }
+  };
+}
+function tag_of(causes) {
+  const present = CAUSES.filter((cause) => causes[cause].length > 0);
+  return present.length > 0 ? present.join(TAG_SEPARATOR) : void 0;
+}
+function causes_of_tag(tag) {
+  const parts = tag.split(TAG_SEPARATOR);
+  const causes = CAUSES.filter((cause) => parts.includes(cause));
+  return causes.length === parts.length ? causes : void 0;
+}
+function numbers_of(causes) {
+  return CAUSES.flatMap((cause) => causes[cause]);
+}
+var backlog_wait_cause = {
+  cause_of,
+  causes_of_tag,
+  classify,
+  lines_of,
+  numbers_of,
+  parse,
+  tag_of
+};
+
+// scripts/backlog/backlog-next-report.ts
+var SUCCESS_EXIT_CODE = 0;
+var RETRY_MESSAGE = "GitHub did not answer, so a child of the dependency graph could not be read. This is a transport failure and not an unusable graph \u2014 the listings this command already read prove `gh` and the credentials work. Ask again after a short wait.";
+var VERDICT_TOKENS = {
+  complete: auto_ok_cli.NONE_TOKEN,
+  error: "error",
+  retry: "retry",
+  run: "run",
+  stop: "stop",
+  triage: epic_triage.TRIAGE_VERDICT,
+  wait: "wait"
+};
+function tokens_of(result, repo) {
+  if (result.verdict !== "run") return [VERDICT_TOKENS[result.verdict]];
+  const here = epic_report.candidates_for_repo(result, repo);
+  if (here.length === 0) return [VERDICT_TOKENS.wait];
+  return here.map((child) => String(child.number));
+}
+function offered_of(result, repo) {
+  return result.verdict === "run" ? epic_report.candidates_for_repo(result, repo) : [];
+}
+function warn_epic_gap(context) {
+  const epics = epic_bundle_gaps.epic_gap(context.tracking.cutoff, auto_ok_cli.LISTING_LIMIT);
+  if (epics !== void 0) console.error(epics);
+}
+function warn_gaps(context, has_answer) {
+  const listing = auto_ok_cli.truncation_note(context.opted_in.cutoff, has_answer);
+  if (listing !== void 0) console.error(listing);
+  warn_epic_gap(context);
+}
+function warn_not_before(context) {
+  for (const issue of context.opted_in.issues) {
+    const reason = issue_not_before.waiting_reason(issue.body);
+    if (reason === void 0) continue;
+    const cited2 = session_cite.issue(issue.number, void 0, context.repo);
+    console.error(`${cited2} ${issue_citation.linkify(reason, context.repo)}`);
+  }
+}
+function warn_wait_causes(result, context) {
+  const causes = backlog_wait_cause.classify(result.waiting, context.repo);
+  for (const line of backlog_wait_cause.lines_of(causes)) {
+    console.error(issue_citation.linkify(line, context.repo));
+  }
+}
+async function report(result, context) {
+  warn_gaps(context, result.verdict === "run");
+  const explanation = epic_report.format_result(result, context.repo);
+  console.error(issue_citation.linkify(explanation, context.repo));
+  warn_not_before(context);
+  const tokens = tokens_of(result, context.repo);
+  if (tokens[0] === VERDICT_TOKENS.wait) warn_wait_causes(result, context);
+  await backlog_next_size.warn_over_guide(offered_of(result, context.repo), context);
+  for (const token of tokens) console.info(token);
+  return SUCCESS_EXIT_CODE;
+}
+function report_retry(context) {
+  warn_epic_gap(context);
+  console.error(RETRY_MESSAGE);
+  console.info(VERDICT_TOKENS.retry);
+  return SUCCESS_EXIT_CODE;
+}
+function report_triage(context, untriaged) {
+  warn_epic_gap(context);
+  console.error(epic_triage.message(untriaged, context.repo));
+  console.info(VERDICT_TOKENS.triage);
+  return SUCCESS_EXIT_CODE;
+}
+function without_untriaged(result, repo) {
+  const candidates = result.candidates.map(
+    (bucket) => bucket.repo === repo ? { ...bucket, children: bucket.children.filter((child) => epic_triage.is_triaged(child)) } : bucket
+  );
+  return { ...result, candidates };
+}
+function has_offer(result, repo) {
+  return result.verdict === "run" && epic_report.candidates_for_repo(result, repo).length > 0;
+}
+async function report_held(gated, context, untriaged) {
+  if (!has_offer(gated, context.repo)) return report_triage(context, untriaged);
+  await report(gated, context);
+  console.error(epic_triage.held_message(untriaged, context.repo));
+  console.info(VERDICT_TOKENS.triage);
+  return SUCCESS_EXIT_CODE;
+}
+function report_none() {
+  console.error(auto_ok_cli.NONE_OPTED_IN_MESSAGE);
+  console.info(auto_ok_cli.NONE_TOKEN);
+  return SUCCESS_EXIT_CODE;
+}
+var backlog_next_report = {
+  RETRY_MESSAGE,
+  VERDICT_TOKENS,
+  offered_of,
+  report,
+  report_retry,
+  tokens_of,
+  without_untriaged,
+  report_held,
+  report_none
+};
+
+export {
+  issue_cap_files,
+  backlog_wait_cause,
+  backlog_next_report
+};

package/dist/commands/chunk-YSDBY2G7.js

@@ -0,0 +1,186 @@
+import {
+  lane_handoff,
+  lane_process_table
+} from "./chunk-5QICRFVL.js";
+import {
+  PROCESS_ALIVE,
+  PROCESS_NONE,
+  PROCESS_UNKNOWN,
+  run_liveness
+} from "./chunk-L7GYJHDX.js";
+import {
+  lane_child_invocation,
+  lane_reap,
+  process_tools
+} from "./chunk-VFW6XZH7.js";
+import {
+  poll
+} from "./chunk-SBGTCT2C.js";
+import {
+  agent_session_environment
+} from "./chunk-HHBC6QZE.js";
+import {
+  issue_number_shape
+} from "./chunk-G75GWNNY.js";
+import {
+  MS_PER_SECOND,
+  PROBE_TIMEOUT_MS
+} from "./chunk-WPAQUMHC.js";
+
+// scripts/lane/lane-await.ts
+import { spawnSync } from "node:child_process";
+import { setTimeout as sleep } from "node:timers/promises";
+import { parseArgs } from "node:util";
+var RECONFIRM_MS = 15e3;
+var DEFAULT_POLL_MS = 5e3;
+var NEVER_APPEARED_TIMEOUT_MS = 6e5;
+var PROCESS_FOUND = 0;
+var PROCESS_NOT_FOUND = 1;
+var PGREP_COMMAND = "pgrep";
+function process_trace_default(issue) {
+  const pattern = lane_child_invocation.process_pattern(issue);
+  const result = spawnSync(PGREP_COMMAND, ["-f", pattern], {
+    encoding: "utf8",
+    timeout: PROBE_TIMEOUT_MS
+  });
+  process_tools.throw_if_missing(PGREP_COMMAND, result.error);
+  if (result.status === PROCESS_FOUND || lane_handoff.is_ship_running(issue, process.cwd())) {
+    return PROCESS_ALIVE;
+  }
+  return result.status === PROCESS_NOT_FOUND ? PROCESS_NONE : PROCESS_UNKNOWN;
+}
+function is_process_running_default(issue) {
+  return process_trace_default(issue) === PROCESS_ALIVE;
+}
+async function other_process_trace(issue) {
+  if (lane_handoff.is_ship_running(issue, process.cwd())) return PROCESS_ALIVE;
+  const rows = await lane_process_table.read_table();
+  if (!rows?.some((row) => row.pid === process.pid)) return PROCESS_UNKNOWN;
+  return lane_reap.is_child_running(issue, lane_process_table.probes_of(rows)) ? PROCESS_ALIVE : PROCESS_NONE;
+}
+function is_shipped_default(issue, since_ms) {
+  return lane_handoff.is_ship_succeeded(issue, process.cwd(), since_ms);
+}
+async function is_settled_default(issue) {
+  return await run_liveness.read_child_settled(issue) === true;
+}
+function read_await_args(rest) {
+  try {
+    return parseArgs({
+      args: [...rest],
+      allowPositionals: true,
+      strict: true,
+      options: { owner: { type: "string" } }
+    });
+  } catch {
+    return void 0;
+  }
+}
+function is_valid(raw) {
+  const { owner } = raw.values;
+  const numbers = owner === void 0 ? raw.positionals : [...raw.positionals, owner];
+  return raw.positionals.length > 0 && numbers.every((value) => issue_number_shape.is_issue_number(value));
+}
+function parse_arguments(rest) {
+  const raw = read_await_args(rest);
+  if (raw === void 0 || !is_valid(raw)) return void 0;
+  const { owner } = raw.values;
+  return {
+    issues: raw.positionals,
+    owner: owner === void 0 ? agent_session_environment.own_session_pid() : Number(owner)
+  };
+}
+function make_initial_state(is_settled) {
+  return { appeared: false, disappeared_at: void 0, first_polled_at: void 0, is_settled };
+}
+async function make_states(issues, is_settled) {
+  const settled = await Promise.all(issues.map(async (issue) => await is_settled(issue)));
+  return new Map(issues.map((issue, index) => [issue, make_initial_state(settled[index] === true)]));
+}
+function resolve_timing(options) {
+  return {
+    poll_ms: options.poll_ms ?? DEFAULT_POLL_MS,
+    reconfirm_ms: options.reconfirm_ms ?? RECONFIRM_MS,
+    never_appeared_timeout_ms: options.never_appeared_timeout_ms ?? NEVER_APPEARED_TIMEOUT_MS
+  };
+}
+function resolve_probes(options) {
+  return {
+    is_running: options.is_running ?? is_process_running_default,
+    is_shipped: options.is_shipped ?? is_shipped_default
+  };
+}
+function resolve_options(options) {
+  return {
+    ...resolve_probes(options),
+    is_settled: options.is_settled ?? is_settled_default,
+    now: options.now ?? Date.now,
+    sleep: options.sleep ?? sleep,
+    ...resolve_timing(options)
+  };
+}
+function update_liveness(state, is_live, now_ms) {
+  if (!is_live) return;
+  if (!state.appeared || state.disappeared_at !== void 0) state.alive_since = now_ms;
+  state.appeared = true;
+  state.disappeared_at = void 0;
+}
+function check_not_appeared(issue, state, now_ms, timeout_ms) {
+  if (state.is_settled === true) return issue;
+  state.first_polled_at ??= now_ms;
+  const elapsed_ms = now_ms - state.first_polled_at;
+  if (elapsed_ms >= timeout_ms) {
+    throw new Error(
+      `lane child ${issue} never appeared within ${String(timeout_ms / MS_PER_SECOND)}s`
+    );
+  }
+  return void 0;
+}
+function is_own_ship_done(issue, state, config) {
+  const { alive_since } = state;
+  return alive_since !== void 0 && config.is_shipped?.(issue, alive_since) === true;
+}
+function check_gone(issue, state, now_ms, config) {
+  if (is_own_ship_done(issue, state, config)) return issue;
+  state.disappeared_at ??= now_ms;
+  return now_ms - state.disappeared_at >= config.reconfirm_ms ? issue : void 0;
+}
+function check_issue(issue, state, now_ms, config) {
+  const is_live = config.is_running(issue);
+  update_liveness(state, is_live, now_ms);
+  if (is_live) return void 0;
+  if (!state.appeared) {
+    return check_not_appeared(issue, state, now_ms, config.never_appeared_timeout_ms);
+  }
+  return check_gone(issue, state, now_ms, config);
+}
+function check_any(states, now_ms, config) {
+  for (const [issue, state] of states) {
+    const result = check_issue(issue, state, now_ms, config);
+    if (result !== void 0) return result;
+  }
+  return void 0;
+}
+async function wait_for_any(issues, options = {}) {
+  const config = resolve_options(options);
+  const states = await make_states(issues, config.is_settled);
+  return await poll.wait_for(() => check_any(states, config.now(), config), {
+    interval_ms: config.poll_ms,
+    sleeper: config.sleep
+  });
+}
+var lane_await = {
+  NEVER_APPEARED_TIMEOUT_MS,
+  RECONFIRM_MS,
+  check_issue,
+  is_process_running_default,
+  is_shipped_default,
+  parse_arguments,
+  other_process_trace,
+  process_trace_default,
+  wait_for_any
+};
+
+export {
+  lane_await
+};

package/dist/commands/chunk-YSL43R4Y.js

@@ -0,0 +1,149 @@
+import {
+  OperationCancelledError
+} from "./chunk-XMZJB7JP.js";
+import {
+  SEPARATOR_LINE
+} from "./chunk-B5GXZK3E.js";
+
+// scripts/git/git-prompt.ts
+import { stdin as input, stdout as output } from "node:process";
+import { createInterface } from "node:readline/promises";
+
+// scripts/git/git-prompt-display.ts
+function display_start_separator() {
+  console.info("");
+  console.info(SEPARATOR_LINE);
+}
+function display_end_separator() {
+  console.info(SEPARATOR_LINE);
+}
+function display_invalid_answer_message() {
+  console.info("\u{1F4A1} Reply y / n.");
+}
+var git_prompt_display = {
+  display_start_separator,
+  display_end_separator,
+  display_invalid_answer_message
+};
+
+// scripts/git/git-prompt.ts
+var PROMPT_MESSAGES = {
+  unstaged_files: "\u{1F4AC} Unstaged files found. Continue anyway? (y/n): ",
+  package_json_not_staged: "\u{1F4AC} package.json is not staged. Continue anyway? (y/n): ",
+  version_not_updated: "\u{1F4AC} package.json version is not updated. Continue anyway? (y/n): ",
+  commit: "\u{1F4AC} Commit staged changes now? (y/n): ",
+  push: "\u{1F4AC} Push changes to remote? (y/n): ",
+  pr: "\u{1F4AC} Create pull request? (y/n): "
+};
+function is_valid_yes_no_answer(answer) {
+  return answer === "y" || answer === "n";
+}
+async function ask_yes_no_unified(prompt, question, options) {
+  if (options.show_separators && options.is_first_call) {
+    git_prompt_display.display_start_separator();
+  }
+  const raw_answer = await prompt.question(question);
+  const answer = String(raw_answer).trim().toLowerCase();
+  if (!is_valid_yes_no_answer(answer)) {
+    git_prompt_display.display_invalid_answer_message();
+    return await ask_yes_no_unified(prompt, question, { ...options, is_first_call: false });
+  }
+  if (options.show_separators) {
+    git_prompt_display.display_end_separator();
+  }
+  return answer === "y";
+}
+async function ask_yes_no(prompt, question) {
+  return await ask_yes_no_unified(prompt, question, { show_separators: true, is_first_call: true });
+}
+async function ask_yes_no_simple(prompt, question) {
+  return await ask_yes_no_unified(prompt, question, { show_separators: false, is_first_call: true });
+}
+function create_prompt() {
+  return process.stdin.isTTY ? createInterface({ input, output }) : void 0;
+}
+function handle_prompt_fallback(fallback_value) {
+  if (fallback_value !== void 0) return fallback_value;
+  throw new Error("TTY not available");
+}
+async function with_prompt(callback, fallback_value) {
+  const prompt = create_prompt();
+  if (prompt === void 0) return handle_prompt_fallback(fallback_value);
+  try {
+    return await callback(prompt);
+  } finally {
+    prompt.close();
+  }
+}
+async function confirm_or_cancel(should_continue) {
+  const is_confirmed = await should_continue();
+  if (!is_confirmed) throw new OperationCancelledError();
+}
+function create_confirm_function(message) {
+  return async () => {
+    return await with_prompt(async (prompt) => await ask_yes_no(prompt, message), false);
+  };
+}
+async function confirm_continue() {
+  return await create_confirm_function(PROMPT_MESSAGES.unstaged_files)();
+}
+async function confirm_without_package_json() {
+  return await create_confirm_function(PROMPT_MESSAGES.package_json_not_staged)();
+}
+async function confirm_unstaged_files() {
+  await confirm_or_cancel(confirm_continue);
+}
+async function confirm_missing_package_json() {
+  await confirm_or_cancel(confirm_without_package_json);
+}
+async function confirm_version_not_updated() {
+  return await create_confirm_function(PROMPT_MESSAGES.version_not_updated)();
+}
+async function confirm_without_version_update() {
+  await confirm_or_cancel(confirm_version_not_updated);
+}
+async function ask_issue_info(prompt, question) {
+  git_prompt_display.display_start_separator();
+  const raw_answer = await prompt.question(question);
+  const answer = String(raw_answer);
+  git_prompt_display.display_end_separator();
+  return answer.trim();
+}
+async function get_issue_info() {
+  return await with_prompt(async (prompt) => {
+    const result = await ask_issue_info(
+      prompt,
+      '\u{1F4AC} Enter issue title and number (e.g., "title #52"): '
+    );
+    return result;
+  });
+}
+async function confirm_workflow_steps() {
+  const fallback = { commit: false, push: false, pr: false };
+  return await with_prompt(async (prompt) => {
+    git_prompt_display.display_start_separator();
+    console.info("\u{1F4AC} Confirm workflow steps:");
+    console.info("");
+    const should_commit = await ask_yes_no_simple(prompt, PROMPT_MESSAGES.commit);
+    const should_push = await ask_yes_no_simple(prompt, PROMPT_MESSAGES.push);
+    const should_create_pr = await ask_yes_no_simple(prompt, PROMPT_MESSAGES.pr);
+    git_prompt_display.display_end_separator();
+    return {
+      commit: should_commit,
+      push: should_push,
+      pr: should_create_pr
+    };
+  }, fallback);
+}
+var git_prompt = {
+  confirm_unstaged_files,
+  confirm_missing_package_json,
+  confirm_without_version_update,
+  get_issue_info,
+  confirm_workflow_steps
+};
+
+export {
+  ask_yes_no_simple,
+  git_prompt
+};