@joshuafolkken/kit 1.3101.0 → 1.3125.0

package/dist/commands/chunk-QA44M56F.js

@@ -0,0 +1,333 @@
+import {
+  whole_suite_files
+} from "./chunk-4MRBLCDB.js";
+import {
+  since_green
+} from "./chunk-XHLSJPV7.js";
+import {
+  test_read_map
+} from "./chunk-ZDP6SKBK.js";
+import {
+  changed_file_scope
+} from "./chunk-MEJ2CQK2.js";
+
+// scripts/test/test-related-scope.ts
+import path2 from "node:path";
+
+// scripts/test/lockfile-changed-packages.ts
+import { isDeepStrictEqual } from "node:util";
+import { loadAll } from "js-yaml";
+import { z } from "zod";
+var LOCKFILE_PATH = "pnpm-lock.yaml";
+var VERSION_KEY = "version";
+var SCOPE_PREFIX = "@";
+var DEPENDENCY_GROUPS = ["dependencies", "optionalDependencies"];
+var RESOLUTION_KEYS = /* @__PURE__ */ new Set(["importers", "packages", "snapshots"]);
+var entries_schema = z.record(z.string(), z.unknown()).default({});
+var document_schema = z.looseObject({
+  importers: entries_schema,
+  packages: entries_schema,
+  snapshots: entries_schema
+});
+var snapshot_schema = z.looseObject({
+  dependencies: entries_schema,
+  optionalDependencies: entries_schema
+});
+function documents_of(text) {
+  try {
+    return loadAll(text).map((document) => document_schema.parse(document));
+  } catch {
+    return void 0;
+  }
+}
+function to_package_key(snapshot_key) {
+  const peer_start = snapshot_key.indexOf("(", 1);
+  return peer_start === -1 ? snapshot_key : snapshot_key.slice(0, peer_start);
+}
+function name_of(key) {
+  const package_key = to_package_key(key);
+  const at = package_key.indexOf(SCOPE_PREFIX, 1);
+  return at === -1 ? package_key : package_key.slice(0, at);
+}
+function without_versions(value) {
+  if (Array.isArray(value)) return value.map((item) => without_versions(item));
+  if (typeof value !== "object" || value === null) return value;
+  const kept = Object.entries(value).filter(([key]) => key !== VERSION_KEY);
+  return Object.fromEntries(kept.map(([key, item]) => [key, without_versions(item)]));
+}
+function skeleton_of(document) {
+  const rest = Object.entries(document).filter(([key]) => !RESOLUTION_KEYS.has(key));
+  return { ...Object.fromEntries(rest), importers: without_versions(document.importers) };
+}
+function moved_keys(before, after) {
+  const keys = /* @__PURE__ */ new Set([...Object.keys(before), ...Object.keys(after)]);
+  return [...keys].filter((key) => !isDeepStrictEqual(before[key], after[key]));
+}
+function dependency_names(snapshot) {
+  const parsed = snapshot_schema.safeParse(snapshot ?? {});
+  if (!parsed.success) return [];
+  return DEPENDENCY_GROUPS.flatMap((group) => Object.keys(parsed.data[group]));
+}
+function dependents_of(documents) {
+  const dependents = /* @__PURE__ */ new Map();
+  const snapshots = documents.flatMap((document) => Object.entries(document.snapshots));
+  const edges = snapshots.flatMap(
+    ([key, snapshot]) => dependency_names(snapshot).map((name) => [name, name_of(key)])
+  );
+  for (const [name, dependent] of edges) {
+    dependents.set(name, (dependents.get(name) ?? /* @__PURE__ */ new Set()).add(dependent));
+  }
+  return dependents;
+}
+function with_dependents(moved, dependents) {
+  const reached = new Set(moved);
+  const pending = [...reached];
+  for (let name = pending.pop(); name !== void 0; name = pending.pop()) {
+    const unseen = [...dependents.get(name) ?? []].filter((dependent) => !reached.has(dependent));
+    for (const dependent of unseen) reached.add(dependent);
+    pending.push(...unseen);
+  }
+  return reached;
+}
+function moved_names(was, is) {
+  return [...moved_keys(was.packages, is.packages), ...moved_keys(was.snapshots, is.snapshots)].map(
+    (key) => name_of(key)
+  );
+}
+function is_resolution_only(was, is) {
+  if (was.length !== is.length) return false;
+  return was.every((document, index) => {
+    const other = is[index];
+    return other !== void 0 && isDeepStrictEqual(skeleton_of(document), skeleton_of(other));
+  });
+}
+function affected_packages(before, after) {
+  const was = documents_of(before);
+  const is = documents_of(after);
+  if (was === void 0 || is === void 0 || !is_resolution_only(was, is)) return void 0;
+  const moved = was.flatMap((document, index) => moved_names(document, is[index] ?? document));
+  const reached = with_dependents(moved, dependents_of([...was, ...is]));
+  return [...reached].some((name) => whole_suite_files.is_unit_runtime_package(name)) ? void 0 : reached;
+}
+var lockfile_changed_packages = { LOCKFILE_PATH, affected_packages, to_package_key };
+
+// scripts/test/pure-files-entries.ts
+import path from "node:path";
+var PURE_FILES_PATH = path.join("tools", "test", "pure-files.ts");
+var LIST_TESTS = [
+  path.join("tools", "test", "pure-files.test.ts"),
+  path.join("tools", "test", "classify-isolation.test.ts")
+];
+var ENTRY_LINE = /^\t'(?<entry>[^']+)',$/u;
+function entry_of(line) {
+  return ENTRY_LINE.exec(line)?.groups?.["entry"];
+}
+function lines_of(text) {
+  return text.trimEnd().split("\n");
+}
+function frame_of(text) {
+  return lines_of(text).filter((line) => entry_of(line) === void 0).join("\n");
+}
+function entries_of(text) {
+  return new Set(lines_of(text).flatMap((line) => entry_of(line) ?? []));
+}
+function missing_from(entries, other) {
+  return [...entries].filter((entry) => !other.has(entry));
+}
+function moved_entries(before, after) {
+  if (frame_of(before) !== frame_of(after)) return void 0;
+  const was = entries_of(before);
+  const is = entries_of(after);
+  return [...missing_from(is, was), ...missing_from(was, is)];
+}
+function tests_of(entries) {
+  return [...LIST_TESTS, ...entries];
+}
+var pure_files_entries = { PURE_FILES_PATH, moved_entries, tests_of };
+
+// scripts/test/test-related-scope.ts
+var RELATABLE_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".ts",
+  ".tsx",
+  ".mts",
+  ".cts",
+  ".js",
+  ".jsx",
+  ".mjs",
+  ".cjs",
+  ".svelte"
+]);
+var { WHOLE_SUITE_FILES } = whole_suite_files;
+var { LOCKFILE_PATH: LOCKFILE_PATH2 } = lockfile_changed_packages;
+var { UNREADABLE_REASON } = changed_file_scope;
+var NOTHING_RELATABLE_REASON = "no changed file is one a test can import or read";
+var NO_MAP_REASON = "no test-read map covers the changed non-code file";
+var { UNMOVED_REASON } = since_green;
+var WHOLE_SUITE_SUFFIX = "affects every test";
+var UNRECORDED_SUFFIX = "is read by no recorded test";
+var FALLBACK_KINDS = [
+  { kind: "unreadable", reason: UNREADABLE_REASON },
+  { kind: "nothing-relatable", reason: NOTHING_RELATABLE_REASON },
+  { kind: "no-map", reason: NO_MAP_REASON },
+  { kind: "whole-suite-file", reason: WHOLE_SUITE_SUFFIX },
+  { kind: "unrecorded-file", reason: UNRECORDED_SUFFIX }
+];
+var OTHER_FALLBACK = "other";
+var COMMAND_NAME = "test:related";
+var COMMAND_LABEL = `josh ${COMMAND_NAME}`;
+var { LISTED_FILE_LIMIT } = changed_file_scope;
+var VOCABULARY = {
+  label: COMMAND_LABEL,
+  fallback_suffix: "running the full unit suite instead",
+  narrowed_suffix: "running only the tests related to them"
+};
+var NONE_SUFFIX = "running no tests";
+var RUN_FLAG = "--run";
+var RELATED_SUBCOMMAND = "related";
+var RUN_SUBCOMMAND = "run";
+function is_relatable(file_path) {
+  return RELATABLE_EXTENSIONS.has(path2.extname(file_path));
+}
+function is_moved(request, file) {
+  return request.since_map?.includes(file) !== true;
+}
+function is_code_input(request, file) {
+  if (!is_relatable(file)) return false;
+  if (is_moved(request, file)) return true;
+  return request.naming_moved?.has(file) === true;
+}
+function all_scope(reason, triggers = [], root = "") {
+  return { mode: "all", files: triggers.map((file) => path2.join(root, file)), reason };
+}
+function resolve_through_map(others, request) {
+  const { map, recorded } = request;
+  if (others.length === 0) return { files: [], unread: [] };
+  if (map === void 0) return { reason: `${NO_MAP_REASON} ${String(others[0])}` };
+  const unread = others.filter((file) => test_read_map.readers_of(map, file).length === 0);
+  const unknown = unread.filter(
+    (file) => is_moved(request, file) && !recorded.has(file) && !test_read_map.in_unread_directory(map, file)
+  );
+  if (unknown.length > 0) {
+    return { reason: `${String(unknown[0])} ${UNRECORDED_SUFFIX}`, triggers: unknown };
+  }
+  return { files: others.flatMap((file) => test_read_map.readers_of(map, file)), unread };
+}
+function code_readers(code, map) {
+  if (map === void 0) return [];
+  return code.flatMap((file) => test_read_map.readers_of(map, file));
+}
+function none_scope(unread, root) {
+  const files = unread.map((file) => path2.join(root, file));
+  return { mode: "none", files, reason: `${String(files.length)} changed file(s) reach no test` };
+}
+function narrowed_scope(selection, request) {
+  if (selection.files.length === 0 && selection.unread.length > 0) {
+    return none_scope(selection.unread, request.root);
+  }
+  const present = [...new Set(selection.files)].map((file) => path2.join(request.root, file)).filter((file) => request.is_present(file));
+  if (present.length === 0) return all_scope(NOTHING_RELATABLE_REASON);
+  return { mode: "related", files: present, reason: `${String(present.length)} related file(s)` };
+}
+function left_out(request, code) {
+  return (request.since_map ?? []).filter((file) => !code.includes(file));
+}
+function without_pure_entries(changed, entries) {
+  if (entries === void 0) return { files: [], unread: changed };
+  const rest = changed.filter((file) => file !== pure_files_entries.PURE_FILES_PATH);
+  return { files: pure_files_entries.tests_of(entries), unread: rest };
+}
+function is_narrowed(request, file) {
+  return request.every_test_importers?.has(file) === true;
+}
+function direct_selection(request, changed) {
+  const moved = changed.filter((file) => is_narrowed(request, file) && is_moved(request, file));
+  const tests = moved.map((file) => request.every_test_importers?.get(file) ?? []);
+  return { files: tests.flat(), unread: moved.filter((_file, index) => tests[index]?.length === 0) };
+}
+function is_resolved_elsewhere(request, file) {
+  if (file === LOCKFILE_PATH2) return request.lockfile_importers !== void 0;
+  return request.version_only?.has(file) === true;
+}
+function is_whole_suite_trigger(request, file) {
+  if (is_resolved_elsewhere(request, file)) return false;
+  return WHOLE_SUITE_FILES.has(file) && !is_narrowed(request, file) && is_moved(request, file);
+}
+function whole_suite_triggers(request, changed) {
+  return changed.filter((file) => is_whole_suite_trigger(request, file));
+}
+function resolve_read(request, entry_tests) {
+  const { changed, root } = request;
+  const whole = whole_suite_triggers(request, changed);
+  if (whole.length > 0) return all_scope(`${String(whole[0])} ${WHOLE_SUITE_SUFFIX}`, whole, root);
+  const direct = direct_selection(request, changed);
+  const code = changed.filter((file) => !is_narrowed(request, file) && is_code_input(request, file));
+  const resolution = resolve_through_map(
+    changed.filter((file) => !is_relatable(file) && is_moved(request, file)),
+    request
+  );
+  if ("reason" in resolution) return all_scope(resolution.reason, resolution.triggers, root);
+  const files = [
+    ...code,
+    ...code_readers(code, request.map),
+    ...resolution.files,
+    ...entry_tests,
+    ...direct.files
+  ];
+  const unread = [...resolution.unread, ...left_out(request, code), ...direct.unread];
+  return narrowed_scope({ files, unread }, request);
+}
+function resolve_scope(request) {
+  if (request.changed === void 0) return all_scope(UNREADABLE_REASON);
+  const pure = without_pure_entries(request.changed, request.pure_entries);
+  const lockfile_importers = request.lockfile_importers ?? [];
+  return resolve_read({ ...request, changed: pure.unread }, [...pure.files, ...lockfile_importers]);
+}
+function describe_scope(scope, root) {
+  if (scope.mode !== "none") return changed_file_scope.describe_scope(scope, root, VOCABULARY);
+  const listing = changed_file_scope.format_file_list(scope.files, root);
+  return `${COMMAND_LABEL}: ${scope.reason} \u2014 ${NONE_SUFFIX}.
+${listing}`;
+}
+function reason_kind(reason) {
+  return FALLBACK_KINDS.find((entry) => reason.includes(entry.reason))?.kind ?? OTHER_FALLBACK;
+}
+function fallback_kind(output) {
+  const prefix = `${COMMAND_LABEL}: `;
+  const suffix = ` \u2014 ${VOCABULARY.fallback_suffix}.`;
+  const line = output.split("\n").map((candidate) => candidate.trim()).find((candidate) => candidate.startsWith(prefix) && candidate.endsWith(suffix));
+  if (line === void 0) return void 0;
+  return reason_kind(line.slice(prefix.length, -suffix.length));
+}
+function scope_kind(scope) {
+  return scope.mode === "all" ? reason_kind(scope.reason) : scope.mode;
+}
+function is_unmoved(output) {
+  const line = `${COMMAND_LABEL}: ${UNMOVED_REASON} \u2014 ${NONE_SUFFIX}.`;
+  return output.split("\n").some((candidate) => candidate.trim() === line);
+}
+function vitest_arguments(scope, extra_flags = []) {
+  if (scope.mode !== "related") return [RUN_SUBCOMMAND, ...extra_flags];
+  return [RELATED_SUBCOMMAND, ...scope.files, RUN_FLAG, ...extra_flags];
+}
+var related_scope = {
+  COMMAND_LABEL,
+  COMMAND_NAME,
+  LISTED_FILE_LIMIT,
+  NOTHING_RELATABLE_REASON,
+  NO_MAP_REASON,
+  UNMOVED_REASON,
+  UNREADABLE_REASON,
+  describe_scope,
+  fallback_kind,
+  is_relatable,
+  is_unmoved,
+  resolve_scope,
+  scope_kind,
+  vitest_arguments
+};
+
+export {
+  lockfile_changed_packages,
+  pure_files_entries,
+  related_scope
+};

