@joshuafolkken/kit 1.3041.0 → 1.3092.0

package/dist/commands/chunk-VY7ZJMDT.js

@@ -0,0 +1,469 @@
+import {
+  epic_add_body,
+  epic_chains,
+  epic_read,
+  epic_shape
+} from "./chunk-MOD3FG4V.js";
+import {
+  epic_decision
+} from "./chunk-XSKB6ZUA.js";
+import {
+  epic_relations
+} from "./chunk-WTIPX5NG.js";
+import {
+  backlog_ready
+} from "./chunk-7OEBSPPU.js";
+import {
+  epic_issue
+} from "./chunk-YEAE46TS.js";
+import {
+  epic_parse
+} from "./chunk-VDGNXSP3.js";
+import {
+  epic_graph
+} from "./chunk-3RIQ36LH.js";
+import {
+  format_dependency_links,
+  format_issue_references,
+  format_replaced_relations,
+  to_issue_reference
+} from "./chunk-2ADQ5XRD.js";
+import {
+  git_gh_command
+} from "./chunk-NRULNBYI.js";
+import {
+  session_cite
+} from "./chunk-22DVQCP6.js";
+
+// scripts/epic/epic-add-plan.ts
+function to_additions(input, tracked, declared) {
+  return input.children.filter(
+    (child) => child !== input.epic_number && !tracked.includes(child) && !declared.includes(child)
+  );
+}
+function declared_numbers(chains) {
+  return [...new Set(chains.flat())];
+}
+function to_relocations(input, tracked) {
+  if (input.position === void 0) return [];
+  return input.children.filter((child) => child !== input.epic_number && tracked.includes(child));
+}
+function to_placed(children, additions, relocations) {
+  const placed = /* @__PURE__ */ new Set([...additions, ...relocations]);
+  return [...new Set(children.filter((child) => placed.has(child)))];
+}
+function find_self_position_error(input) {
+  const { position } = input;
+  if (position === void 0 || !input.children.includes(position.target)) return void 0;
+  return `${to_issue_reference(position.target)} cannot position an insertion of itself.`;
+}
+function to_nothing_to_do_error(position) {
+  const nothing = "Every issue given is already tracked by this epic; nothing to add.";
+  if (position !== void 0) return nothing;
+  return `${nothing} Name \`--before <M>\` or \`--after <M>\` to declare an order between children it already tracks, or \`--order-before <M>\` / \`--order-after <M>\` to move the row without declaring one.`;
+}
+function find_movement_error(moves, position, tracked) {
+  if (moves.additions.length === 0 && moves.relocations.length === 0) {
+    return to_nothing_to_do_error(position);
+  }
+  if (position !== void 0 && !tracked.includes(position.target)) {
+    const reference = to_issue_reference(position.target);
+    return `${reference} is not a child of this epic, so it cannot position an insertion.`;
+  }
+  return void 0;
+}
+function find_relation_error(links, recorded, repo) {
+  const undeclared = epic_graph.undeclared_relations(links, recorded, repo);
+  if (undeclared.length === 0) return void 0;
+  const list = format_dependency_links(undeclared);
+  return `The epic already records relations its body does not declare (${list}); reconcile them before inserting.`;
+}
+function to_rewrite_input(context, decision) {
+  return {
+    body: context.input.body ?? "",
+    placed: context.placed,
+    position: context.input.position,
+    chains_after: context.chains_after,
+    decision
+  };
+}
+function to_added_links(context, links_after) {
+  if (context.input.is_order_only === true) return [];
+  return epic_graph.missing_relations(links_after, context.input.recorded, context.input.repo);
+}
+function does_declare_order(chains, blocker, blocked) {
+  return chains.some((chain) => {
+    const at_blocker = chain.indexOf(blocker);
+    return at_blocker !== -1 && at_blocker < chain.indexOf(blocked);
+  });
+}
+function does_row_contradict_order(chains, rows, child) {
+  const child_at = rows.indexOf(child);
+  return rows.some((other, other_at) => {
+    if (other === child) return false;
+    if (other_at < child_at) return does_declare_order(chains, child, other);
+    return does_declare_order(chains, other, child);
+  });
+}
+function to_contradicted(context, result_rows) {
+  if (context.input.position === void 0 || context.input.is_order_only !== true) return [];
+  return context.placed.filter(
+    (child) => does_row_contradict_order(context.chains_before, result_rows, child)
+  );
+}
+function to_plan(context) {
+  const { removed: replaced } = epic_chains.diff_links(context.chains_before, context.chains_after);
+  const decision = epic_decision.append_replacements(context.input.decision, replaced);
+  const rewritten = epic_add_body.rewrite_body(to_rewrite_input(context, decision));
+  if ("error" in rewritten) return { error: rewritten.error };
+  const links_after = epic_chains.links_of(context.chains_after);
+  const result_rows = epic_parse.parse_task_list_issue_numbers(rewritten.body);
+  return {
+    plan: {
+      body: rewritten.body,
+      additions: context.additions,
+      relocations: context.relocations,
+      added: to_added_links(context, links_after),
+      // Only the links a relation actually backs: asking `gh` to remove one that was never
+      // recorded is reported as a failure the user cannot act on.
+      removed: epic_graph.recorded_relations(replaced, context.input.recorded, context.input.repo),
+      replaced,
+      contradicted: to_contradicted(context, result_rows),
+      decision
+    }
+  };
+}
+function find_decision_error(decision) {
+  return decision === void 0 ? void 0 : epic_decision.find_decision_error(decision);
+}
+function find_ambiguity_error(input, chains_before) {
+  if (input.is_order_only === true) return void 0;
+  return epic_chains.find_position_ambiguity(chains_before, input.position);
+}
+function find_placement_error(input, tracked, chains_before) {
+  const declared = declared_numbers(chains_before);
+  return find_self_position_error(input) ?? find_movement_error(
+    {
+      additions: to_additions(input, tracked, declared),
+      relocations: to_relocations(input, tracked)
+    },
+    input.position,
+    tracked
+  ) ?? find_ambiguity_error(input, chains_before);
+}
+function find_input_error(input, tracked, chains_before) {
+  return epic_shape.find_subject_error(input, tracked) ?? find_placement_error(input, tracked, chains_before) ?? find_relation_error(epic_chains.links_of(chains_before), input.recorded, input.repo) ?? find_decision_error(input.decision);
+}
+function to_chains_after(input, chains_before, moves, tracked) {
+  if (input.is_order_only === true) return epic_chains.keep_declaration(chains_before);
+  return epic_chains.insert_children(
+    epic_chains.remove_children(chains_before, moves.relocations),
+    moves.placed,
+    input.position,
+    tracked
+  );
+}
+function build_plan(input) {
+  const tracked = epic_parse.parse_task_list_issue_numbers(input.body);
+  const chains_before = epic_parse.parse_dependency_chains(input.body);
+  const error = find_input_error(input, tracked, chains_before);
+  if (error !== void 0) return { error };
+  const additions = to_additions(input, tracked, declared_numbers(chains_before));
+  const relocations = to_relocations(input, tracked);
+  const placed = to_placed(input.children, additions, relocations);
+  const inserted = to_chains_after(input, chains_before, { placed, relocations }, tracked);
+  if ("error" in inserted) return { error: inserted.error };
+  return to_plan({
+    input,
+    additions,
+    relocations,
+    placed,
+    chains_before,
+    chains_after: inserted.chains
+  });
+}
+var epic_add_plan = {
+  build_plan
+};
+
+// scripts/epic/epic-add.ts
+var FAILURE_EXIT_CODE = 1;
+var SUCCESS_EXIT_CODE = 0;
+function is_closed_epic(state) {
+  return state !== void 0 && epic_issue.normalize_state(state) === epic_issue.CLOSED;
+}
+function closed_epic_error(epic_number) {
+  return `Epic ${session_cite.issue(epic_number)} is closed \u2014 a completed epic takes no new children. Reopen it if it is not actually done, or run \`pnpm josh epic:bundle <child>\` to place the child in an open epic instead.`;
+}
+function report_relations(plan, failures) {
+  if (plan.removed.length > 0) {
+    console.info(
+      epic_relations.format_relation_report({
+        links: plan.removed,
+        failures: failures.removed,
+        action: "drop"
+      })
+    );
+  }
+  if (plan.added.length === 0) return;
+  console.info(
+    epic_relations.format_relation_report({
+      links: plan.added,
+      failures: failures.added,
+      action: "record"
+    })
+  );
+}
+async function apply_plan(plan) {
+  const removed = await epic_relations.apply_relations(plan.removed, "drop");
+  const added = await epic_relations.apply_relations(plan.added, "record");
+  report_relations(plan, { added, removed });
+}
+function report_contradiction(plan) {
+  if (plan.contradicted.length === 0) return;
+  console.info(
+    session_cite.text(
+      `\u26A0\uFE0F ${format_issue_references(plan.contradicted)} is still held by a declared order, so \`epic:next\` will not offer it any earlier until that order is changed \u2014 \`--remove\` deletes one.`
+    )
+  );
+}
+function report_order(input, plan) {
+  const { position } = input;
+  if (position === void 0) return;
+  const placed = format_issue_references([...plan.additions, ...plan.relocations]);
+  const target = to_issue_reference(position.target);
+  console.info(
+    session_cite.text(
+      `\u{1F4CB} Placed ${placed} ${position.kind} ${target} in epic ${session_cite.issue(input.epic_number)} \u2014 order only, no dependency written.`
+    )
+  );
+  report_contradiction(plan);
+}
+function report_placements(input, plan) {
+  if (input.is_order_only === true) {
+    report_order(input, plan);
+    return;
+  }
+  const epic = `epic ${session_cite.issue(input.epic_number)}`;
+  if (plan.additions.length > 0) {
+    console.info(
+      session_cite.text(`\u{1F4CB} Added ${format_issue_references(plan.additions)} to ${epic}.`)
+    );
+  }
+  if (plan.relocations.length > 0) {
+    console.info(
+      session_cite.text(`\u{1F4CB} Moved ${format_issue_references(plan.relocations)} within ${epic}.`)
+    );
+  }
+}
+function report_success(input, plan) {
+  report_placements(input, plan);
+  if (plan.replaced.length > 0) {
+    console.info(`\u21AA ${format_replaced_relations(plan.replaced)}`);
+  }
+}
+async function comment_decision(children, decision) {
+  const posted = await Promise.all(
+    children.map(async (child) => await git_gh_command.issue_try_comment(String(child), decision))
+  );
+  console.info(
+    epic_decision.format_decision_report({
+      total: children.length,
+      failures: posted.filter((is_posted) => !is_posted).length
+    })
+  );
+}
+function has_new_child(input, plan) {
+  return input.is_order_only !== true && plan.additions.length > 0;
+}
+async function write_plan(input, plan) {
+  await git_gh_command.issue_edit_body(String(input.epic_number), plan.body);
+  report_success(input, plan);
+  await apply_plan(plan);
+  if (plan.decision !== void 0) {
+    await comment_decision([...plan.additions, ...plan.relocations], plan.decision);
+  }
+  if (has_new_child(input, plan)) await backlog_ready.print_offer_hint();
+}
+async function read_open_epic(epic_number) {
+  const epic = await epic_read.read_epic(epic_number);
+  if ("error" in epic) return epic;
+  if (is_closed_epic(epic.subject.state)) return { error: closed_epic_error(epic_number) };
+  return epic;
+}
+async function add_children(input) {
+  const epic = await read_open_epic(input.epic_number);
+  if ("error" in epic) {
+    console.error(`\u2716 ${epic.error}`);
+    return FAILURE_EXIT_CODE;
+  }
+  const outcome = epic_add_plan.build_plan({
+    epic_number: input.epic_number,
+    body: epic.subject.body,
+    labels: epic.subject.labels,
+    children: input.children,
+    position: input.position,
+    is_order_only: input.is_order_only,
+    recorded: epic.recorded,
+    repo: epic.repo,
+    decision: input.decision
+  });
+  if ("error" in outcome) {
+    console.error(`\u2716 ${outcome.error}`);
+    return FAILURE_EXIT_CODE;
+  }
+  await write_plan(input, outcome.plan);
+  return SUCCESS_EXIT_CODE;
+}
+var epic_add = {
+  add_children
+};
+
+// scripts/epic/epic-reconcile.ts
+var FAILURE_EXIT_CODE2 = 1;
+var SUCCESS_EXIT_CODE2 = 0;
+var NOTHING_TO_RECONCILE = "nothing to reconcile";
+var RECONCILED = "reconciled";
+function to_chain(link) {
+  return [link.blocker, link.blocked];
+}
+function to_blocker(link, repo) {
+  return { repo, number: link.blocker };
+}
+function to_children(links, repo) {
+  const blockers = /* @__PURE__ */ new Map();
+  for (const link of links) {
+    blockers.set(link.blocked, [...blockers.get(link.blocked) ?? [], to_blocker(link, repo)]);
+  }
+  const numbers = new Set(links.flatMap((link) => [link.blocker, link.blocked]));
+  return [...numbers].map((number) => ({
+    number,
+    repo,
+    state: "OPEN",
+    labels: [],
+    blocked_by: blockers.get(number) ?? []
+  }));
+}
+function find_cycle(links, repo) {
+  const anomalies = epic_graph.find_anomalies(to_children(links, repo), links, true, repo);
+  return anomalies.find((anomaly) => anomaly.kind === "cycle")?.message;
+}
+function to_reconciled_body(body, target_chains) {
+  return epic_add_body.rewrite_body({
+    body: body ?? "",
+    placed: [],
+    position: void 0,
+    chains_after: target_chains,
+    decision: void 0
+  });
+}
+function read_mismatch(input) {
+  const chains_before = epic_parse.parse_dependency_chains(input.body);
+  const declared = epic_chains.links_of(chains_before);
+  return {
+    chains_before,
+    declare: epic_graph.undeclared_relations(declared, input.recorded, input.repo),
+    record: epic_graph.missing_relations(declared, input.recorded, input.repo)
+  };
+}
+function to_reconciled_plan(input, mismatch) {
+  const declared_chains = mismatch.declare.map((link) => to_chain(link));
+  const target_chains = [...mismatch.chains_before, ...declared_chains];
+  const cycle = find_cycle(epic_chains.links_of(target_chains), input.repo);
+  if (cycle !== void 0) return { kind: "cycle", message: cycle };
+  const { declare, record } = mismatch;
+  if (declare.length === 0) {
+    return { kind: "reconciled", reconciliation: { body: void 0, declare, record } };
+  }
+  const rewritten = to_reconciled_body(input.body, target_chains);
+  if ("error" in rewritten) return { kind: "error", error: rewritten.error };
+  return { kind: "reconciled", reconciliation: { body: rewritten.body, declare, record } };
+}
+function build_reconcile_plan(input) {
+  const mismatch = read_mismatch(input);
+  if (mismatch.declare.length === 0 && mismatch.record.length === 0) return { kind: "nothing" };
+  return to_reconciled_plan(input, mismatch);
+}
+function report_agreement(epic_number) {
+  console.info(
+    `${RECONCILED} ${session_cite.issue(epic_number)} \u2014 epic:audit and backlog:next now agree on this epic's order.`
+  );
+}
+function report_declared(epic_number, declare) {
+  if (declare.length === 0) return;
+  console.info(
+    session_cite.text(
+      `\u{1F4CB} Declared ${format_dependency_links(declare)} in epic ${session_cite.issue(epic_number)} to match the recorded relations.`
+    )
+  );
+}
+async function record_relations(record) {
+  if (record.length === 0) return;
+  const failures = await epic_relations.apply_relations(record, "record");
+  console.info(epic_relations.format_relation_report({ links: record, failures, action: "record" }));
+}
+async function apply_reconciliation(epic_number, reconciliation) {
+  if (reconciliation.body !== void 0) {
+    await git_gh_command.issue_edit_body(String(epic_number), reconciliation.body);
+  }
+  report_declared(epic_number, reconciliation.declare);
+  await record_relations(reconciliation.record);
+  report_agreement(epic_number);
+  return SUCCESS_EXIT_CODE2;
+}
+async function apply_plan2(epic_number, plan) {
+  if (plan.kind === "nothing") {
+    console.info(NOTHING_TO_RECONCILE);
+    return SUCCESS_EXIT_CODE2;
+  }
+  if (plan.kind === "reconciled") {
+    return await apply_reconciliation(epic_number, plan.reconciliation);
+  }
+  console.error(`\u2716 ${plan.kind === "cycle" ? plan.message : plan.error}`);
+  return FAILURE_EXIT_CODE2;
+}
+async function reconcile_epic(epic_number) {
+  const epic = await epic_read.read_epic(epic_number);
+  if ("error" in epic) {
+    console.error(`\u2716 ${epic.error}`);
+    return FAILURE_EXIT_CODE2;
+  }
+  const plan = build_reconcile_plan({
+    body: epic.subject.body,
+    recorded: epic.recorded,
+    repo: epic.repo
+  });
+  return await apply_plan2(epic_number, plan);
+}
+function with_recorded(recorded, link, repo) {
+  return recorded.map(
+    (child) => child.number === link.blocked && child.repo === repo ? { ...child, blocked_by: [...child.blocked_by, to_blocker(link, repo)] } : child
+  );
+}
+function build_plan_after(input, link) {
+  return build_reconcile_plan({
+    ...input,
+    recorded: with_recorded(input.recorded, link, input.repo)
+  });
+}
+async function refusal_after(epic_number, link) {
+  const epic = await epic_read.read_epic(epic_number);
+  if ("error" in epic) throw new Error(epic.error);
+  const input = { body: epic.subject.body, recorded: epic.recorded, repo: epic.repo };
+  const plan = build_plan_after(input, link);
+  if (plan.kind === "cycle") return plan.message;
+  return plan.kind === "error" ? plan.error : void 0;
+}
+var epic_reconcile = {
+  NOTHING_TO_RECONCILE,
+  RECONCILED,
+  build_plan_after,
+  build_reconcile_plan,
+  reconcile_epic,
+  refusal_after
+};
+
+export {
+  epic_add,
+  epic_reconcile
+};

