@joshuafolkken/kit 1.3044.0 → 1.3092.0

package/dist/commands/chunk-XPBF5DG3.js

@@ -1,419 +0,0 @@
-import {
-  epic_decision,
-  epic_sections
-} from "./chunk-XSKB6ZUA.js";
-import {
-  epic_validate
-} from "./chunk-OP2RFVLS.js";
-import {
-  epic_fetch
-} from "./chunk-OX3VQLV2.js";
-import {
-  UNORDERED_DEPENDENCIES,
-  chain_links,
-  epic_parse
-} from "./chunk-VDGNXSP3.js";
-import {
-  epic_graph
-} from "./chunk-3RIQ36LH.js";
-import {
-  DEPENDENCY_ARROW,
-  format_dependency_link,
-  format_issue_references,
-  to_issue_reference
-} from "./chunk-2ADQ5XRD.js";
-import {
-  git_gh_command
-} from "./chunk-YGFOGA7C.js";
-import {
-  EPIC_LABEL,
-  has_label_name
-} from "./chunk-QQBMVC5W.js";
-import {
-  session_cite
-} from "./chunk-22DVQCP6.js";
-
-// scripts/epic/epic-read.ts
-var UNKNOWN_REPO = "Could not read this repository from `git remote`, so the epic's relations cannot be keyed by repository \u2014 check `gh auth status` and that this is a checkout with an `origin` remote.";
-async function read_subject(epic_number) {
-  return epic_validate.parse_epic_subject(
-    await git_gh_command.issue_get_labels_and_body(String(epic_number))
-  );
-}
-async function read_recorded(body) {
-  const repo = await git_gh_command.repo_get_name_with_owner();
-  if (repo === void 0) return { error: UNKNOWN_REPO };
-  const tracked = epic_parse.parse_task_list_issue_numbers(body);
-  if (tracked.length === 0) return { children: [], repo };
-  const fetched = await epic_fetch.fetch_children(tracked, repo);
-  if (fetched.unreadable.length > 0) {
-    const list = epic_graph.format_references(fetched.unreadable, repo);
-    return { error: `Could not read ${list}; the epic's dependency graph is incomplete.` };
-  }
-  return { children: fetched.children, repo };
-}
-async function read_epic(epic_number) {
-  const subject = await read_subject(epic_number);
-  const unread = `Could not read issue ${session_cite.issue(epic_number)}.`;
-  if (subject === void 0) return { error: unread };
-  const recorded = await read_recorded(subject.body);
-  if ("error" in recorded) return { error: recorded.error };
-  return { subject, recorded: recorded.children, repo: recorded.repo };
-}
-var epic_read = {
-  read_subject,
-  read_epic
-};
-
-// scripts/epic/epic-chains.ts
-var AMBIGUOUS_MATCH_COUNT = 2;
-function render_chains(chains) {
-  return chains.filter((chain) => chain.length > 1).map((chain) => chain.map((number) => to_issue_reference(number)).join(DEPENDENCY_ARROW));
-}
-function links_of(chains) {
-  const links = chains.flatMap((chain) => chain_links(chain));
-  return [...new Map(links.map((link) => [format_dependency_link(link), link])).values()];
-}
-function diff_links(before, after) {
-  const before_links = links_of(before);
-  const after_links = links_of(after);
-  const before_keys = new Set(before_links.map((link) => format_dependency_link(link)));
-  const after_keys = new Set(after_links.map((link) => format_dependency_link(link)));
-  return {
-    added: after_links.filter((link) => !before_keys.has(format_dependency_link(link))),
-    removed: before_links.filter((link) => !after_keys.has(format_dependency_link(link)))
-  };
-}
-function chains_containing(chains, target) {
-  return chains.map((chain, index) => chain.includes(target) ? index : -1).filter((index) => index !== -1);
-}
-function find_repeated_reference(chains) {
-  for (const chain of chains) {
-    const repeated = chain.find((issue_number, index) => chain.indexOf(issue_number) !== index);
-    if (repeated !== void 0) return repeated;
-  }
-  return void 0;
-}
-function chain_for(additions, position) {
-  return position.kind === "before" ? [...additions, position.target] : [position.target, ...additions];
-}
-function start_chain(additions, position) {
-  return { chains: [chain_for(additions, position)] };
-}
-function add_chain(chains, additions, position) {
-  return { chains: [...chains.map((chain) => [...chain]), chain_for(additions, position)] };
-}
-function not_a_child_error(target) {
-  return {
-    error: `${to_issue_reference(target)} is not a child of this epic, so it cannot position an insertion.`
-  };
-}
-function insert_outside_chains(chains, additions, position, tracked) {
-  if (tracked.includes(position.target)) return add_chain(chains, additions, position);
-  return not_a_child_error(position.target);
-}
-function has_successor(chain, target) {
-  return chain.indexOf(target) < chain.length - 1;
-}
-function is_branching_after(chains, indices, position) {
-  if (position.kind !== "after") return false;
-  return indices.every((index) => has_successor(chains[index] ?? [], position.target));
-}
-function is_shared_before(chains, indices, position) {
-  if (position.kind !== "before") return false;
-  const predecessors = indices.map((index) => {
-    const chain = chains[index] ?? [];
-    return chain[chain.indexOf(position.target) - 1];
-  });
-  return predecessors.every((predecessor) => predecessor === predecessors[0]);
-}
-function is_single_place(chains, indices, position) {
-  return indices.length < AMBIGUOUS_MATCH_COUNT || is_shared_before(chains, indices, position);
-}
-function to_ambiguous_position_error(position) {
-  return `${to_issue_reference(position.target)} appears in more than one declared chain, so "${position.kind}" does not identify one place; edit the declaration by hand.`;
-}
-function find_position_ambiguity(chains, position) {
-  if (position?.kind !== "before" || is_single_place(chains, chains_containing(chains, position.target), position)) {
-    return void 0;
-  }
-  return to_ambiguous_position_error(position);
-}
-function splice_chain(chain, additions, position) {
-  const at = chain.indexOf(position.target) + (position.kind === "after" ? 1 : 0);
-  return [...chain.slice(0, at), ...additions, ...chain.slice(at)];
-}
-function splice_into_chains(chains, indices, additions, position) {
-  return {
-    chains: chains.map(
-      (chain, index) => indices.includes(index) ? splice_chain(chain, additions, position) : [...chain]
-    )
-  };
-}
-function insert_at_position(chains, additions, position, tracked) {
-  const indices = chains_containing(chains, position.target);
-  if (indices.length === 0) return insert_outside_chains(chains, additions, position, tracked);
-  if (is_branching_after(chains, indices, position)) return add_chain(chains, additions, position);
-  if (!is_single_place(chains, indices, position)) {
-    return { error: to_ambiguous_position_error(position) };
-  }
-  return splice_into_chains(chains, indices, additions, position);
-}
-function keep_declaration(chains) {
-  return { chains: chains.map((chain) => [...chain]) };
-}
-function start_chain_or_refuse(additions, position, tracked) {
-  if (!tracked.includes(position.target)) return not_a_child_error(position.target);
-  return start_chain(additions, position);
-}
-function apply_insertion(chains, additions, position, tracked) {
-  if (position === void 0) return keep_declaration(chains);
-  if (chains.length === 0) return start_chain_or_refuse(additions, position, tracked);
-  return insert_at_position(chains, additions, position, tracked);
-}
-function find_already_declared_addition(chains, additions) {
-  const declared = new Set(chains.flat());
-  return additions.find((addition) => declared.has(addition));
-}
-function already_declared_error(issue_number) {
-  const reference = to_issue_reference(issue_number);
-  return `${reference} is already named in the declared dependency order; inserting it again would have it block itself.`;
-}
-function find_insertion_error(chains, additions) {
-  const repeated = find_repeated_reference(chains);
-  if (repeated !== void 0) {
-    return `The declared dependency order names ${to_issue_reference(repeated)} twice; fix the declaration before inserting.`;
-  }
-  const declared = find_already_declared_addition(chains, additions);
-  return declared === void 0 ? void 0 : already_declared_error(declared);
-}
-function remove_children(chains, children) {
-  const dropped = new Set(children);
-  return chains.map((chain) => chain.filter((issue_number) => !dropped.has(issue_number))).filter((chain) => chain.length > 1);
-}
-function break_indices(chain, dropped) {
-  return chain.map((blocked, index) => {
-    const blocker = chain[index - 1];
-    return blocker !== void 0 && dropped.has(format_dependency_link({ blocker, blocked })) ? index : -1;
-  }).filter((index) => index !== -1);
-}
-function split_chain(chain, dropped) {
-  const bounds = [0, ...break_indices(chain, dropped), chain.length];
-  return bounds.slice(0, -1).map((start, index) => chain.slice(start, bounds[index + 1]));
-}
-function remove_links(chains, links) {
-  const dropped = new Set(links.map((link) => format_dependency_link(link)));
-  return chains.flatMap((chain) => split_chain(chain, dropped)).filter((chain) => chain.length > 1);
-}
-function insert_children(chains, additions, position, tracked) {
-  const error = find_insertion_error(chains, additions);
-  if (error !== void 0) return { error };
-  const outcome = apply_insertion(chains, additions, position, tracked);
-  if ("error" in outcome) return outcome;
-  const duplicated = find_repeated_reference(outcome.chains);
-  return duplicated === void 0 ? outcome : { error: already_declared_error(duplicated) };
-}
-var epic_chains = {
-  render_chains,
-  links_of,
-  diff_links,
-  find_position_ambiguity,
-  // Exported so `--order-before` / `--order-after` can pass the
-  // declaration through by the same function `--add` without a position uses. An order-only move is
-  // "leave the declaration exactly as it stood" applied to a call that *does* name a position, so a
-  // second copy of the passthrough would be the clone `CLAUDE.md` prohibits.
-  keep_declaration,
-  remove_children,
-  remove_links,
-  insert_children
-};
-
-// scripts/epic/epic-add-body.ts
-var { find_indices, is_in_range, to_body_lines } = epic_sections;
-function to_task_row(issue_number) {
-  return `- [ ] ${to_issue_reference(issue_number)}`;
-}
-function to_task_rows(placed) {
-  return placed.map((issue_number) => to_task_row(issue_number));
-}
-function append_task_rows(input, placed) {
-  const rows = find_indices(input, (line) => epic_parse.is_task_list_line(line));
-  const last = rows.at(-1);
-  if (last === void 0) return [...input.lines];
-  return [
-    ...input.lines.slice(0, last + 1),
-    ...to_task_rows(placed),
-    ...input.lines.slice(last + 1)
-  ];
-}
-function to_row_number(line) {
-  const [issue_number] = epic_parse.parse_task_list_issue_numbers(line);
-  return issue_number;
-}
-function is_placed_row(line, placed) {
-  const issue_number = to_row_number(line);
-  return issue_number !== void 0 && placed.has(issue_number);
-}
-function insert_task_rows(input, placed, position) {
-  const moved = new Set(placed);
-  const dropped = new Set(find_indices(input, (line) => is_placed_row(line, moved)));
-  const kept = input.lines.filter((_line, index) => !dropped.has(index));
-  const [at] = find_indices(to_body_lines(kept), (line) => to_row_number(line) === position.target);
-  if (at === void 0) return [...input.lines];
-  const insert_at = position.kind === "before" ? at : at + 1;
-  return [...kept.slice(0, insert_at), ...to_task_rows(placed), ...kept.slice(insert_at)];
-}
-function to_placed_lines(input) {
-  const lines = to_body_lines(input.body);
-  const { position } = input;
-  if (position === void 0) return append_task_rows(lines, input.placed);
-  return insert_task_rows(lines, input.placed, position);
-}
-var DEPENDENCIES_HEADING = /^#{1,6}[ \t]+Dependencies\b/u;
-function find_dependencies_range(input) {
-  return epic_sections.find_section_range(input, DEPENDENCIES_HEADING);
-}
-function splice_declaration(lines, input) {
-  return lines.flatMap((line, index) => {
-    if (index === input.first) return [...input.rendered];
-    if (input.dropped.has(index)) return [];
-    return [line];
-  });
-}
-function replace_declaration(lines, rendered) {
-  const input = to_body_lines(lines);
-  const range = find_dependencies_range(input);
-  if (range === void 0) return void 0;
-  const found = find_indices(input, (line) => epic_parse.is_declaration_line(line));
-  const declarations = found.filter((index) => is_in_range(index, range));
-  const [first] = declarations;
-  return first === void 0 ? [...lines.slice(0, range.end), ...rendered, ...lines.slice(range.end)] : splice_declaration(lines, { first, dropped: new Set(declarations.slice(1)), rendered });
-}
-function to_safe_declaration(line) {
-  const [rendered] = epic_chains.render_chains(epic_parse.parse_dependency_chains(line));
-  return rendered ?? UNORDERED_DEPENDENCIES;
-}
-function find_stray_declaration(lines) {
-  const input = to_body_lines(lines);
-  const range = find_dependencies_range(input);
-  if (range === void 0) return void 0;
-  const stray = find_indices(input, (line) => epic_parse.is_declaration_line(line)).find(
-    (index) => !is_in_range(index, range)
-  );
-  return stray === void 0 ? void 0 : to_safe_declaration(lines[stray] ?? "");
-}
-function to_written_lines(input) {
-  const with_rows = to_placed_lines(input);
-  const { decision } = input;
-  if (decision === void 0) return with_rows;
-  return epic_decision.append_decision(with_rows.join("\n"), decision).split("\n");
-}
-function is_declaration_unchanged(lines, rendered) {
-  const declared = epic_parse.parse_dependency_chains(lines.join("\n"));
-  return epic_chains.render_chains(declared).join("\n") === rendered.join("\n");
-}
-function to_declared_body(with_rows, rendered) {
-  const stray = find_stray_declaration(with_rows);
-  if (stray !== void 0) {
-    return {
-      error: `The body declares \`${stray}\` outside the \`Dependencies\` section, which no insertion can keep consistent; move it into that section or reword it first.`
-    };
-  }
-  if (is_declaration_unchanged(with_rows, rendered)) return { body: with_rows.join("\n") };
-  const replaced = replace_declaration(with_rows, rendered);
-  return replaced === void 0 ? { error: "Could not locate the `Dependencies` section to rewrite; nothing was written." } : { body: replaced.join("\n") };
-}
-function to_rendered_declaration(input) {
-  const rendered = epic_chains.render_chains(input.chains_after);
-  if (rendered.length > 0) return rendered;
-  return input.does_clear_declaration === true ? [UNORDERED_DEPENDENCIES] : [];
-}
-function build_body(input) {
-  const with_rows = to_written_lines(input);
-  const rendered = to_rendered_declaration(input);
-  if (rendered.length === 0) return { body: with_rows.join("\n") };
-  return to_declared_body(with_rows, rendered);
-}
-function to_link_keys(chains) {
-  return epic_chains.links_of(chains).map((link) => format_dependency_link(link)).toSorted((left, right) => left.localeCompare(right));
-}
-function has_intended_links(body, chains_after) {
-  const written = to_link_keys(epic_parse.parse_dependency_chains(body));
-  const intended = to_link_keys(chains_after);
-  return written.length === intended.length && written.every((key, index) => key === intended[index]);
-}
-function missing_rows(body, expected) {
-  const tracked = epic_parse.parse_task_list_issue_numbers(body);
-  return expected.filter((issue_number) => !tracked.includes(issue_number));
-}
-function to_placement_start(position, target, count) {
-  return position.kind === "before" ? target - count : target + 1;
-}
-function has_intended_rows(body, input) {
-  const { position, placed } = input;
-  if (position === void 0 || placed.length === 0) return true;
-  const tracked = epic_parse.parse_task_list_issue_numbers(body);
-  const target = tracked.indexOf(position.target);
-  if (target === -1) return false;
-  const start = to_placement_start(position, target, placed.length);
-  return placed.every((child, offset) => tracked[start + offset] === child);
-}
-function find_rewrite_error(body, input) {
-  const missing = missing_rows(body, input.placed);
-  if (missing.length > 0) {
-    return `The rewritten body would not track ${format_issue_references(missing)} as a task-list row.`;
-  }
-  if (!epic_parse.has_machine_readable_declaration(body)) {
-    return "The rewritten body would carry no unambiguous machine-readable `Dependencies` declaration.";
-  }
-  if (!has_intended_links(body, input.chains_after)) {
-    return "The rewritten body would declare a different dependency order than the one computed; nothing was written.";
-  }
-  if (!has_intended_rows(body, input)) {
-    return "The rewritten body would not put the placed task-list rows where the position asked; nothing was written.";
-  }
-  return void 0;
-}
-function rewrite_body(input) {
-  const built = build_body(input);
-  if ("error" in built) return built;
-  const error = find_rewrite_error(built.body, input);
-  return error === void 0 ? built : { error };
-}
-var epic_add_body = {
-  rewrite_body
-};
-
-// scripts/epic/epic-shape.ts
-function missing_declaration_error(epic_number) {
-  const check = `josh epic:check ${String(epic_number)}`;
-  return `${to_issue_reference(epic_number)} has no unambiguous machine-readable \`Dependencies\` declaration; run \`${check}\` first.`;
-}
-function promote_remedy(epic_number) {
-  const promote = `josh epic --promote ${String(epic_number)} <N...>`;
-  return `Promote it with \`${promote}\` when it is a request, a discussion or a container; create a new epic over both when it is itself one of the deliverables.`;
-}
-function find_epic_shape_error(subject) {
-  if (has_label_name(subject.labels, EPIC_LABEL)) return void 0;
-  return `${to_issue_reference(subject.epic_number)} does not carry the \`${EPIC_LABEL}\` label, so it is not an epic. ${promote_remedy(subject.epic_number)}`;
-}
-function find_subject_error(subject, tracked) {
-  const reference = to_issue_reference(subject.epic_number);
-  if (subject.body === void 0) return `Could not read the body of ${reference}.`;
-  const shape_error = find_epic_shape_error(subject);
-  if (shape_error !== void 0) return shape_error;
-  if (tracked.length === 0) {
-    return `${reference} tracks no child as a \`- [ ] #N\` row; there is nowhere to add one.`;
-  }
-  return epic_parse.has_machine_readable_declaration(subject.body) ? void 0 : missing_declaration_error(subject.epic_number);
-}
-var epic_shape = {
-  find_subject_error
-};
-
-export {
-  epic_chains,
-  epic_add_body,
-  epic_shape,
-  epic_read
-};

