@joshuafolkken/kit 1.3101.0 → 1.3125.0

package/dist/commands/chunk-WORHUJ6T.js

@@ -1,73 +0,0 @@
-import {
-  git_gh_command
-} from "./chunk-NRULNBYI.js";
-import {
-  removed_tests,
-  test_titles
-} from "./chunk-U7Y6RKLK.js";
-import {
-  review_code_tree
-} from "./chunk-FDASVHZD.js";
-import {
-  test_declared_logic
-} from "./chunk-7HCPRVMB.js";
-import {
-  changed_paths
-} from "./chunk-U5EO4QEV.js";
-import {
-  change_base
-} from "./chunk-LBVYFW3I.js";
-import {
-  git_command
-} from "./chunk-IXZZSST7.js";
-
-// scripts/review/removed-tests-check.ts
-import { existsSync, readFileSync } from "node:fs";
-import path from "node:path";
-var UNREADABLE_MESSAGE = "Merge refused: the change base could not be resolved, so the tests this change removes could not be listed; re-run once `git merge-base` answers.";
-function titles_in(api, texts) {
-  return texts.flatMap((text) => test_titles.titles_of(api, text));
-}
-async function base_texts(base, paths) {
-  const held = await changed_paths.read_held_at(base, paths);
-  return await Promise.all(
-    held.map(async (relative) => await git_command.show_file(`${base}:${relative}`))
-  );
-}
-function tree_texts(root, paths) {
-  return paths.map((relative) => path.join(root, relative)).filter((absolute) => existsSync(absolute)).map((absolute) => readFileSync(absolute, "utf8"));
-}
-function added_titles(before, after) {
-  const held = new Set(before);
-  return after.filter((title) => !held.has(title));
-}
-async function changes() {
-  const base = await change_base.resolved_through_merge();
-  if (base === void 0) return void 0;
-  const root = await git_command.repository_root();
-  const api = review_code_tree.load_typescript(root);
-  if (api === void 0) return { removed: [], added: [] };
-  const changed = await changed_paths.read_changed_since(base);
-  const paths = changed.filter((relative) => test_declared_logic.is_test_file(relative));
-  const before = titles_in(api, await base_texts(base, paths));
-  const after = titles_in(api, tree_texts(root, paths));
-  return { removed: removed_tests.removed(before, after), added: added_titles(before, after) };
-}
-async function read() {
-  const found = await changes();
-  return found?.removed;
-}
-async function body_refusal(pr_body) {
-  const removed = await read();
-  if (removed === void 0) return UNREADABLE_MESSAGE;
-  const left = removed_tests.undisposed(removed, pr_body);
-  return left.length === 0 ? void 0 : removed_tests.refusal_message(left);
-}
-async function refusal(branch_name) {
-  return await body_refusal(await git_gh_command.pr_get_body(branch_name));
-}
-var removed_tests_check = { body_refusal, changes, read, refusal, UNREADABLE_MESSAGE };
-
-export {
-  removed_tests_check
-};

package/dist/commands/chunk-WR5PKCQW.js

