@joshuafolkken/kit 1.3041.0 → 1.3092.0

package/dist/commands/chunk-SJITWFNY.js

@@ -0,0 +1,480 @@
+import {
+  backlog_gate_scope,
+  backlog_next,
+  backlog_rank
+} from "./chunk-YNCF66RK.js";
+import {
+  epic_classify,
+  epic_outside_blocker,
+  epic_solo
+} from "./chunk-AUTD5FV2.js";
+import {
+  epic_report
+} from "./chunk-4HOTJAO6.js";
+import {
+  lane_capacity
+} from "./chunk-WR73HTRG.js";
+import {
+  epic_triage
+} from "./chunk-VQRT32JB.js";
+import {
+  auto_ok_cli
+} from "./chunk-RFIOZTXY.js";
+import {
+  epic_index
+} from "./chunk-NHTEC5U4.js";
+import {
+  epic_cross_repo
+} from "./chunk-YTXCLGGL.js";
+import {
+  issue_sample_prime
+} from "./chunk-WWLCQREY.js";
+import {
+  epic_graph
+} from "./chunk-3RIQ36LH.js";
+import {
+  git_gh_command
+} from "./chunk-NRULNBYI.js";
+import {
+  run_stalled
+} from "./chunk-N2XH7QBY.js";
+import {
+  open_issue_schema
+} from "./chunk-34DND4BA.js";
+import {
+  AUTO_OK_LABEL,
+  EPIC_LABEL,
+  IN_PROGRESS_LABEL,
+  NEEDS_DECISION_LABEL,
+  PARKED_LABELS,
+  RUN_SOLO_LABEL,
+  RUN_STALLED_LABEL,
+  has_any_label,
+  has_label_name,
+  has_parked_label
+} from "./chunk-QQBMVC5W.js";
+import {
+  session_cite
+} from "./chunk-22DVQCP6.js";
+import {
+  issue_cite
+} from "./chunk-HQ2HSZBN.js";
+import {
+  read_json_listing
+} from "./chunk-43DU7DYZ.js";
+import {
+  session_language
+} from "./chunk-OKYFQJW3.js";
+
+// scripts/backlog/backlog-plan-words.ts
+var ENGLISH_PLAN_WORDS = {
+  title: "Backlog plan",
+  nothing: "(none)",
+  named_heading: "Named issues \u2014 run in order first, one at a time, then the backlog:",
+  only_named_heading: "Named issues \u2014 run in order, one at a time, then stop (`--only`; the opted-in backlog is not run):",
+  ready_heading: "Ready now \u2014 the first wave; these may run in parallel:",
+  waiting_heading: "Waiting \u2014 each names what it is waiting on:",
+  human_heading: "Waiting on a person \u2014 resolve these before the run starts:",
+  scope_heading: "Out of scope \u2014 open, but the backlog will not run these:",
+  in_progress_note: "a run already has it",
+  past_offer_note: "waiting for a later wave (lane limit or selection gates)",
+  waiting_on: "waiting on"
+};
+var JAPANESE_PLAN_WORDS = {
+  title: "\u30D0\u30C3\u30AF\u30ED\u30B0\u8A08\u753B",
+  nothing: "\uFF08\u306A\u3057\uFF09",
+  named_heading: "\u6307\u540D\u3057\u305F Issue \u2014 \u6307\u540D\u9806\u306B 1 \u4EF6\u305A\u3064\u5148\u306B\u6D41\u3057\u3001\u305D\u306E\u5F8C\u30D0\u30C3\u30AF\u30ED\u30B0\u3078:",
+  only_named_heading: "\u6307\u540D\u3057\u305F Issue \u2014 \u6307\u540D\u9806\u306B 1 \u4EF6\u305A\u3064\u6D41\u3057\u3066\u6B62\u307E\u308B\uFF08`--only`\u3002opt-in \u6E08\u307F\u306E\u30D0\u30C3\u30AF\u30ED\u30B0\u306F\u6D41\u3055\u306A\u3044\uFF09:",
+  ready_heading: "\u4ECA\u3059\u3050\u7740\u624B\u53EF \u2014 \u6700\u521D\u306E\u7D44\u3002\u4E26\u884C\u306B\u6D41\u305B\u308B:",
+  waiting_heading: "\u5F85\u3061 \u2014 \u5404\u884C\u304C\u5F85\u3063\u3066\u3044\u308B\u76F8\u624B\u3092\u793A\u3059:",
+  human_heading: "\u4EBA\u306E\u5BFE\u5FDC\u5F85\u3061 \u2014 \u30E9\u30F3\u306E\u958B\u59CB\u524D\u306B\u89E3\u6D88\u3059\u308B:",
+  scope_heading: "\u5BFE\u8C61\u5916 \u2014 open \u3060\u304C\u30D0\u30C3\u30AF\u30ED\u30B0\u306F\u6D41\u3055\u306A\u3044:",
+  in_progress_note: "\u65E2\u306B\u5225\u306E\u30E9\u30F3\u304C\u62C5\u5F53\u4E2D",
+  past_offer_note: "\u5F8C\u7D9A\u306E\u7D44\u3092\u5F85\u3064\uFF08\u30EC\u30FC\u30F3\u4E0A\u9650\u307E\u305F\u306F\u9078\u629E\u6761\u4EF6\u306B\u3088\u308B\uFF09",
+  waiting_on: "\u5F85\u3061:"
+};
+function words_for(lang) {
+  return session_language.is_japanese(lang) ? JAPANESE_PLAN_WORDS : ENGLISH_PLAN_WORDS;
+}
+function session_words() {
+  return words_for(session_language.resolve_session_lang().lang);
+}
+var backlog_plan_words = { ENGLISH_PLAN_WORDS, JAPANESE_PLAN_WORDS, session_words, words_for };
+
+// scripts/backlog/backlog-plan.ts
+var ROW_INDENT_WIDTH = 4;
+var ROW_INDENT = " ".repeat(ROW_INDENT_WIDTH);
+var ENGLISH = backlog_plan_words.ENGLISH_PLAN_WORDS;
+var NOTHING = `${ROW_INDENT}${ENGLISH.nothing}`;
+var UNUSABLE_HEADING = "The dependency graph is unusable, so there is no plan:";
+function words_of(context) {
+  return context.words ?? ENGLISH;
+}
+function cite_of(reference, repo, title) {
+  const number = String(reference.number);
+  return reference.repo === repo ? issue_cite.reference(repo, number, title) : issue_cite.plain_for("terminal", number, reference.repo);
+}
+function reference_of(reference, repo) {
+  return cite_of(reference, repo, void 0);
+}
+function title_of(child, context) {
+  return child.repo === context.repo ? context.titles.get(child.number) : void 0;
+}
+function join_row(reference, note) {
+  return note === "" ? `${ROW_INDENT}${reference}` : `${ROW_INDENT}${reference}  \u2014 ${note}`;
+}
+var SOLO_MARK = `[${RUN_SOLO_LABEL}]`;
+var UNTRIAGED_MARK = "[untriaged]";
+function mark_of(child) {
+  if (epic_solo.is_solo(child)) return SOLO_MARK;
+  return epic_triage.is_triaged(child) ? void 0 : UNTRIAGED_MARK;
+}
+function marked_reference(child, repo, title) {
+  const reference = cite_of(child, repo, title);
+  const mark = mark_of(child);
+  return mark === void 0 ? reference : `${reference} ${mark}`;
+}
+function row_of(child, context, note) {
+  return join_row(marked_reference(child, context.repo, title_of(child, context)), note);
+}
+function is_standing(edge, context) {
+  if (context.open_numbers === void 0) return true;
+  return edge.repo !== context.repo || context.open_numbers.has(edge.number);
+}
+function open_blockers(child, context) {
+  return child.blocked_by.filter((edge) => is_standing(edge, context)).map((edge) => reference_of(edge, context.repo));
+}
+function waiting_note(child, context) {
+  const words = words_of(context);
+  if (has_label_name(child.labels, IN_PROGRESS_LABEL)) return words.in_progress_note;
+  const blockers = open_blockers(child, context);
+  if (blockers.length > 0) return `${words.waiting_on} ${blockers.join(", ")}`;
+  return words.past_offer_note;
+}
+function section(heading, lines, nothing = ENGLISH.nothing) {
+  return [heading, ...lines.length === 0 ? [`${ROW_INDENT}${nothing}`] : lines].join("\n");
+}
+function child_lines(children, context, note) {
+  return children.map((child) => row_of(child, context, note(child)));
+}
+function park_note(child) {
+  return [...PARKED_LABELS].filter((label) => has_label_name(child.labels, label)).map((label) => `\`${label}\``).join(", ");
+}
+function no_note() {
+  return "";
+}
+function ready_lines(result, context) {
+  return result.candidates.flatMap((bundle) => [
+    epic_report.format_bundle_heading(bundle),
+    ...child_lines(bundle.children, context, no_note)
+  ]);
+}
+function waiting_lines(children, context) {
+  return child_lines(children, context, function note(child) {
+    return waiting_note(child, context);
+  });
+}
+function scope_lines(rows, repo) {
+  return rows.map(
+    (row) => join_row(issue_cite.reference(repo, String(row.number), row.title), row.reason)
+  );
+}
+function format_unusable(result) {
+  const lines = result.anomalies.map((anomaly) => `${ROW_INDENT}${anomaly.message}`);
+  return [UNUSABLE_HEADING, ...lines.length === 0 ? [NOTHING] : lines].join("\n");
+}
+function named_lines(named, context) {
+  return named.map(
+    (issue) => join_row(issue_cite.reference(context.repo, String(issue), context.titles.get(issue)), "")
+  );
+}
+function named_prefix(named, context) {
+  if (named.issues.length === 0) return [];
+  const words = words_of(context);
+  return [section(words.named_heading, named_lines(named.issues, context), words.nothing), ""];
+}
+function title_line(context) {
+  return `${words_of(context).title} \u2014 ${context.repo}`;
+}
+function format_only(named, context) {
+  const words = words_of(context);
+  return [
+    title_line(context),
+    "",
+    section(words.only_named_heading, named_lines(named.issues, context), words.nothing)
+  ].join("\n");
+}
+function pool_sections(result, out_of_scope2, context) {
+  const words = words_of(context);
+  return [
+    section(words.ready_heading, ready_lines(result, context), words.nothing),
+    "",
+    section(words.waiting_heading, waiting_lines(result.waiting, context), words.nothing),
+    "",
+    section(
+      words.human_heading,
+      child_lines(result.blocked_on_people, context, park_note),
+      words.nothing
+    ),
+    "",
+    section(words.scope_heading, scope_lines(out_of_scope2, context.repo), words.nothing)
+  ];
+}
+function format_plan(result, out_of_scope2, context, named) {
+  if (result.verdict === "error") return format_unusable(result);
+  if (named.only) return format_only(named, context);
+  return [
+    title_line(context),
+    "",
+    ...named_prefix(named, context),
+    ...pool_sections(result, out_of_scope2, context)
+  ].join("\n");
+}
+var backlog_plan = {
+  HUMAN_HEADING: ENGLISH.human_heading,
+  IN_PROGRESS_NOTE: ENGLISH.in_progress_note,
+  NAMED_HEADING: ENGLISH.named_heading,
+  NOTHING,
+  ONLY_NAMED_HEADING: ENGLISH.only_named_heading,
+  PAST_OFFER_NOTE: ENGLISH.past_offer_note,
+  READY_HEADING: ENGLISH.ready_heading,
+  SCOPE_HEADING: ENGLISH.scope_heading,
+  SOLO_MARK,
+  UNTRIAGED_MARK,
+  UNUSABLE_HEADING,
+  WAITING_HEADING: ENGLISH.waiting_heading,
+  format_plan,
+  format_unusable,
+  is_standing,
+  marked_reference,
+  row_of,
+  section,
+  waiting_note
+};
+
+// scripts/backlog/backlog-scope.ts
+var EPIC_LABELS = /* @__PURE__ */ new Set([EPIC_LABEL]);
+var AUTO_OK_LABELS = /* @__PURE__ */ new Set([AUTO_OK_LABEL]);
+var NO_OPT_IN_REASON = "not opted in \u2014 no `auto-ok` label";
+var EPIC_NOT_OPTED_IN_REASON = "epic root without `auto-ok` \u2014 it offers no children, and only a child carrying `auto-ok` itself is offered";
+var EPIC_ROOT_REASON = "epic root \u2014 a container, so its children are planned instead of it";
+var OPTED_IN_UNPLACED_REASON = "opted in, but past the listing cap this ask could read";
+function epic_tracked_reason(epic) {
+  return `tracked by epic ${session_cite.issue(epic)}, which offers it instead of the standalone half`;
+}
+var EXCLUDED_REASON = "excluded from this ask \u2014 it merged moments ago";
+function planned_numbers(result, repo) {
+  const children = [
+    ...result.candidates.flatMap((bundle) => bundle.children),
+    ...result.waiting,
+    ...result.blocked_on_people
+  ];
+  return new Set(children.filter((child) => child.repo === repo).map((child) => child.number));
+}
+function opted_in_reason(issue, tracked) {
+  const epic = tracked.get(issue.number);
+  return epic === void 0 ? OPTED_IN_UNPLACED_REASON : epic_tracked_reason(epic);
+}
+function label_reason(issue, tracked) {
+  const is_opted_in = has_any_label(issue.labels, AUTO_OK_LABELS);
+  if (has_any_label(issue.labels, EPIC_LABELS)) {
+    return is_opted_in ? EPIC_ROOT_REASON : EPIC_NOT_OPTED_IN_REASON;
+  }
+  return is_opted_in ? opted_in_reason(issue, tracked) : NO_OPT_IN_REASON;
+}
+function reason_for(issue, scope) {
+  return scope.exclude.includes(issue.number) ? EXCLUDED_REASON : label_reason(issue, scope.tracked);
+}
+function out_of_scope(open_issues, result, scope) {
+  const planned = planned_numbers(result, scope.repo);
+  return open_issues.filter((issue) => !planned.has(issue.number)).map((issue) => ({
+    number: issue.number,
+    title: issue.title,
+    reason: reason_for(issue, scope)
+  }));
+}
+function titles_of(open_issues) {
+  return new Map(open_issues.map((issue) => [issue.number, issue.title]));
+}
+function open_numbers_of(open_issues) {
+  return new Set(open_issues.map((issue) => issue.number));
+}
+var backlog_scope = {
+  epic_tracked_reason,
+  EPIC_NOT_OPTED_IN_REASON,
+  EPIC_ROOT_REASON,
+  EXCLUDED_REASON,
+  NO_OPT_IN_REASON,
+  OPTED_IN_UNPLACED_REASON,
+  open_numbers_of,
+  out_of_scope,
+  titles_of
+};
+
+// scripts/backlog/backlog-plan-read.ts
+async function read_wave_limit() {
+  const choice = await lane_capacity.lane_limit();
+  return choice.kind === "limit" ? lane_capacity.seated_limit(choice.limit) : void 0;
+}
+async function classify(opted_in, exclude) {
+  const context = await backlog_next.context_of(opted_in, exclude);
+  if (context === void 0) return void 0;
+  const result = await backlog_next.resolve(context);
+  if (result === void 0) return void 0;
+  return {
+    result,
+    repo: context.repo,
+    exclude,
+    tracked: epic_index.withheld_children(context.tracking.index, context.opted_in.issues),
+    scope: {
+      ...await backlog_gate_scope.gate_scope(context),
+      wave_limit: await read_wave_limit()
+    }
+  };
+}
+async function fetch_open() {
+  const { json, is_capped } = await git_gh_command.issue_list_recent(auto_ok_cli.LISTING_LIMIT);
+  if (json === void 0) return void 0;
+  const read = read_json_listing(json, open_issue_schema);
+  if (read.kind !== "read") return void 0;
+  await issue_sample_prime.prime(read.rows.map((row) => row.body));
+  return { rows: read.rows, is_capped };
+}
+function context_of(plan, listing) {
+  return {
+    repo: plan.repo,
+    titles: backlog_scope.titles_of(listing.rows),
+    open_numbers: listing.is_capped ? void 0 : backlog_scope.open_numbers_of(listing.rows)
+  };
+}
+async function with_listing(plan) {
+  if (plan === void 0) return void 0;
+  const listing = await fetch_open();
+  return listing === void 0 ? void 0 : { plan, listing };
+}
+async function read_plan(exclude = []) {
+  const opted_in = await auto_ok_cli.fetch_opted_in();
+  if (opted_in.kind !== "read") return void 0;
+  return await with_listing(await classify(opted_in, exclude));
+}
+var backlog_plan_read = { classify, context_of, fetch_open, read_plan };
+
+// scripts/backlog/backlog-waves.ts
+var IDLE = { kind: "idle" };
+var CLOSED = "CLOSED";
+var EMPTY_SCOPE = { standalone: /* @__PURE__ */ new Set(), declared: /* @__PURE__ */ new Map() };
+var UNCAPPED = Infinity;
+var HEADING_ASSUMPTION = "Assumes every issue in a wave merges before the next wave starts. Issues a run already has are left out and count as merged first, and only issues of this repository are planned.";
+var UNCAPPED_WIDTH = "A wave is not capped: the lane limit could not be read.";
+var UNREACHED_HEADING = "Not reached \u2014 each names what it is waiting on:";
+var PARALLEL_NOTE = "(parallel)";
+var NEEDS_DECISION_NOTE = `waiting on a person (\`${NEEDS_DECISION_LABEL}\`)`;
+var NOT_REACHED_NOTE = "not reached by the waves above";
+var WAVE_GAP_WIDTH = 2;
+var PARALLEL_GAP_WIDTH = 3;
+var WAVE_GAP = " ".repeat(WAVE_GAP_WIDTH);
+var PARALLEL_GAP = " ".repeat(PARALLEL_GAP_WIDTH);
+function is_running(child) {
+  return has_label_name(child.labels, IN_PROGRESS_LABEL) && !has_parked_label(child.labels);
+}
+function as_closed(child, done) {
+  return done.has(epic_graph.key_of(child)) ? { ...child, state: CLOSED } : child;
+}
+function pool_of(result, repo, scope) {
+  const all = backlog_rank.everything_in(result);
+  return { children: all, running: epic_outside_blocker.running_keys(all), repo, scope };
+}
+function offer(candidates, children, pool) {
+  const { repo, scope } = pool;
+  const limit = scope.wave_limit ?? UNCAPPED;
+  return backlog_rank.select({ candidates, pool: children, read: IDLE, repo, ...scope, limit }).offered;
+}
+function first_wave(result, pool) {
+  const candidates = epic_report.candidates_for_repo(result, pool.repo);
+  return offer(candidates, backlog_rank.everything_in(result), pool);
+}
+function next_wave(pool, done) {
+  const children = pool.children.map((child) => as_closed(child, done));
+  const { runnable } = epic_classify.classify_children(
+    children,
+    epic_cross_repo.resolve_cross_repo,
+    pool.running
+  );
+  return offer(
+    runnable.filter((child) => child.repo === pool.repo),
+    children,
+    pool
+  );
+}
+function opening_wave(result, pool, done) {
+  const wave = first_wave(result, pool);
+  return wave.length > 0 ? wave : next_wave(pool, done);
+}
+function build(result, repo, scope = EMPTY_SCOPE) {
+  const pool = pool_of(result, repo, scope);
+  const running = pool.children.filter((child) => child.repo === repo && is_running(child));
+  const done = new Set(running.map((child) => epic_graph.key_of(child)));
+  const waves = [];
+  for (let wave = opening_wave(result, pool, done); wave.length > 0; wave = next_wave(pool, done)) {
+    waves.push(wave);
+    for (const child of wave) done.add(epic_graph.key_of(child));
+  }
+  const unreached = backlog_rank.everything_in(result).filter((child) => child.repo === repo && !done.has(epic_graph.key_of(child)));
+  return { waves, unreached, running };
+}
+function run_stalled_note(child) {
+  return `stalled mechanically \u2014 ${run_stalled.next_step(child)}`;
+}
+function unreached_note(child, context) {
+  if (has_label_name(child.labels, NEEDS_DECISION_LABEL)) return NEEDS_DECISION_NOTE;
+  if (has_label_name(child.labels, RUN_STALLED_LABEL)) return run_stalled_note(child.number);
+  const note = backlog_plan.waiting_note(child, context);
+  return note === backlog_plan.PAST_OFFER_NOTE ? NOT_REACHED_NOTE : note;
+}
+function wave_line(wave, index, repo) {
+  const references = wave.map((child) => backlog_plan.marked_reference(child, repo)).join(" ");
+  const suffix = wave.length > 1 ? `${PARALLEL_GAP}${PARALLEL_NOTE}` : "";
+  return `Wave ${String(index + 1)}${WAVE_GAP}${references}${suffix}`;
+}
+function unreached_lines(plan, context) {
+  return plan.unreached.map(
+    (child) => backlog_plan.row_of(child, context, unreached_note(child, context))
+  );
+}
+function width_line(wave_limit) {
+  if (wave_limit === void 0) return UNCAPPED_WIDTH;
+  return `A wave holds at most ${String(wave_limit)} standalone issues, the lane limit; an epic's children are not counted.`;
+}
+function format_waves(result, context, scope = EMPTY_SCOPE) {
+  if (result.verdict === "error") return backlog_plan.format_unusable(result);
+  const plan = build(result, context.repo, scope);
+  const waves = plan.waves.map((wave, index) => wave_line(wave, index, context.repo));
+  return [
+    `Backlog waves \u2014 ${context.repo}`,
+    HEADING_ASSUMPTION,
+    width_line(scope.wave_limit),
+    "",
+    ...waves.length === 0 ? [backlog_plan.NOTHING] : waves,
+    "",
+    backlog_plan.section(UNREACHED_HEADING, unreached_lines(plan, context))
+  ].join("\n");
+}
+var backlog_waves = {
+  HEADING_ASSUMPTION,
+  NEEDS_DECISION_NOTE,
+  PARALLEL_NOTE,
+  run_stalled_note,
+  UNCAPPED_WIDTH,
+  UNREACHED_HEADING,
+  build,
+  format_waves,
+  width_line
+};
+
+export {
+  backlog_plan_words,
+  backlog_plan,
+  backlog_scope,
+  backlog_plan_read,
+  backlog_waves
+};