package/dist/commands/chunk-QDUWBRQC.js

@@ -0,0 +1,61 @@
+import {
+  review_comment_round
+} from "./chunk-5SOU366I.js";
+import {
+  observation_ledger
+} from "./chunk-SV4FZR24.js";
+import {
+  error_text
+} from "./chunk-CDY4NFQG.js";
+import {
+  lane_child_marker
+} from "./chunk-XXPDFJRI.js";
+import {
+  git_common_directory
+} from "./chunk-MT6TRLFD.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-QGTLTPXT.js

@@ -0,0 +1,58 @@
+import {
+  git_issue
+} from "./chunk-VA4M733Q.js";
+import {
+  lane_plan
+} from "./chunk-JUQN3OXG.js";
+import {
+  git_branch
+} from "./chunk-C7CDGSMW.js";
+import {
+  test_declared_logic
+} from "./chunk-7HCPRVMB.js";
+import {
+  changed_paths
+} from "./chunk-AL2H63BP.js";
+
+// scripts/run/ship/run-ship-planned.ts
+import path from "node:path";
+var PRECONDITION = "unplanned";
+var SEPARATOR = "/";
+var NON_CODE_PREFIXES = ["docs/", ".josh/"];
+var CODE_EXTENSIONS = /* @__PURE__ */ new Set([".cjs", ".js", ".mjs", ".sh", ".svelte", ".ts"]);
+function is_planned(claims, file) {
+  return claims.some(
+    (claim) => claim.endsWith(SEPARATOR) ? file.startsWith(claim) : claim === file
+  );
+}
+function is_code(file) {
+  return CODE_EXTENSIONS.has(path.extname(file)) && NON_CODE_PREFIXES.every((prefix) => !file.startsWith(prefix));
+}
+function unplanned_of(claims, changed) {
+  return test_declared_logic.runtime_files(changed).filter((file) => is_code(file) && !is_planned(claims, file));
+}
+function problem_text(issue, claims, files) {
+  const replan = ["pnpm josh lane:plan", issue, ...claims, ...files].join(" ");
+  return `unplanned: ${files.join(", ")} \u2014 the lane's lane:plan record does not list these code files. In scope: run \`${replan}\` and comment the reason on the Issue in one line, then re-detach; if it answers \`yield\` or \`split\`, follow what it prints instead. Out of scope: revert the change and file it with \`pnpm josh issue:file\`.`;
+}
+function held_claims(plan) {
+  return plan?.yielded === true ? void 0 : plan?.paths;
+}
+async function unplanned() {
+  const issue = git_issue.branch_number(await git_branch.current());
+  if (issue === void 0) return void 0;
+  const claims = held_claims(lane_plan.read(Number(issue), process.cwd()));
+  if (claims === void 0) return void 0;
+  const files = unplanned_of(claims, await changed_paths.read_changed_paths(false));
+  if (files.length === 0) return void 0;
+  return { issue: Number(issue), files, text: problem_text(issue, claims, files) };
+}
+async function problems() {
+  const found = await unplanned();
+  return found === void 0 ? [] : [found.text];
+}
+var run_ship_planned = { PRECONDITION, problems, unplanned, unplanned_of };
+
+export {
+  run_ship_planned
+};