@joshuafolkken/kit 1.3044.0 → 1.3099.0

package/dist/commands/chunk-3PEXBHRN.js

@@ -1,33 +0,0 @@
-import {
-  git_gh_api_path
-} from "./chunk-RDRN56E4.js";
-import {
-  git_gh_exec
-} from "./chunk-XDF25GSU.js";
-import {
-  PROJECT_ROOT
-} from "./chunk-3CCGKX7Y.js";
-
-// scripts/gh/gh-spawn.ts
-var NO_BUDGET = 0;
-function fetch_repo_name(timeout_ms) {
-  const stdout = git_gh_exec.read_gh_api_sync({
-    path: git_gh_api_path.repo_api_path(),
-    jq_filter: ".full_name",
-    cwd: PROJECT_ROOT,
-    timeout_ms: timeout_ms ?? NO_BUDGET
-  });
-  const name = stdout?.trim();
-  return name === "" ? void 0 : name;
-}
-function get_repo_name_with_owner() {
-  return fetch_repo_name(void 0);
-}
-function get_repo_name_with_owner_within(timeout_ms) {
-  return fetch_repo_name(timeout_ms);
-}
-var gh_spawn = { get_repo_name_with_owner, get_repo_name_with_owner_within };
-
-export {
-  gh_spawn
-};

package/dist/commands/chunk-3Z425MM3.js

@@ -1,61 +0,0 @@
-import {
-  review_comment_round
-} from "./chunk-CKUKK7JG.js";
-import {
-  observation_ledger
-} from "./chunk-SV4FZR24.js";
-import {
-  lane_child_marker
-} from "./chunk-QAHFPCFR.js";
-import {
-  git_common_directory
-} from "./chunk-FFHEGWPK.js";
-import {
-  error_text
-} from "./chunk-CDY4NFQG.js";
-
-// scripts/review/review-comment-carry.ts
-import { rmSync } from "node:fs";
-import path from "node:path";
-var CARRIED_LINE = "review-finding line(s) recorded on closed issues after their pull requests opened into the ledger.";
-var CARRY_FAILED_LINE = "Could not carry the closed issues\u2019 comment rounds into the ledger; the next carry retries:";
-var LANE_CARRY_LINE = "Not carrying the closed issues\u2019 comment rounds: a lane leaves them to `pnpm josh observations:flush`.";
-var UNKNOWN_CHECKOUT_LINE = "Not carrying the closed issues\u2019 comment rounds: Git could not identify this checkout; `pnpm josh observations:flush` carries them later.";
-var GIT_DIRECTORY_COUNT = 2;
-var UNTRACKED_PREFIX = "?? ";
-function discard_uncommitted(status_output, root) {
-  const untracked = status_output.split("\n").filter((line) => line.startsWith(UNTRACKED_PREFIX));
-  const carried = untracked.map((line) => observation_ledger.status_path(line)).filter((file_path) => review_comment_round.is_carried_file(file_path));
-  for (const file_path of carried) rmSync(path.join(root, file_path), { force: true });
-}
-async function carry_reported(root) {
-  try {
-    const count = await review_comment_round.carry(root);
-    if (count > 0) console.info(`Carried ${String(count)} ${CARRIED_LINE}`);
-  } catch (error) {
-    console.warn(`${CARRY_FAILED_LINE} ${error_text.message_of(error)}`);
-  }
-}
-async function carry_from_record(root) {
-  const directories = lane_child_marker.is_child_of(root) ? void 0 : git_common_directory.directories(root);
-  if (directories === void 0 || git_common_directory.select_linked(directories) !== void 0) {
-    console.info(LANE_CARRY_LINE);
-    return;
-  }
-  if (directories.length !== GIT_DIRECTORY_COUNT) {
-    console.warn(UNKNOWN_CHECKOUT_LINE);
-    return;
-  }
-  await carry_reported(root);
-}
-var review_comment_carry = {
-  CARRIED_LINE,
-  CARRY_FAILED_LINE,
-  carry_reported,
-  carry_from_record,
-  discard_uncommitted
-};
-
-export {
-  review_comment_carry
-};

package/dist/commands/chunk-3ZOX4G4U.js