package/dist/commands/chunk-SKGDMAIA.js

@@ -0,0 +1,33 @@
+import {
+  run_carry,
+  run_carry_conversation
+} from "./chunk-DS53UUDH.js";
+import {
+  stamp_file
+} from "./chunk-VLN6TSPJ.js";
+
+// scripts/run/carry/run-carry-reclaim.ts
+function reclaimed_owner(carry, owner) {
+  if (owner.session === void 0 || owner.session !== carry.owner_session) {
+    return run_carry_conversation.reclaim_owner(carry, owner);
+  }
+  if (owner.pid === void 0 || carry.is_handed_off === true) return carry;
+  return { ...carry, owner_pid: owner.pid, owner_start: owner.start };
+}
+function reclaim_at(target, owner) {
+  const read = run_carry.read_carry(target);
+  if (read.kind !== "carried") return false;
+  const reclaimed = reclaimed_owner(read.carry, owner);
+  if (reclaimed === read.carry) return false;
+  stamp_file.replace_stamp(target, reclaimed);
+  return true;
+}
+async function reclaim_carry(owner) {
+  const directory = await run_carry.repository_directory();
+  return directory !== void 0 && reclaim_at(run_carry.carry_path(directory), owner);
+}
+var run_carry_reclaim = { reclaim_at, reclaim_carry };
+
+export {
+  run_carry_reclaim
+};