@joshuafolkken/kit 1.3099.0 → 1.3125.0

package/dist/commands/chunk-B4W77FVS.js

@@ -0,0 +1,704 @@
+import {
+  epic_run
+} from "./chunk-HN3EGYAI.js";
+import {
+  epic_add,
+  epic_reconcile
+} from "./chunk-XMNPU3J5.js";
+import {
+  epic_bundle_gaps
+} from "./chunk-N2EE7MMH.js";
+import {
+  epic_index,
+  epic_schema
+} from "./chunk-2ROVUERM.js";
+import {
+  epic_issue
+} from "./chunk-GXXWRH6F.js";
+import {
+  git_gh_issue_batch_graphql,
+  git_gh_issue_batch_read
+} from "./chunk-WHYYBPIC.js";
+import {
+  cutoff_of
+} from "./chunk-SK3GDQOI.js";
+import {
+  epic_audit_logic
+} from "./chunk-RVFE7JDZ.js";
+import {
+  epic_graph
+} from "./chunk-3RIQ36LH.js";
+import {
+  format_dependency_links
+} from "./chunk-2ADQ5XRD.js";
+import {
+  git_gh_command
+} from "./chunk-VJNE7W7O.js";
+import {
+  PLAN_FIELDS
+} from "./chunk-U6SMBYTN.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-NAZ753DE.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
+};