@@ -1,88 +0,0 @@
-import {
-  live_evidence
-} from "./chunk-3B2HEFNO.js";
-import {
-  acceptance_map
-} from "./chunk-5PCK53WP.js";
-import {
-  removed_tests
-} from "./chunk-U7Y6RKLK.js";
-import {
-  git_command
-} from "./chunk-AKQYYHP2.js";
-
-// scripts/run/ship/run-ship-body-draft.ts
-import { access, rm, writeFile } from "node:fs/promises";
-import path from "node:path";
-var BODY_FILE_OPTION = "body-file";
-var DRAFT_PREFIX = "josh-ship-body-";
-var DRAFT_SUFFIX = ".md";
-var EXISTS_CODE = "EEXIST";
-var NO_GIT_DIRECTORY = "no git directory to hold the ship body draft";
-async function path_of(issue_number) {
-  const [git_directory] = await git_command.git_directories();
-  if (git_directory === void 0) throw new Error(NO_GIT_DIRECTORY);
-  return path.join(git_directory, `${DRAFT_PREFIX}${issue_number}${DRAFT_SUFFIX}`);
-}
-function is_exists_error(error) {
-  return error instanceof Error && "code" in error && error.code === EXISTS_CODE;
-}
-var FORMAT_HINTS = [
-  acceptance_map.ROW_FORMAT,
-  live_evidence.EVIDENCE_FORMAT,
-  `when the change removes or renames a test, ${removed_tests.ROW_FORMAT}`
-];
-function hint_line(format) {
-  return `<!-- ${format} -->`;
-}
-function draft_text(acceptance_rows) {
-  const hints = FORMAT_HINTS.map((format) => hint_line(format)).join("\n");
-  return `${acceptance_rows}
-
-${hints}
-
-${live_evidence.EVIDENCE_HEADING}
-`;
-}
-async function prepare(issue_number, acceptance_rows) {
-  const target = await path_of(issue_number);
-  try {
-    await writeFile(target, draft_text(acceptance_rows), { flag: "wx" });
-  } catch (error) {
-    if (!is_exists_error(error)) throw error;
-  }
-  return target;
-}
-async function existing(issue_number) {
-  const target = await path_of(issue_number);
-  try {
-    await access(target);
-    return target;
-  } catch {
-    return void 0;
-  }
-}
-async function remove(issue_number) {
-  await rm(await path_of(issue_number), { force: true });
-}
-function body_arguments(body_path) {
-  return body_path === void 0 ? [] : [`--${BODY_FILE_OPTION}`, body_path];
-}
-async function with_draft(args) {
-  if (args.body_path !== void 0) return args;
-  const draft = await existing(args.number);
-  return draft === void 0 ? args : { ...args, body: body_arguments(draft), body_path: draft };
-}
-var run_ship_body_draft = {
-  BODY_FILE_OPTION,
-  body_arguments,
-  existing,
-  path_of,
-  prepare,
-  remove,
-  with_draft
-};
-
-export {
-  run_ship_body_draft
-};

package/dist/commands/chunk-452HWOJ7.js

