@joshuafolkken/kit 1.3101.0 → 1.3125.0

package/dist/commands/chunk-S4JE63QE.js

@@ -1,704 +0,0 @@
-import {
-  epic_run
-} from "./chunk-NYWPTYGL.js";
-import {
-  epic_add,
-  epic_reconcile
-} from "./chunk-VY7ZJMDT.js";
-import {
-  epic_bundle_gaps
-} from "./chunk-RFIOZTXY.js";
-import {
-  epic_index,
-  epic_schema
-} from "./chunk-NHTEC5U4.js";
-import {
-  epic_issue
-} from "./chunk-YEAE46TS.js";
-import {
-  git_gh_issue_batch_graphql,
-  git_gh_issue_batch_read
-} from "./chunk-HYE3MBAN.js";
-import {
-  cutoff_of
-} from "./chunk-DACNQAXC.js";
-import {
-  epic_audit_logic
-} from "./chunk-ILIITIMQ.js";
-import {
-  epic_graph
-} from "./chunk-3RIQ36LH.js";
-import {
-  format_dependency_links
-} from "./chunk-2ADQ5XRD.js";
-import {
-  git_gh_command
-} from "./chunk-NRULNBYI.js";
-import {
-  PLAN_FIELDS
-} from "./chunk-TFYYXETQ.js";
-import {
-  blocked_by_schema,
-  issue_label_schema
-} from "./chunk-34DND4BA.js";
-import {
-  RELEASE_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 {
-  parse_json_array_or_undefined
-} from "./chunk-43DU7DYZ.js";
-
-// scripts/epic/epic-bundle-cli.ts
-import { z } from "zod";
-
-// scripts/epic/epic-bundle-recommend.ts
-function tracked_count(epic, members) {
-  return members.filter((member) => member.epic === epic).length;
-}
-function recommend_epic(epics, members) {
-  const [recommended] = epics.toSorted(
-    (left, right) => tracked_count(right, members) - tracked_count(left, members) || left - right
-  );
-  return recommended;
-}
-function format_counts(epics, members) {
-  return epics.map(
-    (epic) => `${issue_cite.plain_for("github", epic)}: ${String(tracked_count(epic, members))}`
-  ).join(", ");
-}
-function placement_record(input, date) {
-  const rejected = input.epics.filter((epic) => epic !== input.epic).map((epic) => issue_cite.plain_for("github", epic));
-  const placed = `placed ${issue_cite.plain_for("github", input.subject)} in ${issue_cite.plain_for("github", input.epic)}`;
-  const counts = format_counts(input.epics, input.members);
-  return `Auto-decided (${date}, \`epic:bundle --apply\`): ${placed} over ${rejected.join(", ")} because it tracks the most related issues (${counts}); a tie goes to the older epic.`;
-}
-var epic_bundle_recommend = { recommend_epic, placement_record };
-
-// scripts/epic/epic-bundle.ts
-function reference_section(from, to) {
-  return epic_audit_logic.signal_references(from.body, from.repo).find((reference) => reference.number === to.number)?.section;
-}
-function names_in_body(from, to) {
-  return reference_section(from, to) !== void 0;
-}
-function has_mutual_reference(subject, other) {
-  return names_in_body(subject, other) || names_in_body(other, subject);
-}
-function names_as_blocker(blocked, blocker) {
-  const wanted = epic_graph.key_of(blocker);
-  return blocked.blocked_by.some((recorded) => epic_graph.key_of(recorded) === wanted);
-}
-function has_recorded_dependency(subject, other) {
-  return names_as_blocker(subject, other) || names_as_blocker(other, subject);
-}
-function membership_of(number, labels, context) {
-  const epic = context.epics.get(number);
-  return {
-    is_epic: context.epic_numbers.has(number),
-    is_release: has_label_name(labels, RELEASE_LABEL),
-    ...epic !== void 0 && { epic }
-  };
-}
-function is_excluded(issue) {
-  return issue.is_epic === true || issue.is_release === true;
-}
-function is_strong_signal(subject, other) {
-  if (subject.number === other.number || is_excluded(subject) || is_excluded(other)) return false;
-  return has_mutual_reference(subject, other) || has_recorded_dependency(subject, other);
-}
-function find_candidates(subject, backlog) {
-  return backlog.filter((other) => is_strong_signal(subject, other));
-}
-function candidate_epics(candidates) {
-  const epics = /* @__PURE__ */ new Set();
-  for (const candidate of candidates) {
-    if (candidate.epic !== void 0) epics.add(candidate.epic);
-  }
-  return [...epics].toSorted((left, right) => left - right);
-}
-var NO_SIGNAL_REASON = "no existing issue shares a reference or a dependency with this one";
-function already_tracked_reason(epic) {
-  return `${issue_cite.plain_for("linked", epic)} already tracks this issue`;
-}
-var SPREAD_REASON = "the related issues already belong to different epics; pick the one this issue belongs in and record why";
-function to_numbers(candidates) {
-  return candidates.map((candidate) => candidate.number);
-}
-function create_decision(subject, numbers) {
-  const count = String(numbers.length);
-  const reason = `${issue_cite.plain_for("linked", subject.number)} and ${count} related issue(s) belong to no epic`;
-  return { action: "create_epic", epics: [], candidates: numbers, reason };
-}
-function epic_parents(backlog, repo) {
-  const parents = /* @__PURE__ */ new Map();
-  for (const issue of backlog) {
-    if (issue.repo === repo && issue.epic !== void 0) parents.set(issue.number, issue.epic);
-  }
-  return parents;
-}
-function ancestors_of(epic, parents) {
-  const seen = /* @__PURE__ */ new Set();
-  let current = parents.get(epic);
-  while (current !== void 0 && !seen.has(current)) {
-    seen.add(current);
-    current = parents.get(current);
-  }
-  return seen;
-}
-function is_cyclic(epics, above) {
-  return epics.some((epic, index) => above[index]?.has(epic) === true);
-}
-function narrow_to_innermost(epics, parents) {
-  const above = epics.map((epic) => ancestors_of(epic, parents));
-  if (is_cyclic(epics, above)) return [...epics];
-  const covered = new Set(above.flatMap((ancestors) => [...ancestors]));
-  return epics.filter((epic) => !covered.has(epic));
-}
-function tracks_reason(epic, involved) {
-  const tracks = `${issue_cite.plain_for("linked", epic)} already tracks a related issue`;
-  if (involved.length === 1) return tracks;
-  return `${tracks}; the other epics the candidates sit in are its own parents`;
-}
-function ask_decision(epics, candidates, parents) {
-  const has_cycle = is_cyclic(
-    epics,
-    epics.map((epic) => ancestors_of(epic, parents))
-  );
-  const recommended = has_cycle ? void 0 : epic_bundle_recommend.recommend_epic(epics, candidates);
-  return {
-    action: "ask",
-    epics,
-    candidates: to_numbers(candidates),
-    reason: SPREAD_REASON,
-    ...recommended !== void 0 && { recommended }
-  };
-}
-function decide_with_candidates(subject, candidates, parents) {
-  const numbers = to_numbers(candidates);
-  const involved = candidate_epics(candidates);
-  const epics = narrow_to_innermost(involved, parents);
-  if (epics.length > 1) return ask_decision(epics, candidates, parents);
-  const [epic] = epics;
-  if (epic === void 0) return create_decision(subject, numbers);
-  return {
-    action: "add_to_epic",
-    epic,
-    epics: [epic],
-    candidates: numbers,
-    reason: tracks_reason(epic, involved)
-  };
-}
-function decide_bundle(subject, backlog) {
-  if (subject.epic !== void 0) {
-    return {
-      action: "none",
-      epics: [subject.epic],
-      candidates: [],
-      reason: already_tracked_reason(subject.epic)
-    };
-  }
-  const candidates = find_candidates(subject, backlog);
-  if (candidates.length === 0) {
-    return { action: "none", epics: [], candidates: [], reason: NO_SIGNAL_REASON };
-  }
-  return decide_with_candidates(subject, candidates, epic_parents(backlog, subject.repo));
-}
-function bundle_dependency_links(subject, candidates) {
-  const members = [subject, ...candidates];
-  const keys = new Set(members.map((member) => epic_graph.key_of(member)));
-  const declared_repo = subject.repo;
-  return members.filter((member) => member.repo === declared_repo).flatMap(
-    (member) => member.blocked_by.filter((blocker) => blocker.repo === declared_repo && keys.has(epic_graph.key_of(blocker))).map((blocker) => ({ blocker: blocker.number, blocked: member.number }))
-  );
-}
-function bundle_children(subject, candidates) {
-  return [subject.number, ...to_numbers(candidates)].toSorted((left, right) => left - right);
-}
-var epic_bundle = {
-  names_as_blocker,
-  reference_section,
-  NO_SIGNAL_REASON,
-  already_tracked_reason,
-  has_recorded_dependency,
-  is_strong_signal,
-  membership_of,
-  decide_bundle,
-  bundle_dependency_links,
-  bundle_children
-};
-
-// scripts/epic/epic-bundle-apply.ts
-var SUCCESS_EXIT_CODE = 0;
-var FAILURE_EXIT_CODE = 1;
-var ISO_DATE_LENGTH = 10;
-var UNAPPLIED_LINES = {
-  ask: "\u21B7 `--apply` wrote nothing: the related epics declare a cycle, so none is recommended. Choose one and place it with `pnpm josh epic --add <E> <N> --decision-file <path>`.",
-  none: "\u21B7 `--apply` wrote nothing: there is nothing to place."
-};
-var WITHHELD_LINE = "\u21B7 `--apply` wrote nothing: the epic listing was cut short, so no placement was confirmed.";
-var UNREAD_EPIC_LINE = "\u2716 The new epic's number could not be read, so the recorded order was not written; run `pnpm josh epic --reconcile <E>` on it.";
-function has_order(input) {
-  return epic_bundle.bundle_dependency_links(input.subject, input.members).length > 0;
-}
-function children_of(input) {
-  return epic_bundle.bundle_children(input.subject, input.members);
-}
-async function reconcile_order(epic_number, input) {
-  if (!has_order(input)) return SUCCESS_EXIT_CODE;
-  if (epic_number === void 0) {
-    console.error(UNREAD_EPIC_LINE);
-    return FAILURE_EXIT_CODE;
-  }
-  return await epic_reconcile.reconcile_epic(epic_number);
-}
-function placeable(epic_number, input) {
-  const members = input.members.filter(
-    (member) => member.epic === void 0 || member.epic === epic_number
-  );
-  return { ...input, members };
-}
-async function add_to_epic(epic_number, input, decision) {
-  const placed = placeable(epic_number, input);
-  const added = await epic_add.add_children({
-    epic_number,
-    children: children_of(placed),
-    ...decision !== void 0 && { decision }
-  });
-  if (added !== SUCCESS_EXIT_CODE) return added;
-  return await reconcile_order(epic_number, placed);
-}
-function target_of(decision) {
-  if (decision.action === "add_to_epic") return decision.epic;
-  return decision.action === "ask" ? decision.recommended : void 0;
-}
-function record_of(input, epic_number) {
-  if (input.decision.action !== "ask") return void 0;
-  const date = (/* @__PURE__ */ new Date()).toISOString().slice(0, ISO_DATE_LENGTH);
-  const placement = {
-    subject: input.subject.number,
-    epic: epic_number,
-    epics: input.decision.epics,
-    members: input.members
-  };
-  return epic_bundle_recommend.placement_record(placement, date);
-}
-function title_of(subject) {
-  const title = subject.title ?? `bundle with ${issue_cite.plain_for("github", subject.number)}`;
-  return `Epic: ${title}`;
-}
-async function create_epic(input) {
-  const epic_number = await epic_run.create_epic_number({
-    title: title_of(input.subject),
-    children: children_of(input),
-    rationale: input.decision.reason,
-    is_ordered: false
-  });
-  return await reconcile_order(epic_number, input);
-}
-function report_unapplied(action) {
-  const line = UNAPPLIED_LINES[action];
-  if (line !== void 0) console.info(line);
-  return SUCCESS_EXIT_CODE;
-}
-async function apply_decision(input) {
-  const { decision } = input;
-  if (!input.is_membership_established) {
-    console.info(WITHHELD_LINE);
-    return SUCCESS_EXIT_CODE;
-  }
-  if (decision.action === "create_epic") return await create_epic(input);
-  const epic_number = target_of(decision);
-  if (epic_number === void 0) return report_unapplied(decision.action);
-  return await add_to_epic(epic_number, input, record_of(input, epic_number));
-}
-var epic_bundle_apply = {
-  UNAPPLIED_LINES,
-  WITHHELD_LINE,
-  UNREAD_EPIC_LINE,
-  title_of,
-  apply_decision
-};
-
-// scripts/epic/epic-bundle-evidence.ts
-function blocker_found(from, to) {
-  return epic_bundle.names_as_blocker(from, to) ? {} : void 0;
-}
-function reference_found(from, to) {
-  const section = epic_bundle.reference_section(from, to);
-  return section === void 0 ? void 0 : { section };
-}
-var EVIDENCE_TESTS = [
-  { kind: "dependency", find: blocker_found },
-  { kind: "reference", find: reference_found }
-];
-function directed_evidence(test, from, to) {
-  const found = test.find(from, to);
-  if (found === void 0) return [];
-  return [{ kind: test.kind, first: to.number, second: from.number, ...found }];
-}
-function pair_evidence(subject, other) {
-  const directions = [
-    { from: subject, to: other },
-    { from: other, to: subject }
-  ];
-  return EVIDENCE_TESTS.flatMap(
-    (test) => directions.flatMap((pair) => directed_evidence(test, pair.from, pair.to))
-  );
-}
-function member_pairs(members) {
-  return members.flatMap(
-    (left, index) => members.slice(index + 1).map((right) => ({ left, right }))
-  );
-}
-function ordering_evidence(subject, candidates) {
-  const members = [subject, ...candidates].filter((member) => member.repo === subject.repo);
-  return member_pairs(members).flatMap((pair) => pair_evidence(pair.left, pair.right));
-}
-var EVIDENCE_WORDING = {
-  dependency: { verb: "is recorded as blocked by", order_prefix: "", order_suffix: " comes first" },
-  reference: { verb: "names", order_prefix: "that points to ", order_suffix: " first" }
-};
-function section_phrase(item) {
-  return item.section === void 0 ? "" : ` in its ${item.section}`;
-}
-var EVIDENCE_HEADING = "  Evidence:";
-var EVIDENCE_INDENT_WIDTH = 4;
-var EVIDENCE_INDENT = " ".repeat(EVIDENCE_INDENT_WIDTH);
-function format_one(item) {
-  const { verb, order_prefix, order_suffix } = EVIDENCE_WORDING[item.kind];
-  const first = issue_cite.plain_for("linked", item.first);
-  const second = issue_cite.plain_for("linked", item.second);
-  const order = `${order_prefix}${first}${order_suffix}`;
-  return `${EVIDENCE_INDENT}${second} ${verb} ${first}${section_phrase(item)} \u2014 ${order}`;
-}
-function format_evidence(subject, candidates) {
-  const found = ordering_evidence(subject, candidates);
-  if (found.length === 0) return [];
-  return [EVIDENCE_HEADING, ...found.map((item) => format_one(item))];
-}
-var epic_bundle_evidence = {
-  EVIDENCE_HEADING,
-  format_evidence
-};
-
-// scripts/epic/epic-bundle-format.ts
-var ACTION_LINES = {
-  add_to_epic: "Add it to the epic that already tracks a related issue (Tier A \u2014 do it).",
-  create_epic: "Create an epic for these (Tier A \u2014 do it).",
-  ask: "Related issues sit in more than one epic: place it in the recommended one and record why \u2014 `epic:bundle --apply` does both (Tier A \u2014 do it).",
-  none: "Nothing to bundle."
-};
-var ALREADY_TRACKED_LINE = "Already in an epic \u2014 add to that one, do not create a second.";
-function headline(decision) {
-  if (decision.action === "none" && decision.epics.length > 0) return ALREADY_TRACKED_LINE;
-  return ACTION_LINES[decision.action] ?? "";
-}
-function format_numbers(numbers) {
-  return numbers.map((issue_number) => issue_cite.plain_for("linked", issue_number)).join(", ");
-}
-function members_of(decision, backlog) {
-  return backlog.filter((issue) => decision.candidates.includes(issue.number));
-}
-function format_links(links) {
-  if (links.length === 0) return "  Order: none declared \u2014 do not invent one";
-  return `  Order: ${format_dependency_links(links)}`;
-}
-function format_order(decision, subject, backlog) {
-  if (decision.action !== "add_to_epic" && decision.action !== "create_epic") return [];
-  const members = members_of(decision, backlog);
-  const children = epic_bundle.bundle_children(subject, members);
-  return [
-    `  Children: ${format_numbers(children)}`,
-    format_links(epic_bundle.bundle_dependency_links(subject, members)),
-    ...epic_bundle_evidence.format_evidence(subject, members)
-  ];
-}
-var PLACING_ACTIONS = /* @__PURE__ */ new Set([
-  "add_to_epic",
-  "create_epic",
-  "ask"
-]);
-var NO_RECOMMENDATION_LINE = "  Recommended: none \u2014 the epics declare a cycle; place it with `pnpm josh epic --add <E> <N> --decision-file <path>`";
-function format_epics(decision) {
-  if (decision.epics.length <= 1) return [];
-  const involved = `  Epics involved: ${format_numbers(decision.epics)}`;
-  if (decision.recommended === void 0) return [involved, NO_RECOMMENDATION_LINE];
-  return [involved, `  Recommended: ${issue_cite.plain_for("linked", decision.recommended)}`];
-}
-function format_decision(decision, subject, backlog, is_membership_established) {
-  if (!is_membership_established && PLACING_ACTIONS.has(decision.action)) {
-    return epic_bundle_gaps.unconfirmed_membership(format_numbers(decision.candidates)).join("\n");
-  }
-  const lines = [headline(decision), `  ${decision.reason}`];
-  if (decision.candidates.length > 0) {
-    lines.push(`  Related: ${format_numbers(decision.candidates)}`);
-  }
-  return [...lines, ...format_epics(decision), ...format_order(decision, subject, backlog)].join(
-    "\n"
-  );
-}
-var epic_bundle_format = {
-  ACTION_LINES,
-  ALREADY_TRACKED_LINE,
-  NO_RECOMMENDATION_LINE,
-  format_numbers,
-  format_epics,
-  format_order,
-  format_decision,
-  members_of
-};
-
-// scripts/epic/epic-bundle-referenced.ts
-var REFERENCED_LOOKUP_LIMIT = 20;
-function signal_first(subject) {
-  const signals = epic_audit_logic.signal_references(subject.body, subject.repo).map((reference) => reference.number);
-  const all = epic_audit_logic.parse_references(subject.body, subject.repo);
-  return [.../* @__PURE__ */ new Set([...signals, ...all])];
-}
-function referenced_lookups(subject, known) {
-  const candidates = signal_first(subject).filter(
-    (number) => number !== subject.number && !known.has(number)
-  );
-  return {
-    numbers: candidates.slice(0, REFERENCED_LOOKUP_LIMIT),
-    dropped: candidates.slice(REFERENCED_LOOKUP_LIMIT)
-  };
-}
-function to_backlog_issue(issue, context) {
-  return {
-    number: issue.number,
-    repo: context.repo,
-    body: issue.body,
-    blocked_by: epic_issue.blocker_references_of(issue, context.repo),
-    ...epic_bundle.membership_of(issue.number, epic_issue.label_names(issue), context)
-  };
-}
-function is_usable_candidate(issue, read) {
-  if (issue.is_epic === true || epic_issue.is_pull_request(read)) return false;
-  return epic_issue.is_open(read.state) || issue.epic !== void 0;
-}
-function is_failed_read(result) {
-  return typeof result === "string";
-}
-function usable_candidates(reads, context) {
-  return reads.flatMap((read) => {
-    if (is_failed_read(read.result)) return [];
-    const candidate = to_backlog_issue(read.result, context);
-    return is_usable_candidate(candidate, read.result) ? [candidate] : [];
-  });
-}
-function collect_referenced(reads, context) {
-  return {
-    issues: usable_candidates(reads, context),
-    unreadable: reads.filter((read) => read.result === "unreadable").map((read) => read.number)
-  };
-}
-function to_referenced(number, read) {
-  if (read.kind !== "read") return { number, result: read.kind };
-  return { number, result: epic_issue.parse_epic_issue(read.json) ?? "unreadable" };
-}
-async function read_plan_fields(number) {
-  return await git_gh_command.issue_get_plan_fields_classified(String(number));
-}
-async function read_one(number) {
-  return to_referenced(number, await read_plan_fields(number));
-}
-async function fetch_referenced(numbers) {
-  const reads = await git_gh_issue_batch_read.read_each(numbers, {
-    fields: PLAN_FIELDS,
-    from_json: git_gh_issue_batch_graphql.answered,
-    read_rest: read_plan_fields
-  });
-  return reads.map(([number, read]) => to_referenced(number, read));
-}
-async function referenced_candidates(subject, known, context) {
-  const { numbers, dropped } = referenced_lookups(subject, known);
-  if (numbers.length === 0 && dropped.length === 0) return void 0;
-  const found = collect_referenced(await fetch_referenced(numbers), context);
-  return { ...found, unreadable: [...found.unreadable, ...dropped] };
-}
-function is_open_issue(read) {
-  return !epic_issue.is_pull_request(read) && epic_issue.is_open(read.state);
-}
-async function read_subject(number, context) {
-  const { result } = await read_one(number);
-  if (is_failed_read(result) || !is_open_issue(result)) return void 0;
-  return { ...to_backlog_issue(result, context), title: result.title };
-}
-var epic_bundle_referenced = {
-  REFERENCED_LOOKUP_LIMIT,
-  read_subject,
-  referenced_lookups,
-  collect_referenced,
-  fetch_referenced,
-  referenced_candidates
-};
-
-// scripts/epic/epic-bundle-cli.ts
-var SUCCESS_EXIT_CODE2 = 0;
-var FAILURE_EXIT_CODE2 = 1;
-var BACKLOG_LIMIT = 200;
-var APPLY_FLAG = "--apply";
-var USAGE = "Usage: josh epic:bundle <issue-number> [--apply]";
-var UNKNOWN_REPO_MESSAGE = "Could not read this repository from `git remote`, so the backlog cannot be keyed by repository \u2014 check `gh auth status` and that this is a checkout with an `origin` remote.";
-var backlog_schema = epic_schema.extend({
-  title: z.string().nullable(),
-  labels: z.array(issue_label_schema).default([]),
-  blockedBy: blocked_by_schema
-});
-var { build_epic_index } = epic_index;
-async function list_backlog(options) {
-  return options?.include_relations === false ? await git_gh_command.issue_list_open_bodies(BACKLOG_LIMIT) : await git_gh_command.issue_list_open_relations(BACKLOG_LIMIT);
-}
-function to_backlog_issue2(row, context) {
-  const labels = row.labels.map((label) => label.name);
-  return {
-    number: row.number,
-    repo: context.repo,
-    title: row.title ?? "",
-    body: row.body ?? "",
-    blocked_by: epic_issue.blocker_references_of(row, context.repo),
-    ...epic_bundle.membership_of(row.number, labels, context)
-  };
-}
-async function fetch_backlog(repo, epics, epic_numbers = new Set(epics.values()), options) {
-  const { json, is_capped } = await list_backlog(options);
-  if (json === void 0) return { issues: [], unreadable: [], is_readable: false };
-  const rows = parse_json_array_or_undefined(json, backlog_schema);
-  if (rows === void 0) return { issues: [], unreadable: [], is_readable: false };
-  return {
-    is_readable: true,
-    // Either cutoff hides the same thing: a related issue past it, reported as "no existing issue
-    // shares a reference" — an assertion about data that was never loaded.
-    cutoff: cutoff_of(rows.length, BACKLOG_LIMIT, is_capped),
-    issues: rows.map((row) => to_backlog_issue2(row, { repo, epics, epic_numbers })),
-    unreadable: []
-  };
-}
-var { format_decision: format_decision2 } = epic_bundle_format;
-async function fetch_epics() {
-  return await epic_index.fetch_epics(BACKLOG_LIMIT);
-}
-async function read_backlog(repo, options) {
-  const open_epics = await fetch_epics();
-  if (open_epics === void 0) {
-    return { issues: [], unreadable: [], is_readable: false, has_epic_list: false };
-  }
-  const epics = build_epic_index(open_epics.epics);
-  const epic_numbers = new Set(open_epics.epics.map((epic) => epic.number));
-  return {
-    ...await fetch_backlog(repo, epics, epic_numbers, options),
-    has_epic_list: true,
-    epic_cutoff: open_epics.cutoff,
-    context: { repo, epics, epic_numbers }
-  };
-}
-async function widen_with_referenced(subject, backlog) {
-  const { context } = backlog;
-  if (context === void 0 || subject.epic !== void 0) return backlog;
-  const known = new Set(backlog.issues.map((issue) => issue.number));
-  const found = await epic_bundle_referenced.referenced_candidates(subject, known, context);
-  if (found === void 0) return backlog;
-  return {
-    ...backlog,
-    issues: [...backlog.issues, ...found.issues],
-    unreadable: [...backlog.unreadable, ...found.unreadable]
-  };
-}
-function unreadable_backlog_message(backlog) {
-  return backlog.has_epic_list === false ? "Could not list the open epics; no recommendation was made." : "Could not list the open issues; no recommendation was made.";
-}
-var NO_CUTOFF = "none";
-function warn_cutoff(message) {
-  if (message !== void 0) console.error(message);
-}
-function warn_about_gaps(backlog) {
-  if (backlog.unreadable.length > 0) {
-    const unreadable = backlog.unreadable.map((issue_number) => session_cite.issue(issue_number));
-    console.error(`\u26A0 Could not read ${unreadable.join(", ")}.`);
-  }
-  warn_cutoff(epic_bundle_gaps.backlog_gap(backlog.cutoff ?? NO_CUTOFF, BACKLOG_LIMIT));
-  warn_cutoff(epic_bundle_gaps.epic_gap(backlog.epic_cutoff ?? NO_CUTOFF, BACKLOG_LIMIT));
-}
-async function report_decision(subject, backlog, repo, is_apply) {
-  const others = backlog.issues.filter((issue) => issue.number !== subject.number);
-  const is_established = epic_bundle_gaps.is_membership_established(backlog.epic_cutoff);
-  const decision = epic_bundle.decide_bundle(subject, others);
-  const report = format_decision2(decision, subject, others, is_established);
-  console.info(issue_citation.linkify(report, repo));
-  if (!is_apply) return SUCCESS_EXIT_CODE2;
-  return await epic_bundle_apply.apply_decision({
-    decision,
-    subject,
-    members: epic_bundle_format.members_of(decision, others),
-    is_membership_established: is_established
-  });
-}
-async function report_widened(subject, backlog, repo, is_apply) {
-  const widened = await widen_with_referenced(subject, backlog);
-  warn_about_gaps(widened);
-  return await report_decision(subject, widened, repo, is_apply);
-}
-async function find_subject(issue_number, backlog) {
-  const listed = backlog.issues.find((issue) => issue.number === issue_number);
-  if (listed !== void 0 || backlog.context === void 0) return listed;
-  const read = await epic_bundle_referenced.read_subject(issue_number, backlog.context);
-  if (read !== void 0) backlog.issues.push(read);
-  return read;
-}
-async function report_for(issue_number, repo, is_apply = false) {
-  const backlog = await read_backlog(repo);
-  if (!backlog.is_readable) {
-    console.error(unreadable_backlog_message(backlog));
-    return FAILURE_EXIT_CODE2;
-  }
-  const subject = await find_subject(issue_number, backlog);
-  if (subject === void 0) {
-    console.error(
-      `${session_cite.issue(issue_number, void 0, repo)} is not an open issue in ${repo}.`
-    );
-    return FAILURE_EXIT_CODE2;
-  }
-  return await report_widened(subject, backlog, repo, is_apply);
-}
-async function run(argv) {
-  const raw_issue = argv.find((argument) => argument !== APPLY_FLAG);
-  const issue_number = epic_issue.parse_epic_number(raw_issue);
-  if (issue_number === void 0) {
-    console.error(USAGE);
-    return FAILURE_EXIT_CODE2;
-  }
-  const repo = await git_gh_command.repo_get_name_with_owner();
-  if (repo === void 0) {
-    console.error(UNKNOWN_REPO_MESSAGE);
-    return FAILURE_EXIT_CODE2;
-  }
-  return await report_for(issue_number, repo, argv.includes(APPLY_FLAG));
-}
-var epic_bundle_cli = {
-  USAGE,
-  BACKLOG_LIMIT,
-  ...epic_bundle_format,
-  build_epic_index,
-  unreadable_backlog_message,
-  read_backlog,
-  report_for,
-  fetch_epics,
-  fetch_backlog,
-  widen_with_referenced,
-  warn_about_gaps,
-  run
-};
-
-export {
-  epic_bundle,
-  epic_bundle_cli
-};