@@ -1,61 +0,0 @@
-import {
-  run_preflight
-} from "./chunk-GAVSK6P6.js";
-import {
-  session_cite
-} from "./chunk-22DVQCP6.js";
-
-// scripts/git/stash/stash-orphans.ts
-var HASH_PATTERN = /#(?<issue>\d+)\b/u;
-var LEADING_PATTERN = /(?:^|: )(?<issue>\d+): /u;
-var MESSAGE_PATTERNS = [HASH_PATTERN, LEADING_PATTERN];
-var ALL_ISSUE_PATTERN = new RegExp(HASH_PATTERN.source, "gu");
-var BRANCH_PATTERN = /^(?:WIP on|On) (?<issue>\d+)-lane: /u;
-var WIP_PREFIX = "WIP on ";
-var NO_PATTERNS = [];
-var HEADER = "Stashes whose issue is closed, or whose owner cannot be read \u2014 decide for each whether to revive or discard it (none is dropped automatically):";
-var FOOTER = 'Revive: `pnpm josh stash:pop "<message>"` \xB7 Discard: `git stash drop <selector>` \u2014 re-read the selector first, the stack is shared by every lane.';
-var UNKNOWN_OWNER = "owner unknown";
-var COLUMN_SEPARATOR = "  ";
-var LINE_SEPARATOR = "\n";
-function patterns_for(subject) {
-  if (subject.includes(run_preflight.STASH_LABEL_PREFIX)) return NO_PATTERNS;
-  return subject.startsWith(WIP_PREFIX) ? [BRANCH_PATTERN] : [...MESSAGE_PATTERNS, BRANCH_PATTERN];
-}
-function issue_of(subject) {
-  for (const pattern of patterns_for(subject)) {
-    const issue = pattern.exec(subject)?.groups?.["issue"];
-    if (issue !== void 0) return issue;
-  }
-  return void 0;
-}
-function issues_of(entries) {
-  const issues = entries.map((entry) => issue_of(entry.subject));
-  return [...new Set(issues.filter((issue) => issue !== void 0))];
-}
-function message_issues(subject) {
-  const hashed = [...subject.matchAll(ALL_ISSUE_PATTERN)].map((match) => match.groups?.["issue"]);
-  return [...hashed, LEADING_PATTERN.exec(subject)?.groups?.["issue"]];
-}
-function issues_named(subject) {
-  const branch = BRANCH_PATTERN.exec(subject)?.groups?.["issue"];
-  const named = subject.startsWith(WIP_PREFIX) ? [] : message_issues(subject);
-  const found = [...named, branch].filter((issue) => issue !== void 0);
-  return [...new Set(found)];
-}
-function orphans(entries, closed) {
-  return entries.map((entry) => ({ ...entry, issue: issue_of(entry.subject) })).filter((entry) => entry.issue === void 0 || closed.has(entry.issue));
-}
-function format_line(orphan) {
-  const owner = orphan.issue === void 0 ? UNKNOWN_OWNER : `${session_cite.issue(orphan.issue)} closed`;
-  return `  ${[orphan.selector, owner, orphan.subject].join(COLUMN_SEPARATOR)}`;
-}
-function format_report(found) {
-  if (found.length === 0) return void 0;
-  return [HEADER, ...found.map((orphan) => format_line(orphan)), FOOTER].join(LINE_SEPARATOR);
-}
-var stash_orphans = { format_report, issue_of, issues_named, issues_of, orphans };
-
-export {
-  stash_orphans
-};

package/dist/commands/chunk-WR73HTRG.js

@@ -1,121 +0,0 @@
-import {
-  lane_seed_policy
-} from "./chunk-6NGNMIMT.js";
-import {
-  run_event_stream_emit
-} from "./chunk-26JL4UU4.js";
-import {
-  run_event_stream
-} from "./chunk-KGSEWOKI.js";
-import {
-  run_carry
-} from "./chunk-DS53UUDH.js";
-import {
-  cli_flags
-} from "./chunk-2FE3C4PH.js";
-import {
-  stamp_file
-} from "./chunk-VLN6TSPJ.js";
-
-// scripts/lane/lane-limit-override.ts
-var STREAM_START = 0;
-async function carry_target() {
-  const repository = await run_carry.repository_directory();
-  return repository === void 0 ? void 0 : run_carry.carry_path(repository);
-}
-function live_carry(target) {
-  const read = run_carry.read_carry(target);
-  return read.kind === "carried" ? read.carry : void 0;
-}
-async function current_carry() {
-  const target = await carry_target();
-  return target === void 0 ? void 0 : live_carry(target);
-}
-async function read_override() {
-  const carry = await current_carry();
-  return carry?.lane_limit;
-}
-function is_run_live(carry) {
-  return carry.is_handed_off === true || run_carry.is_owner_live(carry);
-}
-async function read_carried() {
-  const carry = await current_carry();
-  if (carry?.lane_limit !== void 0) return carry.lane_limit;
-  return carry !== void 0 && is_run_live(carry) ? carry.launch_limit : void 0;
-}
-async function update_carry(fields) {
-  const target = await carry_target();
-  const carry = target === void 0 ? void 0 : live_carry(target);
-  if (target === void 0 || carry === void 0) return false;
-  stamp_file.write_stamp(target, { ...carry, ...fields });
-  return true;
-}
-async function write_override(limit) {
-  return await update_carry({ lane_limit: limit });
-}
-async function write_launch(limit) {
-  return await update_carry({ launch_limit: limit });
-}
-async function emit_raise(text) {
-  await run_event_stream_emit.emit(run_event_stream.EVENT_KIND.LANE_LIMIT, text);
-}
-function never_raised() {
-  return false;
-}
-async function watch_raise() {
-  const target = await run_event_stream_emit.stream_target();
-  if (target === void 0) return never_raised;
-  const start = run_event_stream.read_from(target, STREAM_START).next_position;
-  return function is_raised() {
-    const { events } = run_event_stream.read_from(target, start);
-    return events.some((event) => event.kind === run_event_stream.EVENT_KIND.LANE_LIMIT);
-  };
-}
-var lane_limit_override = {
-  emit_raise,
-  read_carried,
-  read_override,
-  watch_raise,
-  write_launch,
-  write_override
-};
-
-// scripts/lane/lane-capacity.ts
-var DEFAULT_LANE_LIMIT = 4;
-var LANE_LIMIT_KEY = "JOSH_LANE_LIMIT";
-var NO_LANES = 0;
-function read_limit(raw, name) {
-  return cli_flags.read_positive_setting(raw, name, DEFAULT_LANE_LIMIT);
-}
-function environment_limit(environment = process.env) {
-  return read_limit(environment[LANE_LIMIT_KEY], LANE_LIMIT_KEY);
-}
-async function lane_limit(environment = process.env, read_carried2 = lane_limit_override.read_carried) {
-  const carried = await read_carried2();
-  if (carried !== void 0) return { kind: "limit", limit: carried };
-  return environment_limit(environment);
-}
-function seated_limit(limit) {
-  return Math.min(limit, lane_seed_policy.LAST_LANE_SEAT);
-}
-function limit_room(limit, occupied) {
-  return Math.max(NO_LANES, seated_limit(limit) - occupied);
-}
-function free_lanes(limit, occupied, seated = occupied) {
-  const by_seats = lane_seed_policy.LAST_LANE_SEAT - seated;
-  return Math.max(NO_LANES, Math.min(limit_room(limit, occupied), by_seats));
-}
-var lane_capacity = {
-  LANE_LIMIT_KEY,
-  environment_limit,
-  free_lanes,
-  lane_limit,
-  limit_room,
-  read_limit,
-  seated_limit
-};
-
-export {
-  lane_limit_override,
-  lane_capacity
-};