@@ -1,395 +0,0 @@
-import {
-  lane_handoff
-} from "./chunk-BYFC6MD2.js";
-import {
-  PROCESS_ALIVE,
-  PROCESS_NONE,
-  PROCESS_UNKNOWN
-} from "./chunk-3AEDZZNL.js";
-import {
-  lane_environment
-} from "./chunk-5ZTQX7OS.js";
-import {
-  git_worktree
-} from "./chunk-W3FX7FYN.js";
-import {
-  lane_reap
-} from "./chunk-2DJLAUYB.js";
-import {
-  lane_child_invocation,
-  process_tools
-} from "./chunk-EW4NPUMQ.js";
-import {
-  repo_discovery
-} from "./chunk-MDKDJF2K.js";
-import {
-  lane_paths
-} from "./chunk-YIA6FC3K.js";
-import {
-  issue_number_shape
-} from "./chunk-66NX6EXR.js";
-import {
-  process_identity
-} from "./chunk-AKK56GNX.js";
-import {
-  ENV_FILE_NAME
-} from "./chunk-IGD6QJPH.js";
-import {
-  git_command
-} from "./chunk-AKQYYHP2.js";
-import {
-  file_reader
-} from "./chunk-ZNX2LJCQ.js";
-import {
-  PROBE_TIMEOUT_MS
-} from "./chunk-WPAQUMHC.js";
-
-// scripts/lane/lane-registry.ts
-import { chmodSync, existsSync, statSync, writeFileSync } from "node:fs";
-import path from "node:path";
-
-// scripts/lane/lane-listening-ports.ts
-import { readFile } from "node:fs/promises";
-import { execa } from "execa";
-var PORT_FIELD = /^n.*:(?<port>\d+)$/gmu;
-var NO_MATCH = 1;
-var HEX_RADIX = 16;
-var LISTEN_STATE = "0A";
-var TCP_TABLE = "/proc/net/tcp";
-var TCP6_TABLE = "/proc/net/tcp6";
-var TABLE_FIELDS = 4;
-var ADDRESS_FIELDS = 2;
-async function read_text(file) {
-  return await readFile(file, "utf8");
-}
-function linux_port(line) {
-  const [, local, , state] = line.trim().split(/\s+/u, TABLE_FIELDS);
-  if (state !== LISTEN_STATE || local === void 0) return [];
-  const port = Number.parseInt(local.split(":", ADDRESS_FIELDS)[1] ?? "", HEX_RADIX);
-  return Number.isSafeInteger(port) ? [port] : [];
-}
-async function ipv6_text(read) {
-  try {
-    return await read(TCP6_TABLE);
-  } catch (error) {
-    if (error instanceof Error && "code" in error && error.code === "ENOENT") return "";
-    throw error;
-  }
-}
-async function linux_ports(read) {
-  const tables = await Promise.all([read(TCP_TABLE), ipv6_text(read)]);
-  return new Set(tables.flatMap((table) => table.split("\n").flatMap((line) => linux_port(line))));
-}
-async function darwin_ports() {
-  const result = await execa("lsof", ["-nP", "-iTCP", "-sTCP:LISTEN", "-Fn"], {
-    reject: false,
-    timeout: PROBE_TIMEOUT_MS
-  });
-  if (result.exitCode !== 0 && result.exitCode !== NO_MATCH) return void 0;
-  if (result.stderr.trim() !== "") return void 0;
-  return new Set(
-    [...result.stdout.matchAll(PORT_FIELD)].map((match) => Number(match.groups?.["port"]))
-  );
-}
-async function read_for(platform, read) {
-  if (platform === "linux") return await linux_ports(read);
-  return platform === "darwin" ? await darwin_ports() : void 0;
-}
-async function read_ports(platform = process.platform, read = read_text) {
-  try {
-    return await read_for(platform, read);
-  } catch {
-    return void 0;
-  }
-}
-var lane_listening_ports = { read_ports };
-
-// scripts/lane/lane-process-table.ts
-import { execa as execa2 } from "execa";
-var COLUMNS = ["pid=", "ppid=", "time=", "rss=", "stat=", process_identity.START_TIME_FORMAT];
-var PS_ARGUMENTS = ["-A", "-ww", "-o", [...COLUMNS, "command="].join(",")];
-var PS_ENVIRONMENT = process_identity.PROBE_ENVIRONMENT;
-var FIELD_SEPARATOR = /\s+/u;
-var START_FIELDS = 5;
-var DAY_FIELD = 2;
-var DAY_WIDTH = 2;
-function is_row(row) {
-  const { pid, parent, rss_kb, command } = row;
-  return Number.isSafeInteger(pid + parent) && Number.isFinite(rss_kb) && command !== "";
-}
-function start_of(fields) {
-  return fields.map((field, index) => index === DAY_FIELD ? field.padStart(DAY_WIDTH) : field).join(" ");
-}
-function row_of(line) {
-  const [pid, parent, time = "", rss, stat = "", ...rest] = line.trim().split(FIELD_SEPARATOR);
-  const numbers = { pid: Number(pid), parent: Number(parent), rss_kb: Number(rss) };
-  const start = start_of(rest.slice(0, START_FIELDS));
-  const row = { ...numbers, time, stat, start, command: rest.slice(START_FIELDS).join(" ") };
-  return is_row(row) ? row : void 0;
-}
-function parse(printed) {
-  return printed.split("\n").map((line) => row_of(line)).filter((row) => row !== void 0);
-}
-function matching_in(rows, pattern) {
-  const expression = new RegExp(pattern, "u");
-  return rows.filter((row) => expression.test(row.command)).map((row) => row.pid);
-}
-function children_index(rows) {
-  const children = /* @__PURE__ */ new Map();
-  for (const { pid, parent } of rows) {
-    const siblings = children.get(parent) ?? [];
-    siblings.push(pid);
-    children.set(parent, siblings);
-  }
-  return children;
-}
-function probes_of(rows) {
-  const by_pid = new Map(rows.map((row) => [row.pid, row]));
-  const children = children_index(rows);
-  return {
-    matching: (pattern) => matching_in(rows, pattern),
-    children_of: (pid) => children.get(pid) ?? [],
-    parent_of: (pid) => by_pid.get(pid)?.parent
-  };
-}
-function start_reader(rows) {
-  const starts = new Map(rows.map((row) => [row.pid, row.start]));
-  const probes = {
-    ...process_identity.START_PROBES,
-    read_ps_start: (pid) => starts.get(pid)
-  };
-  return (pid) => process_identity.read_start(pid, probes);
-}
-async function read_table() {
-  try {
-    const { stdout } = await execa2(lane_reap.PS_COMMAND, PS_ARGUMENTS, {
-      env: PS_ENVIRONMENT,
-      timeout: PROBE_TIMEOUT_MS
-    });
-    return parse(stdout);
-  } catch (error) {
-    process_tools.throw_if_missing(lane_reap.PS_COMMAND, error);
-    return void 0;
-  }
-}
-function shared(read) {
-  const taken = {};
-  return async function table() {
-    taken.table ??= read();
-    return await taken.table;
-  };
-}
-var lane_process_table = {
-  PS_ARGUMENTS,
-  parse,
-  probes_of,
-  read_table,
-  shared,
-  start_reader
-};
-
-// scripts/lane/lane-snapshot-trace.ts
-function is_matched(probes, issue) {
-  return probes.matching(lane_child_invocation.process_pattern(issue)).length > 0;
-}
-async function traces_of(issues, rows) {
-  if (rows === void 0) return () => PROCESS_UNKNOWN;
-  const probes = lane_process_table.probes_of(rows);
-  const unmatched = issues.filter((issue) => !is_matched(probes, issue));
-  const is_shipping = unmatched.length === 0 ? () => false : await lane_handoff.ship_reader(lane_process_table.start_reader(rows));
-  const idle = new Set(unmatched.filter((issue) => !is_shipping(issue)));
-  return (issue) => idle.has(issue) ? PROCESS_NONE : PROCESS_ALIVE;
-}
-function never_merge_waiting() {
-  return false;
-}
-async function merge_waits_of(issues, rows) {
-  if (rows === void 0) return never_merge_waiting;
-  const probes = lane_process_table.probes_of(rows);
-  const shipping = issues.filter(
-    (issue) => probes.matching(lane_child_invocation.ship_pattern(issue)).length > 0
-  );
-  if (shipping.length === 0) return never_merge_waiting;
-  return await lane_handoff.merge_wait_reader(lane_process_table.start_reader(rows));
-}
-async function count_merge_waiting(issues, table = lane_process_table.read_table) {
-  const is_waiting = await merge_waits_of(issues, await table());
-  return issues.filter((issue) => is_waiting(issue)).length;
-}
-var lane_snapshot_trace = { count_merge_waiting, merge_waits_of, traces_of };
-
-// scripts/lane/lane-seat-ownership.ts
-var UNREADABLE = "Cannot read lane process ownership or listening ports (process or socket probe failed).";
-async function snapshot(issues = []) {
-  const [ports, rows] = await Promise.all([
-    lane_listening_ports.read_ports(),
-    lane_process_table.read_table()
-  ]);
-  if (ports === void 0 || rows === void 0) return void 0;
-  const trace = await lane_snapshot_trace.traces_of(issues, rows);
-  return { running: new Set(issues.filter((issue) => trace(issue) === PROCESS_ALIVE)), ports };
-}
-function ports_held(lane, ports) {
-  return [lane.development_port, lane.preview_port].some(
-    (port) => port !== void 0 && ports.has(port)
-  );
-}
-function ownership(lane, reading) {
-  if (lane.is_stranded) return { ...lane, seat_held: false };
-  if (reading === void 0) return { ...lane, seat_held: true, seat_problem: UNREADABLE };
-  const is_running = reading.running.has(lane.issue);
-  return {
-    ...lane,
-    seat_owned: is_running,
-    seat_held: is_running || ports_held(lane, reading.ports)
-  };
-}
-function measure(lanes, reading) {
-  return lanes.map((lane) => ownership(lane, reading));
-}
-var lane_seat_ownership = { measure, ports_held, snapshot, UNREADABLE };
-
-// scripts/lane/lane-registry.ts
-var OWNER_ONLY_MODE = 384;
-var WORKTREE_PREFIX = "worktree ";
-var BRANCH_PREFIX = "branch refs/heads/";
-var BLOCK_SEPARATOR = "\n\n";
-function line_value(lines, prefix) {
-  return lines.find((line) => line.startsWith(prefix))?.slice(prefix.length);
-}
-function seat_from_content(content) {
-  const seat = lane_environment.read_lane_seat(content);
-  if (seat === void 0) return void 0;
-  const port_pair = lane_environment.read_lane_ports(content);
-  return { seat, development_port: port_pair.development, preview_port: port_pair.preview };
-}
-var EMPTY_SEAT = {
-  seat: void 0,
-  development_port: void 0,
-  preview_port: void 0
-};
-function held_seat(content) {
-  if (content === void 0) return EMPTY_SEAT;
-  return seat_from_content(content) ?? EMPTY_SEAT;
-}
-function read_environment(directory) {
-  return file_reader.read_if_readable(path.join(directory, ENV_FILE_NAME));
-}
-function write_environment(directory, content) {
-  const file = path.join(directory, ENV_FILE_NAME);
-  writeFileSync(file, content, { mode: OWNER_ONLY_MODE });
-  chmodSync(file, OWNER_ONLY_MODE);
-}
-function dispatched_at(directory) {
-  return statSync(path.join(directory, ENV_FILE_NAME), { throwIfNoEntry: false })?.mtimeMs;
-}
-function branch_issue(branch) {
-  if (!branch?.endsWith(lane_paths.LANE_BRANCH_SUFFIX)) return void 0;
-  const issue = branch.slice(0, -lane_paths.LANE_BRANCH_SUFFIX.length);
-  return issue_number_shape.ISSUE_NUMBER_PATTERN.test(issue) ? issue : void 0;
-}
-function is_gone(directory) {
-  return !existsSync(directory);
-}
-function build_lane(issue, branch, directory, is_stranded) {
-  const content = is_stranded ? void 0 : read_environment(directory);
-  const held = held_seat(content);
-  const output = content === void 0 ? void 0 : lane_environment.read_lane_output(content);
-  const profile = content === void 0 ? void 0 : lane_environment.read_lane_profile(content);
-  return {
-    issue,
-    branch,
-    directory,
-    seat: held.seat,
-    development_port: held.development_port,
-    preview_port: held.preview_port,
-    output,
-    profile,
-    dispatched_ms: is_stranded ? void 0 : dispatched_at(directory),
-    is_stranded
-  };
-}
-function is_lane_directory(root, issue, directory) {
-  return directory === lane_paths.lane_directory(root, issue);
-}
-function parse_block(block, root) {
-  const lines = block.split("\n");
-  const directory = line_value(lines, WORKTREE_PREFIX);
-  const branch = line_value(lines, BRANCH_PREFIX);
-  const issue = branch_issue(branch);
-  if (directory === void 0 || branch === void 0 || issue === void 0 || !is_lane_directory(root, issue, directory)) {
-    return void 0;
-  }
-  return build_lane(issue, branch, directory, is_gone(directory));
-}
-function is_lane(lane) {
-  return lane !== void 0;
-}
-async function worktree_blocks() {
-  const listing = await git_worktree.worktree_list();
-  return listing.split(BLOCK_SEPARATOR);
-}
-async function main_repository_root() {
-  return repo_discovery.main_worktree(await git_command.repository_root());
-}
-async function lane_root_directory() {
-  return lane_paths.lane_root(await main_repository_root());
-}
-async function lane_location(issue) {
-  return { issue, directory: lane_paths.lane_directory(await lane_root_directory(), issue) };
-}
-async function list_lanes(main_root) {
-  const root = lane_paths.lane_root(main_root ?? await main_repository_root());
-  const blocks = await worktree_blocks();
-  const lanes = blocks.map((block) => parse_block(block, root)).filter(is_lane);
-  const reading = await lane_seat_ownership.snapshot(lanes.map((lane) => lane.issue));
-  const measured = lane_seat_ownership.measure(lanes, reading);
-  return measured.toSorted((left, right) => Number(left.issue) - Number(right.issue));
-}
-async function registered_directories() {
-  const blocks = await worktree_blocks();
-  return blocks.flatMap((block) => line_value(block.split("\n"), WORKTREE_PREFIX) ?? []);
-}
-async function has_lanes_in_flight() {
-  const lanes = await list_lanes();
-  return lanes.some((lane) => !lane.is_stranded);
-}
-function used_seats(lanes) {
-  return [
-    ...new Set(lanes.filter((lane) => lane.seat_held !== false).flatMap((lane) => lane.seat ?? []))
-  ];
-}
-function unreadable_lanes(lanes) {
-  return lanes.filter(
-    (lane) => !lane.is_stranded && (lane.seat === void 0 || lane.seat_problem !== void 0)
-  );
-}
-function find_lane(lanes, issue) {
-  return lanes.find((lane) => lane.issue === issue);
-}
-async function find_open_lane(issue) {
-  return find_lane(await list_lanes(), issue);
-}
-var lane_registry = {
-  find_lane,
-  find_open_lane,
-  has_lanes_in_flight,
-  lane_location,
-  lane_root_directory,
-  list_lanes,
-  main_repository_root,
-  parse_block,
-  read_environment,
-  registered_directories,
-  unreadable_lanes,
-  used_seats,
-  write_environment,
-  OWNER_ONLY_MODE
-};
-
-export {
-  lane_process_table,
-  lane_snapshot_trace,
-  lane_seat_ownership,
-  lane_registry
-};