package/dist/commands/chunk-W3MDLQZF.js

@@ -0,0 +1,137 @@
+import {
+  lane_implement_signals
+} from "./chunk-CNL3SLM6.js";
+import {
+  run_event_step
+} from "./chunk-X4LYH6Q4.js";
+import {
+  run_hold_cli
+} from "./chunk-GWTBIGYC.js";
+import {
+  lane_breakdown_implement,
+  lane_transcript_stats
+} from "./chunk-A3JYZWBS.js";
+import {
+  lane_plan
+} from "./chunk-MDGPJOLK.js";
+import {
+  run_stage
+} from "./chunk-UWLLZQJB.js";
+import {
+  run_step
+} from "./chunk-F4YMLVWN.js";
+import {
+  run_event_stream_emit
+} from "./chunk-26JL4UU4.js";
+import {
+  run_event_stream
+} from "./chunk-KGSEWOKI.js";
+
+// scripts/run/entry/run-entry.ts
+var SUMMARY_PREFIX = "entry #";
+var SUMMARY_DASH = " \u2014 ";
+var FIELD_SEPARATOR = " \xB7 ";
+var HOLD_LABEL = "hold: ";
+var COST_LABEL = "cost: ";
+var VERDICT_LABEL = "verdict: ";
+var SECTION_SEPARATOR = "\n\n";
+var COST_UNDER = "under";
+var COST_OVER = "over";
+var COST_SKIPPED = "skipped";
+var NO_VERDICT = "-";
+var GATE_VERDICT = "gate";
+var SUCCESS_EXIT_CODE = 0;
+var FAILURE_EXIT_CODE = 1;
+function summary(parts) {
+  const fields = [
+    `${HOLD_LABEL}${parts.hold}`,
+    `${COST_LABEL}${parts.cost}`,
+    `${VERDICT_LABEL}${parts.verdict}`
+  ];
+  return `${SUMMARY_PREFIX}${parts.issue_number}${SUMMARY_DASH}${fields.join(FIELD_SEPARATOR)}`;
+}
+function format_report(parts) {
+  return [summary(parts), parts.report].join(SECTION_SEPARATOR);
+}
+function can_proceed(hold, cost) {
+  return hold === run_hold_cli.HOLD_VERDICT && cost !== COST_OVER;
+}
+function exit_code(parts) {
+  const is_ok = can_proceed(parts.hold, parts.cost) && parts.verdict !== run_step.UNKNOWN;
+  return is_ok ? SUCCESS_EXIT_CODE : FAILURE_EXIT_CODE;
+}
+function stage_verdict(state, verdict) {
+  return state === run_stage.PR_OPEN && verdict === run_step.IMPLEMENT ? GATE_VERDICT : verdict;
+}
+var run_entry = {
+  COST_OVER,
+  COST_SKIPPED,
+  COST_UNDER,
+  GATE_VERDICT,
+  NO_VERDICT,
+  exit_code,
+  format_report,
+  can_proceed,
+  summary,
+  stage_verdict
+};
+
+// scripts/lane/lane-implement-signals-record.ts
+function lane_calls(issue) {
+  const directories = lane_breakdown_implement.transcript_directories(issue);
+  return lane_transcript_stats.read_calls(directories, { since_ms: 0, until_ms: Date.now() });
+}
+function planned_paths(issue) {
+  const plan = lane_plan.read(issue, process.cwd());
+  return [...plan?.paths ?? [], ...plan?.cleared_paths ?? []];
+}
+var STREAM_IO = {
+  read: run_event_stream_emit.all_events,
+  emit: run_event_stream_emit.emit,
+  calls: lane_calls,
+  planned: planned_paths,
+  root: process.cwd()
+};
+async function record(issue, io = STREAM_IO) {
+  const number = Number(issue);
+  const events = await io.read();
+  if (events.some((event) => lane_implement_signals.is_signals_of(event, number))) return;
+  const signals = lane_implement_signals.counts_of(io.calls(number), io.planned(number), io.root);
+  await io.emit(lane_implement_signals.KIND, lane_implement_signals.text_of(issue, signals));
+}
+var lane_implement_signals_record = { record };
+
+// scripts/run/run-step-progress.ts
+var { STEP } = run_event_step;
+var KIND = run_event_stream.EVENT_KIND;
+var VERDICT_STEPS = {
+  [run_step.UPDATE_DEPS]: STEP.UPDATE_DEPS,
+  [run_step.IMPLEMENT]: STEP.IMPLEMENT,
+  [run_step.HUMAN_REVIEW]: STEP.IMPLEMENT,
+  [run_entry.GATE_VERDICT]: STEP.GATE
+};
+var EVENT_STEPS = {
+  [KIND.REVIEW_ROUND]: STEP.GATE,
+  [KIND.PR_OPENED]: STEP.FOLLOWUP
+};
+function step_of(line, last_event = "") {
+  return VERDICT_STEPS[line] ?? EVENT_STEPS[last_event];
+}
+var STREAM_IO2 = {
+  step: async (issue, step) => {
+    await run_event_step.record(issue, step);
+  },
+  signals: lane_implement_signals_record.record
+};
+async function record2(issue, line, last_event, io = STREAM_IO2) {
+  const step = step_of(line, last_event);
+  if (step === void 0) return;
+  await io.step(issue, step);
+  if (step === STEP.GATE) await io.signals(issue);
+}
+var run_step_progress = { record: record2, step_of };
+
+export {
+  run_entry,
+  run_step_progress
+};