package/dist/commands/chunk-WRNMUQTD.js

@@ -1,95 +0,0 @@
-import {
-  stash_args
-} from "./chunk-R7IT5VOL.js";
-import {
-  git_stash
-} from "./chunk-WROJTXWZ.js";
-import {
-  error_text
-} from "./chunk-CDY4NFQG.js";
-
-// scripts/git/stash/stash-pop-cli.ts
-var COMMAND = "stash:pop";
-var POPPED_VERDICT = "popped";
-var CONFLICTED_VERDICT = "conflicted";
-var NO_MATCH_VERDICT = "no-match";
-var AMBIGUOUS_VERDICT = "ambiguous";
-var SUCCESS_EXIT_CODE = 0;
-var FAILURE_EXIT_CODE = 1;
-function report(verdict, detail, code) {
-  console.info(verdict);
-  console.error(detail);
-  return code;
-}
-function refuse() {
-  console.error(stash_args.usage(COMMAND));
-  return FAILURE_EXIT_CODE;
-}
-async function pop_selected(selector, directory) {
-  try {
-    await git_stash.pop(selector, directory);
-  } catch (error) {
-    if (await git_stash.has_conflict(directory)) {
-      const detail = `Popped ${selector} with conflicts \u2014 resolve them.`;
-      return report(CONFLICTED_VERDICT, detail, SUCCESS_EXIT_CODE);
-    }
-    throw error;
-  }
-  return report(POPPED_VERDICT, `Popped ${selector}.`, SUCCESS_EXIT_CODE);
-}
-var HASH_ARGUMENT = /^[\da-f]{7,40}$/u;
-async function ambiguous(request) {
-  const entries = await git_stash.list_by_hash(request.dir);
-  const hashes = entries.filter((entry) => git_stash.matches(entry.subject, request.message));
-  const named = hashes.map((entry) => entry.selector).join(", ");
-  const detail = `More than one stash matches "${request.message}" \u2014 pop one by its hash: ${named}.`;
-  return report(AMBIGUOUS_VERDICT, detail, FAILURE_EXIT_CODE);
-}
-async function position_of_hash(hash, directory) {
-  const entries = await git_stash.list_by_hash(directory);
-  const [only, ...rest] = entries.filter((entry) => entry.selector.startsWith(hash));
-  if (only === void 0 || rest.length > 0) return void 0;
-  return await git_stash.position_of(only.selector, directory);
-}
-async function pop_hash(hash, directory) {
-  const position = await position_of_hash(hash, directory);
-  if (position === void 0) {
-    return report(NO_MATCH_VERDICT, `No single stash has the hash ${hash}.`, FAILURE_EXIT_CODE);
-  }
-  return await pop_selected(position, directory);
-}
-async function answer(request) {
-  if (HASH_ARGUMENT.test(request.message)) return await pop_hash(request.message, request.dir);
-  const selection = git_stash.select(await git_stash.list(request.dir), request.message);
-  if (selection.kind === "none") {
-    return report(NO_MATCH_VERDICT, `No stash matches "${request.message}".`, FAILURE_EXIT_CODE);
-  }
-  if (selection.kind === "ambiguous") return await ambiguous(request);
-  return await pop_selected(selection.selector, request.dir);
-}
-function report_unknown(error) {
-  console.error(error_text.message_of(error));
-  return FAILURE_EXIT_CODE;
-}
-async function run(argv) {
-  const parsed = stash_args.read_arguments(argv);
-  if (parsed === void 0) return refuse();
-  const request = stash_args.to_request(parsed);
-  if (request === void 0) return refuse();
-  try {
-    return await answer(request);
-  } catch (error) {
-    return report_unknown(error);
-  }
-}
-var stash_pop_cli = {
-  AMBIGUOUS_VERDICT,
-  CONFLICTED_VERDICT,
-  NO_MATCH_VERDICT,
-  POPPED_VERDICT,
-  run
-};
-
-export {
-  stash_pop_cli
-};

