@joshuafolkken/kit 1.3101.0 → 1.3125.0

package/dist/commands/chunk-QHWQJCV5.js

@@ -0,0 +1,250 @@
+import {
+  issue_bug_label
+} from "./chunk-Z4E7V7YJ.js";
+import {
+  observation_ledger
+} from "./chunk-SV4FZR24.js";
+import {
+  base_tree
+} from "./chunk-H6TBBVC2.js";
+import {
+  test_declared_logic
+} from "./chunk-7HCPRVMB.js";
+import {
+  changed_paths
+} from "./chunk-AL2H63BP.js";
+import {
+  change_base
+} from "./chunk-FVPRBMHE.js";
+import {
+  git_location_environment
+} from "./chunk-B77ZMVHS.js";
+import {
+  json_value
+} from "./chunk-HIU2WXB6.js";
+
+// scripts/test/test-red.ts
+import { existsSync } from "node:fs";
+import { readFile, realpath, rm, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { execa } from "execa";
+
+// scripts/test/test-red-logic.ts
+import node_path from "node:path";
+import { z } from "zod";
+var { BUG_DECLARATION_LINE } = issue_bug_label;
+var UNIT_TEST_SUFFIX = ".test.ts";
+function is_bug_fix(body) {
+  return issue_bug_label.is_bug_fix(body);
+}
+function unit_test_files(paths) {
+  return paths.map((path2) => path2.trim()).filter((path2) => test_declared_logic.is_test_file(path2) && path2.endsWith(UNIT_TEST_SUFFIX));
+}
+function is_test_only(paths) {
+  const counted = paths.filter((path2) => !observation_ledger.is_ledger_path(path2));
+  return counted.length > 0 && counted.every((path2) => test_declared_logic.is_test_file(path2));
+}
+var REPORT_SCHEMA = z.object({ testResults: z.array(z.unknown()) });
+function ran_file_count(report) {
+  return json_value.parse_with(report, REPORT_SCHEMA)?.testResults.length ?? 0;
+}
+var RESULT_SCHEMA = z.object({ name: z.string(), status: z.string() });
+var RESULTS_SCHEMA = z.object({ testResults: z.array(RESULT_SCHEMA) });
+var FAILED_STATUS = "failed";
+var PARENT_PREFIX = "..";
+function is_inside(name) {
+  return !name.startsWith(PARENT_PREFIX) && !node_path.isAbsolute(name);
+}
+function relative_in(roots, file) {
+  const relatives = roots.map((root) => node_path.relative(root, file));
+  return relatives.filter((name) => is_inside(name)).slice(0, 1);
+}
+function failed_files(report, roots) {
+  const results = json_value.parse_with(report, RESULTS_SCHEMA)?.testResults ?? [];
+  return results.filter((result) => result.status === FAILED_STATUS).flatMap((result) => relative_in(roots, result.name));
+}
+var QUEUED_EVENT = "queued";
+var END_EVENT = "end";
+function progress_reporter(progress) {
+  const target = JSON.stringify(progress);
+  return [
+    "import { appendFileSync } from 'node:fs'",
+    "export default class {",
+    `	onTestModuleQueued(module) { appendFileSync(${target}, \`${QUEUED_EVENT} \${module.moduleId}\\n\`) }`,
+    `	onTestModuleEnd(module) { appendFileSync(${target}, \`${END_EVENT} \${module.moduleId}\\n\`) }`,
+    "}",
+    ""
+  ].join("\n");
+}
+function files_of(lines, event) {
+  const prefix = `${event} `;
+  return lines.filter((line) => line.startsWith(prefix)).map((line) => line.slice(prefix.length));
+}
+function unfinished_files(progress, roots) {
+  const lines = progress.split("\n");
+  const ended = new Set(files_of(lines, END_EVENT));
+  const running = files_of(lines, QUEUED_EVENT).filter((file) => !ended.has(file));
+  return [...new Set(running)].flatMap((file) => relative_in(roots, file));
+}
+function verdict_for(test_count, is_failed) {
+  if (test_count === 0) return is_failed ? "stopped" : "no-test";
+  return is_failed ? "red" : "green";
+}
+function is_refused(body, verdict) {
+  return verdict === "green" && is_bug_fix(body);
+}
+var test_red_logic = {
+  BUG_DECLARATION_LINE,
+  failed_files,
+  is_bug_fix,
+  is_refused,
+  is_test_only,
+  progress_reporter,
+  ran_file_count,
+  unfinished_files,
+  unit_test_files,
+  verdict_for
+};
+
+// scripts/test/vitest-cache-directory.ts
+var CACHE_DIRECTORY_KEY = "JOSH_VITEST_CACHE_DIR";
+function config_cache_directory(environment = process.env) {
+  const directory = environment[CACHE_DIRECTORY_KEY] ?? "";
+  return directory === "" ? void 0 : directory;
+}
+var vitest_cache_directory = { CACHE_DIRECTORY_KEY, config_cache_directory };
+
+// scripts/test/test-red.ts
+var TREE_PREFIX = "josh-test-red-";
+var REPORT_NAME = "report.json";
+var PROGRESS_NAME = "progress.log";
+var REPORTER_NAME = "progress-reporter.mjs";
+var PROBE_TIMEOUT_MS = 3e5;
+var KILL_SIGNAL = "SIGKILL";
+var CACHE_NAME = "vite-cache";
+var VITEST_BIN = path.join(base_tree.NODE_MODULES, ".bin", "vitest");
+var USAGE = "Usage: josh test:red \u2014 prints red / green / no-test / stopped / test-only for the changed tests on the merge-base";
+function changed_tests(paths) {
+  return test_red_logic.unit_test_files(paths).filter((file) => existsSync(file));
+}
+function reporter_arguments(report) {
+  return ["--reporter=json", `--outputFile=${report}`];
+}
+async function read_report(report) {
+  return existsSync(report) ? await readFile(report, "utf8") : "";
+}
+async function prepare_outputs(parent, outputs) {
+  const reporter = path.join(parent, REPORTER_NAME);
+  await Promise.all(
+    outputs.map(async (output) => {
+      await rm(output, { force: true });
+    })
+  );
+  await writeFile(reporter, test_red_logic.progress_reporter(path.join(parent, PROGRESS_NAME)));
+  return reporter;
+}
+var live_groups = /* @__PURE__ */ new Set();
+function kill_group(pid) {
+  if (pid === void 0) return;
+  try {
+    process.kill(-pid, KILL_SIGNAL);
+  } catch {
+  }
+}
+function stop_live_probes() {
+  for (const pid of live_groups) kill_group(pid);
+}
+process.on("exit", stop_live_probes);
+function spawn_vitest({ parent, tree }, vitest_args) {
+  return execa(path.join(tree, VITEST_BIN), vitest_args, {
+    cwd: tree,
+    detached: true,
+    env: {
+      ...git_location_environment.location_free_environment(),
+      [vitest_cache_directory.CACHE_DIRECTORY_KEY]: path.join(parent, CACHE_NAME)
+    },
+    extendEnv: true,
+    reject: false
+  });
+}
+async function vitest_in(base, vitest_args, timeout_ms) {
+  const state = { timed_out: false };
+  const subprocess = spawn_vitest(base, vitest_args);
+  live_groups.add(subprocess.pid);
+  const timer = setTimeout(() => {
+    state.timed_out = true;
+    kill_group(subprocess.pid);
+  }, timeout_ms);
+  const result = await subprocess;
+  clearTimeout(timer);
+  live_groups.delete(subprocess.pid);
+  return {
+    is_failed: result.exitCode !== 0,
+    timed_out: state.timed_out && result.signal === KILL_SIGNAL
+  };
+}
+async function timeout_error(progress, roots, timeout_ms) {
+  const running = test_red_logic.unfinished_files(await read_report(progress), roots);
+  const names = running.length > 0 ? running.join(", ") : "no test file had been queued";
+  return new Error(
+    `vitest probe passed its ${String(timeout_ms)} ms timeout, still running: ${names}`
+  );
+}
+async function probe_in(base, selection, timeout_ms = PROBE_TIMEOUT_MS) {
+  const report = path.join(base.parent, REPORT_NAME);
+  const progress = path.join(base.parent, PROGRESS_NAME);
+  const reporter = await prepare_outputs(base.parent, [report, progress]);
+  const vitest_args = [
+    ...selection,
+    "--passWithNoTests",
+    ...reporter_arguments(report),
+    `--reporter=${reporter}`
+  ];
+  const outcome = await vitest_in(base, vitest_args, timeout_ms);
+  const roots = [base.tree, await realpath(base.tree)];
+  if (outcome.timed_out) throw await timeout_error(progress, roots, timeout_ms);
+  const text = await read_report(report);
+  const ran = test_red_logic.ran_file_count(text);
+  return {
+    verdict: test_red_logic.verdict_for(ran, outcome.is_failed),
+    failed: test_red_logic.failed_files(text, roots),
+    ran
+  };
+}
+async function verdict_on(base, files) {
+  return await base_tree.with_tree(TREE_PREFIX, base, async (pre_fix) => {
+    await base_tree.copy_in(pre_fix.tree, files);
+    const probe = await probe_in(pre_fix, ["run", ...files]);
+    return probe.verdict;
+  });
+}
+async function run() {
+  const base = await change_base.resolved_through_merge();
+  const paths = await changed_paths.read_changed_paths(false);
+  const files = changed_tests(paths);
+  if (base === void 0 || files.length === 0) return { verdict: "no-test", files };
+  if (test_red_logic.is_test_only(paths)) return { verdict: "test-only", files };
+  return { verdict: await verdict_on(base, files), files };
+}
+async function main(argv) {
+  if (argv.length > 0) {
+    process.stderr.write(`${USAGE}
+`);
+    return argv.includes("--help") ? 0 : 1;
+  }
+  const { verdict, files } = await run();
+  process.stdout.write(`${verdict}
+`);
+  if (files.length > 0) process.stderr.write(`${files.join("\n")}
+`);
+  return 0;
+}
+function has_runner() {
+  return existsSync(VITEST_BIN);
+}
+var test_red = { has_runner, main, probe_in, run, stop_live_probes };
+
+export {
+  test_red_logic,
+  test_red
+};

package/dist/commands/chunk-QI72D6NY.js

@@ -0,0 +1,54 @@
+import {
+  project_checks
+} from "./chunk-23TWJOAI.js";
+import {
+  test_declared_logic
+} from "./chunk-7HCPRVMB.js";
+import {
+  git_spawn_sync
+} from "./chunk-B77ZMVHS.js";
+import {
+  PORCELAIN_FLAG
+} from "./chunk-B5GXZK3E.js";
+
+// scripts/test/test-declared-changed.ts
+var RENAME_ARROW = " -> ";
+var STATUS_PREFIX_LENGTH = 3;
+function path_of(line) {
+  const body = line.slice(STATUS_PREFIX_LENGTH);
+  const arrow = body.indexOf(RENAME_ARROW);
+  return arrow === -1 ? body : body.slice(arrow + RENAME_ARROW.length);
+}
+function read_changed_paths_sync() {
+  const output = git_spawn_sync.run(["status", PORCELAIN_FLAG], { timeout: 0 });
+  if (output.exit_code !== 0) return [];
+  return output.stdout.split("\n").filter((line) => line.length > STATUS_PREFIX_LENGTH).map((line) => path_of(line));
+}
+var injected = {};
+function source_paths() {
+  return injected.paths ?? read_changed_paths_sync();
+}
+function current_verdict(paths = source_paths()) {
+  return test_declared_logic.verdict_for(paths, project_checks.is_basic(process.cwd()));
+}
+function restore_injection(previous) {
+  if (previous === void 0) {
+    delete injected.paths;
+    return;
+  }
+  injected.paths = previous;
+}
+function with_paths(paths, body) {
+  const previous = injected.paths;
+  injected.paths = paths;
+  try {
+    return body();
+  } finally {
+    restore_injection(previous);
+  }
+}
+var test_declared_changed = { current_verdict, path_of, read_changed_paths_sync, with_paths };
+
+export {
+  test_declared_changed
+};

package/dist/commands/chunk-QN3FWRDW.js

@@ -0,0 +1,122 @@
+import {
+  backlog_drive_restore
+} from "./chunk-52CGT2IN.js";
+import {
+  lane_await
+} from "./chunk-YSDBY2G7.js";
+import {
+  lane_registry
+} from "./chunk-KXZR7UAE.js";
+import {
+  PROCESS_ALIVE,
+  PROCESS_NONE,
+  PROCESS_UNKNOWN
+} from "./chunk-L7GYJHDX.js";
+import {
+  issue_state
+} from "./chunk-HXM26K3O.js";
+import {
+  git_gh_issue_read
+} from "./chunk-U6SMBYTN.js";
+import {
+  run_hold
+} from "./chunk-NQ4D2XZY.js";
+import {
+  run_event_stream_emit
+} from "./chunk-XO7S2BTY.js";
+import {
+  git_command
+} from "./chunk-KMED24C4.js";
+
+// scripts/lane/lane-spent.ts
+var STATE_FIELD = "state";
+var CLOSED_STATE = "CLOSED";
+async function read_issue_state(issue) {
+  const json = await git_gh_issue_read.issue_view_json(issue, STATE_FIELD);
+  return json === void 0 ? void 0 : issue_state.parse_issue_state(json)?.state;
+}
+async function read_unpushed_commits(branch) {
+  try {
+    return await git_command.commit_count_unpushed(branch);
+  } catch {
+    return void 0;
+  }
+}
+async function read_in_flight() {
+  return backlog_drive_restore.active_issues(await run_event_stream_emit.current_events());
+}
+var LIVE_PROBES = {
+  process_trace: lane_await.process_trace_default,
+  issue_state: read_issue_state,
+  in_flight: read_in_flight,
+  is_tree_dirty: run_hold.is_tree_dirty,
+  unpushed_commits: read_unpushed_commits
+};
+function trace_of(lane, probes) {
+  return lane.is_stranded ? PROCESS_NONE : probes.process_trace(lane.issue);
+}
+async function child_reason(lane, probes) {
+  const trace = probes.process_trace(lane.issue);
+  if (trace === PROCESS_NONE) return void 0;
+  return trace === PROCESS_ALIVE ? "a child is still working in it" : "whether a child is working in it could not be read";
+}
+async function issue_reason(lane, probes) {
+  const state = await probes.issue_state(lane.issue);
+  if (state === CLOSED_STATE) return void 0;
+  return state === void 0 ? "its issue could not be read" : "its issue is still open";
+}
+async function run_reason(lane, probes) {
+  const in_flight = await probes.in_flight();
+  return in_flight.has(lane.issue) ? "the running backlogrun has not collected it yet (`pnpm josh run:merge` does)" : void 0;
+}
+async function tree_reason(lane, probes) {
+  return await probes.is_tree_dirty(lane.directory) ? "it has uncommitted changes" : void 0;
+}
+async function commit_reason(lane, probes) {
+  const count = await probes.unpushed_commits(lane.branch);
+  if (count === 0) return void 0;
+  return count === void 0 ? "its commits could not be counted" : `it has ${String(count)} commit(s) that are on no remote`;
+}
+var CHECKS = [
+  child_reason,
+  issue_reason,
+  run_reason,
+  tree_reason,
+  commit_reason
+];
+async function kept_reason(lane, probes = LIVE_PROBES) {
+  const reasons = await Promise.all(CHECKS.map(async (check) => await check(lane, probes)));
+  return reasons.find((reason) => reason !== void 0);
+}
+async function sort_lanes(lanes, probes = LIVE_PROBES) {
+  const live = lanes.filter((lane) => !lane.is_stranded);
+  const reasons = await Promise.all(live.map(async (lane) => await kept_reason(lane, probes)));
+  const sorted = { spent: [], kept: [] };
+  for (const [index, lane] of live.entries()) {
+    const reason = reasons[index];
+    if (reason === void 0) sorted.spent.push(lane);
+    else sorted.kept.push({ issue: lane.issue, reason });
+  }
+  return sorted;
+}
+function issues_traced(traced, trace) {
+  return traced.filter(([, answer]) => answer === trace).map(([issue]) => issue);
+}
+function traced_of(lanes, probes) {
+  return lanes.map((lane) => [lane.issue, trace_of(lane, probes)]);
+}
+async function lanes_in_use(probes = LIVE_PROBES) {
+  const traced = traced_of(await lane_registry.list_lanes(), probes);
+  return {
+    working: issues_traced(traced, PROCESS_ALIVE),
+    unread: issues_traced(traced, PROCESS_UNKNOWN)
+  };
+}
+function idle_lanes(lanes, probes = LIVE_PROBES) {
+  return issues_traced(traced_of(lanes, probes), PROCESS_NONE);
+}
+var lane_spent = { idle_lanes, kept_reason, lanes_in_use, read_unpushed_commits, sort_lanes };
+
+export {
+  lane_spent
+};

package/dist/commands/chunk-QQ2JKDSV.js

@@ -0,0 +1,144 @@
+import {
+  run_wake
+} from "./chunk-DIXUXHZ2.js";
+import {
+  import_graph
+} from "./chunk-CVZXDKCV.js";
+import {
+  poll
+} from "./chunk-SBGTCT2C.js";
+import {
+  error_text
+} from "./chunk-CDY4NFQG.js";
+import {
+  process_identity
+} from "./chunk-F2RDEF2J.js";
+import {
+  git_command
+} from "./chunk-KMED24C4.js";
+import {
+  MS_PER_MINUTE,
+  MS_PER_SECOND
+} from "./chunk-WPAQUMHC.js";
+
+// scripts/run/wake/run-wake-code.ts
+function is_changed(loaded, current, is_suspected) {
+  if (current === void 0) return false;
+  if (loaded === void 0) return is_suspected;
+  return loaded !== current;
+}
+function consume(state, read, current) {
+  if (current === void 0) {
+    state.is_suspect = read.is_suspect;
+    return;
+  }
+  state.head = read.head;
+  state.is_suspect = false;
+}
+async function is_stale(state, source, is_suspected) {
+  const head = await source.head();
+  const is_suspect = is_suspected() || state.is_suspect;
+  if (!is_suspect && head === state.head) return false;
+  const current = await source.closure();
+  consume(state, { head, is_suspect }, current);
+  return is_changed(state.loaded, current, is_suspect);
+}
+async function watch(source, is_suspected = () => false) {
+  const state = {
+    head: await source.head(),
+    loaded: await source.closure(),
+    is_suspect: false
+  };
+  return async () => await is_stale(state, source, is_suspected);
+}
+async function read_head() {
+  try {
+    return await git_command.head_commit();
+  } catch (error) {
+    error_text.trace_swallowed("run_wake_code.read_head", error);
+    return void 0;
+  }
+}
+async function read_closure(root, entry) {
+  try {
+    const graph = await import_graph.create(root);
+    return graph?.closure_hash(entry);
+  } catch (error) {
+    error_text.trace_swallowed("run_wake_code.read_closure", error);
+    return void 0;
+  }
+}
+function source_of(root, entry) {
+  return { head: read_head, closure: async () => await read_closure(root, entry) };
+}
+var run_wake_code = { source_of, watch };
+
+// scripts/backlog/backlog-dispatch-bound.ts
+var DISPATCH_BOUND_SECONDS = 60;
+var DISPATCH_BOUND_MS = DISPATCH_BOUND_SECONDS * MS_PER_SECOND;
+var DRIVER_START_SECONDS = 25;
+var DRIVER_START_MS = DRIVER_START_SECONDS * MS_PER_SECOND;
+var NOTICE_MS = DISPATCH_BOUND_MS - DRIVER_START_MS;
+var backlog_dispatch_bound = { DISPATCH_BOUND_MS, DRIVER_START_MS, NOTICE_MS };
+
+// scripts/run/wake/run-wake-window.ts
+var WINDOW_MINUTES = 5;
+var WINDOW_MS = WINDOW_MINUTES * MS_PER_MINUTE;
+var PASS_INTERVAL_MS = backlog_dispatch_bound.NOTICE_MS;
+var run_wake_window = { WINDOW_MINUTES, WINDOW_MS, PASS_INTERVAL_MS };
+
+// scripts/run/wake/run-wake-stop.ts
+function signal(pid) {
+  try {
+    process.kill(pid, "SIGTERM");
+  } catch {
+    console.error(
+      `Process ${String(pid)} could not be signalled; the record is removed regardless.`
+    );
+  }
+}
+function signal_supervisor(wake) {
+  if (run_wake.is_supervisor_live(wake)) signal(wake.pid);
+}
+function stop(wake_target) {
+  const wake = run_wake.read_wake(wake_target);
+  if (wake === void 0) return void 0;
+  run_wake.remove_wake(wake_target);
+  signal_supervisor(wake);
+  return wake;
+}
+var run_wake_stop = { signal, stop };
+
+// scripts/run/wake/run-wake-takeover.ts
+var TAKEOVER_INTERVAL_MS = MS_PER_SECOND;
+var TAKEOVER_WAIT_MS = backlog_dispatch_bound.NOTICE_MS;
+var TAKEOVER_ATTEMPTS = TAKEOVER_WAIT_MS / TAKEOVER_INTERVAL_MS;
+function ports_of(wake_target) {
+  return {
+    holder_pid: () => run_wake.read_wake(wake_target)?.pid,
+    is_alive: process_identity.is_live_pid,
+    stop: run_wake_stop.signal
+  };
+}
+function result_of(pid, ports) {
+  if (ports.holder_pid() === pid) return "taken";
+  return ports.is_alive(pid) ? "unclaimed" : "died";
+}
+async function await_takeover(pid, ports, attempts = TAKEOVER_ATTEMPTS) {
+  await poll.poll_until(async () => result_of(pid, ports) !== "unclaimed", {
+    attempts,
+    interval_ms: TAKEOVER_INTERVAL_MS,
+    ...ports.sleeper && { sleeper: ports.sleeper }
+  });
+  const result = result_of(pid, ports);
+  if (result === "unclaimed") ports.stop(pid);
+  return result;
+}
+var run_wake_takeover = { TAKEOVER_WAIT_MS, await_takeover, ports_of };
+
+export {
+  run_wake_code,
+  run_wake_window,
+  run_wake_stop,
+  run_wake_takeover
+};

package/dist/commands/chunk-QRY55H5U.js

@@ -0,0 +1,48 @@
+import {
+  repo_party
+} from "./chunk-DKDWOE3C.js";
+import {
+  gh_rate_limit
+} from "./chunk-W4R6ZBLO.js";
+import {
+  git_gh_etag_read
+} from "./chunk-V6WWW6HX.js";
+import {
+  git_gh_api_path
+} from "./chunk-RDRN56E4.js";
+import {
+  parse_json
+} from "./chunk-NAZ753DE.js";
+import {
+  error_text
+} from "./chunk-CDY4NFQG.js";
+
+// scripts/gh/git-gh-repo.ts
+import { z } from "zod";
+var repository_schema = z.object({ full_name: z.string() });
+function local_name_with_owner() {
+  const identity = repo_party.current_repository();
+  return identity === void 0 ? void 0 : `${identity.owner}/${identity.repo}`;
+}
+async function repo_get_canonical_name_with_owner() {
+  try {
+    const body = await git_gh_etag_read.read(git_gh_api_path.repo_api_path());
+    const name = parse_json.parse_json_object_or_undefined(body, repository_schema)?.full_name.trim();
+    return name === "" ? void 0 : name;
+  } catch (error) {
+    if (gh_rate_limit.is_exhausted(error_text.message_of(error))) throw error;
+    error_text.trace_swallowed("git_gh_repo.repo_get_name_with_owner", error);
+    return void 0;
+  }
+}
+async function repo_get_name_with_owner() {
+  return local_name_with_owner() ?? await repo_get_canonical_name_with_owner();
+}
+var git_gh_repo = {
+  repo_get_canonical_name_with_owner,
+  repo_get_name_with_owner
+};
+
+export {
+  git_gh_repo
+};