@joshuafolkken/kit 1.3101.0 → 1.3125.0

package/dist/commands/chunk-XMNPU3J5.js

@@ -0,0 +1,469 @@
+import {
+  epic_add_body,
+  epic_chains,
+  epic_read,
+  epic_shape
+} from "./chunk-MIZLGSHI.js";
+import {
+  epic_decision
+} from "./chunk-XSKB6ZUA.js";
+import {
+  epic_relations
+} from "./chunk-BAJABWKW.js";
+import {
+  backlog_ready
+} from "./chunk-OJO5AADO.js";
+import {
+  epic_issue
+} from "./chunk-GXXWRH6F.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-VJNE7W7O.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-XMZJB7JP.js

@@ -0,0 +1,100 @@
+import {
+  has_stderr_field
+} from "./chunk-NAZ753DE.js";
+import {
+  error_text
+} from "./chunk-CDY4NFQG.js";
+
+// scripts/git/git-error.ts
+function get_stderr_from_error(cause) {
+  if (!has_stderr_field(cause)) return void 0;
+  const stderr = cause.stderr.trim();
+  return stderr.length > 0 ? stderr : void 0;
+}
+function get_error_message_from_cause(cause) {
+  const message = cause.message.trim();
+  if (message.length > 0) return message;
+  return get_stderr_from_error(cause);
+}
+function get_cause_message(cause) {
+  if (cause instanceof Error) return get_error_message_from_cause(cause);
+  if (typeof cause === "string") return cause.trim();
+  return void 0;
+}
+var FAILURE_PREFIX = "\u274C Error:";
+var DETAILS_PREFIX = "\u{1F4A1} Details:";
+function display_error_details(cause) {
+  const cause_message = get_cause_message(cause);
+  if (cause_message === void 0 || cause_message.length === 0) return;
+  console.error("");
+  console.error(DETAILS_PREFIX, cause_message);
+}
+var FAILURE_EXIT_CODE = 1;
+var OPERATION_CANCELLED_MESSAGE = "\u{1F4A1} Operation cancelled.";
+var BranchMismatchError = class extends Error {
+  current_branch;
+  target_branch_name;
+  constructor(mismatch, options) {
+    super(
+      `Branch mismatch: on ${mismatch.current_branch}, expected ${mismatch.target_branch_name}`,
+      options
+    );
+    this.name = "BranchMismatchError";
+    this.current_branch = mismatch.current_branch;
+    this.target_branch_name = mismatch.target_branch_name;
+  }
+};
+var OperationCancelledError = class extends Error {
+  constructor() {
+    super("Operation cancelled");
+    this.name = "OperationCancelledError";
+  }
+};
+function display_failure(error) {
+  const error_message = error_text.message_of(error);
+  console.error("");
+  console.error(FAILURE_PREFIX, error_message);
+  if (error instanceof Error && error.cause !== void 0) {
+    display_error_details(error.cause);
+  }
+  console.error("");
+}
+function display_branch_mismatch(error) {
+  console.error("");
+  console.error("\u274C Branch mismatch detected");
+  console.error("");
+  console.error(`Current branch: ${error.current_branch}`);
+  console.error(`Expected branch: ${error.target_branch_name}`);
+  console.error("");
+  console.error("\u{1F4A1} Please update main branch to the latest and try again.");
+}
+function display_cancelled() {
+  console.info(OPERATION_CANCELLED_MESSAGE);
+  console.info("");
+}
+function display(error) {
+  if (error instanceof BranchMismatchError) {
+    display_branch_mismatch(error);
+    return;
+  }
+  if (error instanceof OperationCancelledError) {
+    display_cancelled();
+    return;
+  }
+  display_failure(error);
+}
+function handle(error) {
+  display(error);
+  process.exitCode = FAILURE_EXIT_CODE;
+}
+var git_error = {
+  DETAILS_PREFIX,
+  FAILURE_PREFIX,
+  handle
+};
+
+export {
+  BranchMismatchError,
+  OperationCancelledError,
+  git_error
+};