package/dist/commands/chunk-WROJTXWZ.js

@@ -1,138 +0,0 @@
-import {
-  LEDGER_EXCLUSION_PATHSPEC
-} from "./chunk-SV4FZR24.js";
-import {
-  git_spawn
-} from "./chunk-B5HP6T4L.js";
-
-// scripts/git/stash/git-stash.ts
-var ENTRY_SEPARATOR = "\n";
-var FIELD_SEPARATOR = "\0";
-var LIST_FORMAT = "--format=%gd%x00%gs";
-var SUBJECT_MESSAGE_SEPARATOR = ": ";
-var HASH_FORMAT = "--format=%H%x00%gs";
-var HASH_POSITION_FORMAT = "--format=%H%x00%gd";
-var NAME_ONLY_FLAG = "--name-only";
-var ADDED_PREFIX = "+";
-var FILE_HEADER_PREFIX = "+++";
-function to_entry(line) {
-  const [selector, subject] = line.split(FIELD_SEPARATOR);
-  if (selector === void 0 || subject === void 0) return void 0;
-  return { selector, subject };
-}
-function parse_entries(raw) {
-  if (raw === "") return [];
-  return raw.split(ENTRY_SEPARATOR).map((line) => to_entry(line)).filter((entry) => entry !== void 0);
-}
-function matches(subject, message) {
-  return subject === message || subject.endsWith(`${SUBJECT_MESSAGE_SEPARATOR}${message}`);
-}
-function select(entries, message) {
-  const found = entries.filter((entry) => matches(entry.subject, message));
-  const [first] = found;
-  if (first === void 0) return { kind: "none" };
-  if (found.length > 1) {
-    return { kind: "ambiguous", selectors: found.map((entry) => entry.selector) };
-  }
-  return { kind: "match", selector: first.selector };
-}
-function git_args(directory, args) {
-  return directory === void 0 ? args : ["-C", directory, ...args];
-}
-async function list(directory) {
-  return parse_entries(await git_spawn.read(git_args(directory, ["stash", "list", LIST_FORMAT])));
-}
-async function pop(selector, directory) {
-  await git_spawn.read(git_args(directory, ["stash", "pop", selector]));
-}
-async function unmerged_paths(directory) {
-  const unmerged = await git_spawn.read(
-    git_args(directory, ["diff", NAME_ONLY_FLAG, "--diff-filter=U"])
-  );
-  return unmerged.split("\n").filter((line) => line !== "");
-}
-async function has_conflict(directory) {
-  const unmerged = await unmerged_paths(directory);
-  return unmerged.length > 0;
-}
-async function status_of(directory, pathspec = []) {
-  return await git_spawn.read(git_args(directory, ["status", "--porcelain", ...pathspec]));
-}
-async function has_changes(directory, pathspec = []) {
-  const status = await status_of(directory, pathspec);
-  return status !== "";
-}
-var DELETION_STATUS = " D ";
-function holds_work(status) {
-  return status.split(ENTRY_SEPARATOR).some((line) => line !== "" && !line.startsWith(DELETION_STATUS));
-}
-async function has_work(directory) {
-  return holds_work(await status_of(directory));
-}
-var STASHABLE_PATHSPEC = ["--", ...LEDGER_EXCLUSION_PATHSPEC];
-async function has_stashable_changes(directory) {
-  return await has_changes(directory, STASHABLE_PATHSPEC);
-}
-async function push(message, directory, pathspec = []) {
-  await git_spawn.read(git_args(directory, ["stash", "push", "-u", "-m", message, ...pathspec]));
-}
-async function list_by_hash(directory) {
-  return parse_entries(await git_spawn.read(git_args(directory, ["stash", "list", HASH_FORMAT])));
-}
-async function changed_paths(hash, directory) {
-  const raw = await git_spawn.read(
-    git_args(directory, ["stash", "show", "--include-untracked", NAME_ONLY_FLAG, hash])
-  );
-  return raw === "" ? [] : raw.split(ENTRY_SEPARATOR);
-}
-async function untracked_lines(hash, file, directory) {
-  try {
-    const raw = await git_spawn.read(git_args(directory, ["show", `${hash}^3:${file}`]));
-    return raw === "" ? [] : raw.split(ENTRY_SEPARATOR);
-  } catch {
-    return [];
-  }
-}
-async function added_lines(hash, file, directory) {
-  const diff = await git_spawn.read(git_args(directory, ["diff", `${hash}^1`, hash, "--", file]));
-  if (diff === "") return await untracked_lines(hash, file, directory);
-  return diff.split(ENTRY_SEPARATOR).filter((line) => line.startsWith(ADDED_PREFIX) && !line.startsWith(FILE_HEADER_PREFIX)).map((line) => line.slice(ADDED_PREFIX.length));
-}
-async function position_of(hash, directory) {
-  const raw = await git_spawn.read(git_args(directory, ["stash", "list", HASH_POSITION_FORMAT]));
-  return parse_entries(raw).find((candidate) => candidate.selector === hash)?.subject;
-}
-async function drop_by_hash(hash, directory) {
-  const position = await position_of(hash, directory);
-  if (position === void 0) return false;
-  await git_spawn.read(git_args(directory, ["stash", "drop", position]));
-  return true;
-}
-function work_message(issue, occasion) {
-  return `${issue}: uncommitted work at ${occasion}`;
-}
-var git_stash = {
-  added_lines,
-  changed_paths,
-  drop_by_hash,
-  has_changes,
-  has_conflict,
-  has_stashable_changes,
-  has_work,
-  holds_work,
-  list,
-  list_by_hash,
-  matches,
-  parse_entries,
-  pop,
-  position_of,
-  push,
-  select,
-  STASHABLE_PATHSPEC,
-  unmerged_paths,
-  work_message
-};
-
-export {
-  git_stash
-};