package/dist/commands/chunk-XUMYPESL.js

@@ -1,160 +0,0 @@
-import {
-  test_related_pins
-} from "./chunk-HE5S4XRE.js";
-import {
-  direct_importers
-} from "./chunk-LAR76BFA.js";
-import {
-  related_scope
-} from "./chunk-CFHRNTE5.js";
-import {
-  run_ship_lap
-} from "./chunk-PE7B7242.js";
-import {
-  tree_verdict
-} from "./chunk-NOLFSPOB.js";
-import {
-  scoped_green
-} from "./chunk-WTH6NTXU.js";
-import {
-  test_unit_guard
-} from "./chunk-J6WKZRV2.js";
-import {
-  verification_tail
-} from "./chunk-FGL6DBZU.js";
-import {
-  review_stamps
-} from "./chunk-MVHPRYHE.js";
-import {
-  gate_tree
-} from "./chunk-NFPD2P3V.js";
-import {
-  input_fingerprint
-} from "./chunk-MGF64OHV.js";
-
-// scripts/test/test-related-touched.ts
-import { readdirSync } from "node:fs";
-import path from "node:path";
-var TOUCHED_FLAG = "--touched";
-var TOUCHED_KIND = "touched";
-var TEST_SUFFIX = ".test.ts";
-var TOUCHED_REASON = "the diff test files, their modules' same-named tests, direct test importers and pinned tests";
-var NOTHING_TOUCHED_REASON = "no changed file reaches a touched test";
-function list_directory(directory) {
-  try {
-    return readdirSync(directory);
-  } catch {
-    return [];
-  }
-}
-function is_named_after(module_file, name) {
-  const stem = path.basename(module_file, path.extname(module_file));
-  return name.startsWith(`${stem}.`) && name.endsWith(TEST_SUFFIX);
-}
-function tests_of(root, file, list) {
-  const directory = path.dirname(file);
-  const names = list(path.join(root, directory));
-  if (file.endsWith(TEST_SUFFIX)) return names.includes(path.basename(file)) ? [file] : [];
-  if (!related_scope.is_relatable(file)) return [];
-  return names.filter((name) => is_named_after(file, name)).map((name) => path.join(directory, name));
-}
-function touched_tests(root, changed, list = list_directory) {
-  const tests = changed.flatMap((file) => tests_of(root, file, list));
-  return [.../* @__PURE__ */ new Set([...tests, ...test_related_pins.pinned_tests(changed)])];
-}
-function touched_scope(root, changed, list = list_directory) {
-  const { UNREADABLE_REASON } = related_scope;
-  if (changed === void 0) return { mode: "all", files: [], reason: UNREADABLE_REASON };
-  const files = touched_tests(root, changed, list).map((file) => path.join(root, file));
-  if (files.length === 0) return { mode: "none", files: [], reason: NOTHING_TOUCHED_REASON };
-  return { mode: "related", files, reason: TOUCHED_REASON };
-}
-async function read_scope(root, changed) {
-  if (changed === void 0) return touched_scope(root, changed);
-  const importers = await direct_importers.importers_of(
-    root,
-    changed.filter((file) => related_scope.is_relatable(file))
-  );
-  return touched_scope(root, [...changed, ...[...importers.values()].flat()]);
-}
-var test_related_touched = {
-  NOTHING_TOUCHED_REASON,
-  TOUCHED_FLAG,
-  TOUCHED_KIND,
-  TOUCHED_REASON,
-  read_scope,
-  touched_scope,
-  touched_tests
-};
-
-// scripts/test/test-related-verdict.ts
-function touched_target() {
-  return tree_verdict.record_path("test-related-touched-review");
-}
-async function record_touched(given, before, exit_code) {
-  if (given.length !== 1 || given[0] !== test_related_touched.TOUCHED_FLAG) return;
-  await scoped_green.record_if_green(review_stamps.test_related_stamp, {
-    before,
-    exit_code,
-    target: touched_target()
-  });
-}
-function target_of(given) {
-  const arguments_hash = input_fingerprint.of_entries([JSON.stringify([process.cwd(), given])]);
-  return tree_verdict.record_path(`test-related-${arguments_hash}`);
-}
-async function fresh_verdict(before, target, fresh) {
-  const exit_code = await fresh(before);
-  const tail = `${verification_tail.format_verdict("josh test:related", [])}
-`;
-  if (exit_code === 0) {
-    await tree_verdict.record({ before, exit_code, tail }, gate_tree.read_gate_tree, target);
-  }
-  return { exit_code, is_reused: false };
-}
-function preserved_blobs(before) {
-  if (before === void 0) return void 0;
-  const stamp = review_stamps.test_related_stamp.read();
-  if (stamp === void 0 || !scoped_green.is_unmoved(before, { files: stamp.files, base: stamp.base }) || !review_stamps.test_related_stamp.describes_inputs(stamp)) {
-    return void 0;
-  }
-  return stamp.blobs;
-}
-async function reused_verdict(given, before, target, kept) {
-  if (given.length === 0) {
-    const blobs = preserved_blobs(before);
-    await scoped_green.record_if_green(review_stamps.test_related_stamp, {
-      before,
-      exit_code: 0,
-      ...blobs !== void 0 && { blobs }
-    });
-  }
-  await record_touched(given, before, 0);
-  return { exit_code: tree_verdict.replay(kept, target), is_reused: true };
-}
-async function checked(given, fresh) {
-  const before = await scoped_green.read_before([]);
-  const target = target_of(given);
-  const kept = tree_verdict.read(before, target);
-  if (kept?.exit_code === 0) return await reused_verdict(given, before, target, kept);
-  const result = await fresh_verdict(before, target, fresh);
-  await record_touched(given, before, result.exit_code);
-  return result;
-}
-async function run(given, fresh) {
-  if (!test_unit_guard.is_running(process.cwd())) return await fresh(void 0);
-  const outcome = await run_ship_lap.timed(
-    "test:related",
-    async () => await checked(given, fresh),
-    {
-      note_of: (result) => ({ is_reused: result.is_reused })
-    }
-  );
-  return outcome.exit_code;
-}
-var test_related_verdict = { run, touched_target };
-
-export {
-  test_related_touched,
-  test_related_verdict
-};