package/dist/commands/chunk-WTIPX5NG.js

@@ -1,43 +0,0 @@
-import {
-  format_dependency_links
-} from "./chunk-2ADQ5XRD.js";
-import {
-  git_gh_command
-} from "./chunk-NRULNBYI.js";
-import {
-  session_cite
-} from "./chunk-22DVQCP6.js";
-
-// scripts/epic/epic-relations.ts
-async function apply_one(link, action) {
-  const blocked = String(link.blocked);
-  const blocker = String(link.blocker);
-  return action === "record" ? await git_gh_command.issue_add_blocked_by(blocked, blocker) : await git_gh_command.issue_remove_blocked_by(blocked, blocker);
-}
-async function apply_relations(links, action) {
-  if (links.length === 0) return 0;
-  const applied = await Promise.all(links.map(async (link) => await apply_one(link, action)));
-  return applied.filter((is_applied) => !is_applied).length;
-}
-function describe_action(action) {
-  return action === "record" ? "recorded" : "removed";
-}
-function format_relation_report(input) {
-  const verb = describe_action(input.action);
-  const total = String(input.links.length);
-  if (input.links.length === 0) return `\u{1F517} No blocked-by relation was ${verb}.`;
-  if (input.failures === 0) {
-    return session_cite.text(
-      `\u{1F517} ${total} blocked-by relation(s) ${verb}: ${format_dependency_links(input.links)}.`
-    );
-  }
-  return `\u26A0\uFE0F  ${String(input.failures)} of ${total} blocked-by relation(s) could not be ${verb}; the epic body is intact.`;
-}
-var epic_relations = {
-  apply_relations,
-  format_relation_report
-};
-
-export {
-  epic_relations
-};