@joshuafolkken/kit 1.3044.0 → 1.3099.0

package/dist/commands/chunk-EHPTXSAT.js

@@ -0,0 +1,315 @@
+import {
+  input_fingerprint
+} from "./chunk-GA2YSPFH.js";
+import {
+  lint_related_scope
+} from "./chunk-DLHH3MLS.js";
+import {
+  toolchain_inputs
+} from "./chunk-TUIFS5E7.js";
+import {
+  gate_labels
+} from "./chunk-WQ6FS544.js";
+import {
+  PROJECT_ROOT
+} from "./chunk-3CCGKX7Y.js";
+
+// scripts/gate/verification-inputs.ts
+import { readFileSync as readFileSync2 } from "node:fs";
+import path3 from "node:path";
+
+// eslint/config-fingerprint.js
+import { dirname as __josh_dirname } from "node:path";
+import { fileURLToPath as __josh_file_path } from "node:url";
+import { createHash } from "node:crypto";
+import { readFileSync, realpathSync, statSync } from "node:fs";
+import { createRequire } from "node:module";
+import path from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { resolve } from "import-meta-resolve";
+import ts from "typescript";
+var __josh_meta = import.meta;
+var __josh_source_url = new URL("../../eslint/config-fingerprint.js", __josh_meta.url).href;
+var __josh_source_filename = __josh_file_path(__josh_source_url);
+var __josh_source_dirname = __josh_dirname(__josh_source_filename);
+var HASH_ALGORITHM = "sha256";
+var FINGERPRINT_LENGTH = 32;
+var SETTINGS_KEY = "kit_config_fingerprint";
+var PRESET_DIRECTORY = path.dirname(fileURLToPath(__josh_source_url));
+var PRESET_ENTRY = "base.js";
+var MODULE_EXTENSIONS = [".js", ".mjs", ".cjs", ".ts", ".mts", ".cts"];
+var CONFIG_ENTRY_NAMES = MODULE_EXTENSIONS.map((extension) => `eslint.config${extension}`);
+function is_file(file) {
+  return statSync(file, { throwIfNoEntry: false })?.isFile() === true;
+}
+function module_candidates(target) {
+  const typed = target.replace(/\.([cm]?)js$/u, ".$1ts");
+  const bare = MODULE_EXTENSIONS.map((extension) => `${target}${extension}`);
+  const indexes = MODULE_EXTENSIONS.map((extension) => path.join(target, `index${extension}`));
+  return [target, typed, ...bare, ...indexes];
+}
+function resolve_module(target) {
+  return module_candidates(target).find((candidate) => is_file(candidate));
+}
+function is_inside(relative_path) {
+  return relative_path !== "" && !relative_path.startsWith("..") && !path.isAbsolute(relative_path);
+}
+function is_local_module(target) {
+  return path.isAbsolute(target) && (!target.split(path.sep).includes("node_modules") || is_inside(path.relative(PRESET_DIRECTORY, target)));
+}
+function keep_path_spelling(file, target) {
+  const directory = path.dirname(file);
+  const relative = path.relative(realpathSync(directory), target);
+  return path.resolve(directory, relative);
+}
+function resolve_es_module(specifier, file) {
+  const url = resolve(specifier, pathToFileURL(file).href);
+  return url.startsWith("file:") ? fileURLToPath(url) : "";
+}
+function resolve_commonjs_module(specifier, file) {
+  return createRequire(file).resolve(specifier);
+}
+function resolve_package_import(file, specifier, resolver) {
+  try {
+    const target = resolver(specifier, file);
+    return is_local_module(target) ? [keep_path_spelling(file, target)] : [];
+  } catch {
+    return [];
+  }
+}
+function resolve_import(file, specifier) {
+  const relative = specifier.startsWith(".") ? [resolve_module(path.resolve(path.dirname(file), specifier))] : [];
+  return [
+    ...relative,
+    ...resolve_package_import(file, specifier, resolve_es_module),
+    ...resolve_package_import(file, specifier, resolve_commonjs_module)
+  ];
+}
+function list_imports(file) {
+  const source = readFileSync(file, "utf8");
+  return ts.preProcessFile(source, true, true).importedFiles.flatMap((entry) => resolve_import(file, entry.fileName)).filter((resolved) => resolved !== void 0);
+}
+function visit_module(file, reached, pending) {
+  if (reached.has(file) || !is_file(file)) return;
+  reached.add(file);
+  pending.push(...list_imports(file));
+}
+function list_reachable_modules(entries) {
+  const reached = /* @__PURE__ */ new Set();
+  const pending = [...entries];
+  while (pending.length > 0) visit_module(pending.pop(), reached, pending);
+  return reached;
+}
+function list_config_entries(project_root) {
+  return CONFIG_ENTRY_NAMES.map((name) => path.join(project_root, name)).filter(
+    (file) => is_file(file)
+  );
+}
+function default_entries(directory, project_root) {
+  const project_entries = project_root === void 0 ? [] : list_config_entries(project_root);
+  return [path.join(directory, PRESET_ENTRY), ...project_entries];
+}
+function compare_source_names(left, right) {
+  if (left === right) return 0;
+  return left < right ? -1 : 1;
+}
+function list_config_sources(directory, entries) {
+  return [...list_reachable_modules(entries)].map((file) => path.relative(directory, file)).filter((relative_path) => is_inside(relative_path)).map((relative_path) => relative_path.split(path.sep).join("/")).toSorted(compare_source_names);
+}
+function compute_config_fingerprint(directory = PRESET_DIRECTORY, entries = default_entries(directory)) {
+  const digest = createHash(HASH_ALGORITHM);
+  for (const relative_path of list_config_sources(directory, entries)) {
+    digest.update(`${relative_path}\0`);
+    digest.update(readFileSync(path.join(directory, relative_path)));
+    digest.update("\0");
+  }
+  return digest.digest("hex").slice(0, FINGERPRINT_LENGTH);
+}
+function create_config_fingerprint_block(project_root) {
+  const entries = default_entries(PRESET_DIRECTORY, project_root);
+  return { settings: { [SETTINGS_KEY]: compute_config_fingerprint(PRESET_DIRECTORY, entries) } };
+}
+var config_fingerprint = {
+  SETTINGS_KEY,
+  compute_config_fingerprint,
+  create_config_fingerprint_block,
+  list_config_entries,
+  list_reachable_modules
+};
+
+// scripts/test/test-runner-config.ts
+import path2 from "node:path";
+var PREFIXES = ["vitest.config.", "vitest.workspace.", "vite.config."];
+function is_config(relative) {
+  if (path2.dirname(relative) !== ".") return false;
+  return PREFIXES.some((prefix) => relative.startsWith(prefix));
+}
+var test_runner_config = { is_config, PREFIXES };
+
+// scripts/gate/verification-inputs.ts
+var GIT_IGNORE = ".gitignore";
+var PRETTIER_IGNORE = ".prettierignore";
+var PRETTIER_IGNORE_FILES = [GIT_IGNORE, PRETTIER_IGNORE];
+var MANIFEST = "package.json";
+var TOOLCHAIN_FILES = /* @__PURE__ */ new Set([
+  ...toolchain_inputs.PACKAGE_FILES.map((relative) => path3.basename(relative)),
+  ".editorconfig",
+  ...PRETTIER_IGNORE_FILES
+]);
+var PRETTIER_CONFIG_PREFIX = ".prettierrc";
+var COMPILER_CONFIG_PREFIXES = ["tsconfig", "svelte.config."];
+var TEST_CONFIG_PREFIXES = [...COMPILER_CONFIG_PREFIXES, ...test_runner_config.PREFIXES];
+var LINT_CONFIG_PREFIXES = ["eslint.config.", "prettier.config.", ...COMPILER_CONFIG_PREFIXES];
+var LINT_CONFIG_DIRECTORIES = /* @__PURE__ */ new Set(["prettier", "tsconfig"]);
+var SOURCE_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".ts",
+  ".tsx",
+  ".mts",
+  ".cts",
+  ".js",
+  ".jsx",
+  ".mjs",
+  ".cjs",
+  ".svelte",
+  ".vue",
+  ".json",
+  ".jsonc"
+]);
+var MARKDOWN_EXTENSION = ".md";
+var COMMON_ENV = ["NODE_ENV"];
+var ABSENT = "absent";
+function is_source(relative) {
+  return SOURCE_EXTENSIONS.has(path3.extname(relative));
+}
+async function is_lint_input(relative, is_ignored) {
+  if (is_source(relative)) return true;
+  if (!lint_related_scope.is_lintable(relative)) return false;
+  return !await is_ignored(relative);
+}
+async function is_source_input(relative) {
+  return is_source(relative);
+}
+async function is_metrics_input(relative) {
+  return is_source(relative) || path3.extname(relative) === MARKDOWN_EXTENSION;
+}
+function configures_toolchain(relative) {
+  const name = path3.basename(relative);
+  return TOOLCHAIN_FILES.has(name) || name.startsWith(PRETTIER_CONFIG_PREFIX);
+}
+function names_any(relative, prefixes) {
+  const name = path3.basename(relative);
+  return configures_toolchain(relative) || prefixes.some((prefix) => name.startsWith(prefix));
+}
+function configures_compiler(relative) {
+  return names_any(relative, COMPILER_CONFIG_PREFIXES);
+}
+function configures_tests(relative) {
+  return names_any(relative, TEST_CONFIG_PREFIXES);
+}
+function read_lint_config_modules(root) {
+  const entries = config_fingerprint.list_config_entries(root);
+  const modules = [...config_fingerprint.list_reachable_modules(entries)];
+  return new Set(modules.map((file) => path3.relative(root, file).split(path3.sep).join("/")));
+}
+var lint_config_modules_by_root = /* @__PURE__ */ new Map();
+function lint_config_modules(root) {
+  const cached = lint_config_modules_by_root.get(root);
+  if (cached !== void 0) return cached;
+  const modules = read_lint_config_modules(root);
+  lint_config_modules_by_root.set(root, modules);
+  return modules;
+}
+function configures_lint(relative, root) {
+  const [top = ""] = relative.split("/", 1);
+  if (LINT_CONFIG_DIRECTORIES.has(top) || names_any(relative, LINT_CONFIG_PREFIXES)) return true;
+  return lint_config_modules(root).has(relative);
+}
+var LINT = {
+  is_input: is_lint_input,
+  reads: "matched",
+  is_config: configures_lint,
+  tools: ["prettier", "eslint", "typescript"],
+  env: COMMON_ENV
+};
+var UNIT = {
+  is_input: void 0,
+  reads: "recorded",
+  is_config: configures_tests,
+  tools: ["vitest", "typescript"],
+  env: [...COMMON_ENV, "TZ"]
+};
+function compiled(is_input) {
+  return {
+    is_input,
+    reads: "matched",
+    is_config: configures_compiler,
+    tools: ["typescript"],
+    env: COMMON_ENV
+  };
+}
+async function is_any_file() {
+  return true;
+}
+var SPELLING = {
+  is_input: is_any_file,
+  reads: "matched",
+  is_config: configures_toolchain,
+  tools: ["cspell"],
+  env: COMMON_ENV
+};
+var DECLARATIONS = /* @__PURE__ */ new Map([
+  [gate_labels.LINT_LABEL, LINT],
+  [gate_labels.SPELL_CHECK_LABEL, SPELLING],
+  [gate_labels.TYPE_CHECK_LABEL, compiled(is_source_input)],
+  [gate_labels.EXPORTS_LABEL, compiled(is_source_input)],
+  [gate_labels.METRICS_LABEL, compiled(is_metrics_input)],
+  [gate_labels.UNIT_LABEL, UNIT]
+]);
+function declaration_of(label) {
+  return DECLARATIONS.get(label);
+}
+function is_declared(label) {
+  return DECLARATIONS.has(label);
+}
+function configures(label, relatives, root = PROJECT_ROOT) {
+  const declaration = DECLARATIONS.get(label);
+  return declaration === void 0 || relatives.some((relative) => declaration.is_config(relative, root));
+}
+function tool_version(root, tool) {
+  try {
+    const manifest = JSON.parse(
+      readFileSync2(path3.join(root, "node_modules", tool, MANIFEST), "utf8")
+    );
+    return typeof manifest === "object" && manifest !== null && "version" in manifest ? String(manifest.version) : ABSENT;
+  } catch {
+    return ABSENT;
+  }
+}
+function entries_of(declaration, root, environment) {
+  return [
+    ...declaration.tools.map((tool) => `tool:${tool}=${tool_version(root, tool)}`),
+    ...declaration.env.map((name) => `env:${name}=${environment[name] ?? ABSENT}`)
+  ];
+}
+function fingerprint(labels, root = PROJECT_ROOT, environment = process.env) {
+  const declarations = labels.flatMap((label) => DECLARATIONS.get(label) ?? []);
+  const entries = new Set(
+    declarations.flatMap((declaration) => entries_of(declaration, root, environment))
+  );
+  return input_fingerprint.of_entries(entries);
+}
+var DECLARED_LABELS = [...DECLARATIONS.keys()];
+var verification_inputs = {
+  configures,
+  declaration_of,
+  DECLARED_LABELS,
+  fingerprint,
+  is_declared,
+  PRETTIER_IGNORE_FILES
+};
+
+export {
+  config_fingerprint,
+  test_runner_config,
+  verification_inputs
+};

package/dist/commands/chunk-EHVEWJQ4.js

@@ -0,0 +1,33 @@
+import {
+  lane_cache
+} from "./chunk-LEB2VP7F.js";
+import {
+  lane_registry
+} from "./chunk-NEOCCN6D.js";
+
+// scripts/lane/lane-cache-run.ts
+import path from "node:path";
+async function resolve_main_root() {
+  try {
+    return await lane_registry.main_repository_root();
+  } catch {
+    return void 0;
+  }
+}
+async function run(cache_file, work, current_root = process.cwd()) {
+  const main_root = await resolve_main_root();
+  if (main_root === void 0 || path.resolve(current_root) === path.resolve(main_root)) {
+    return await work();
+  }
+  lane_cache.sync_cache(main_root, current_root, cache_file);
+  try {
+    return await work();
+  } finally {
+    lane_cache.sync_cache(current_root, main_root, cache_file);
+  }
+}
+var lane_cache_run = { run };
+
+export {
+  lane_cache_run
+};

package/dist/commands/chunk-EMFSPPMH.js

@@ -0,0 +1,98 @@
+import {
+  NONE,
+  issue_release_cli
+} from "./chunk-3U6A5WON.js";
+import {
+  git_followup_pending
+} from "./chunk-2SA3W4JF.js";
+import {
+  release_plan
+} from "./chunk-RGRLLF2J.js";
+import {
+  git_gh_repo
+} from "./chunk-CTXJVMHW.js";
+import {
+  path_decision
+} from "./chunk-JI2EGXZX.js";
+import {
+  session_cite
+} from "./chunk-22DVQCP6.js";
+
+// scripts/release/release-request.ts
+var UNKNOWN = "unknown";
+var RELEASE_COMMAND = "run `pnpm josh release` on the default branch of the primary checkout";
+function request_of(open, target) {
+  if (open === void 0) return { release_issue: UNKNOWN, request: `request: ${RELEASE_COMMAND}` };
+  if (open === NONE) return { release_issue: NONE, request: `request: ${RELEASE_COMMAND}` };
+  const cite = session_cite.issue(open, void 0, target);
+  return { release_issue: cite, request: `request: ${RELEASE_COMMAND} \u2014 it closes ${cite}` };
+}
+async function read() {
+  const target = await git_gh_repo.repo_get_name_with_owner();
+  if (target === void 0) return request_of(void 0, "");
+  return request_of(await issue_release_cli.find_open(target), target);
+}
+var release_request = { read, request_of, RELEASE_COMMAND, UNKNOWN };
+
+// scripts/release/release-scope-cli.ts
+var USAGE = "Usage: josh release:scope [--json]";
+var JSON_KEY = "scope";
+var KNOWN_FLAGS = [path_decision.JSON_FLAG];
+var REQUIRED_SCOPE = "required";
+var SKIPPED_SCOPE = "skip";
+var UNKNOWN_SCOPE = "unknown";
+var SUCCESS_EXIT_CODE = 0;
+var FAILURE_EXIT_CODE = 1;
+var NOTHING_PENDING_REASON = "main has taken no merge since the version last changed";
+var RELEASE_HINT = release_request.RELEASE_COMMAND;
+var UNKNOWN_REASON = "the unreleased-merge count could not be read \u2014 report unknown, never skip";
+function decide(pending) {
+  if (pending === void 0) return { scope: UNKNOWN_SCOPE, reason: UNKNOWN_REASON };
+  const line = release_plan.format_pending_line(pending);
+  if (pending === 0) return { scope: SKIPPED_SCOPE, reason: `${line} \u2014 ${NOTHING_PENDING_REASON}` };
+  return { scope: REQUIRED_SCOPE, reason: `${line} \u2014 ${RELEASE_HINT}` };
+}
+function print_required(decision, request, is_json) {
+  if (is_json) {
+    console.info(
+      JSON.stringify({ [JSON_KEY]: decision.scope, reason: decision.reason, ...request })
+    );
+    return;
+  }
+  path_decision.print_decision(JSON_KEY, decision.scope, decision.reason, is_json);
+  console.error(`release_issue: ${request.release_issue}`);
+  console.error(request.request);
+}
+async function print_scope(decision, is_json) {
+  if (decision.scope === REQUIRED_SCOPE) {
+    print_required(decision, await release_request.read(), is_json);
+    return;
+  }
+  path_decision.print_decision(JSON_KEY, decision.scope, decision.reason, is_json);
+}
+async function run(argv) {
+  if (path_decision.has_unknown_flag(argv, KNOWN_FLAGS)) {
+    console.error(USAGE);
+    return FAILURE_EXIT_CODE;
+  }
+  const decision = decide(await git_followup_pending.read_pending({}));
+  const is_json = argv.includes(path_decision.JSON_FLAG);
+  await print_scope(decision, is_json);
+  return SUCCESS_EXIT_CODE;
+}
+var release_scope_cli = {
+  decide,
+  run,
+  JSON_KEY,
+  NOTHING_PENDING_REASON,
+  RELEASE_HINT,
+  REQUIRED_SCOPE,
+  SKIPPED_SCOPE,
+  UNKNOWN_REASON,
+  UNKNOWN_SCOPE,
+  USAGE
+};
+
+export {
+  release_scope_cli
+};

package/dist/commands/chunk-EPICTV2P.js

@@ -0,0 +1,46 @@
+import {
+  issue_evidence_exit
+} from "./chunk-UUA63LCI.js";
+import {
+  epic_close
+} from "./chunk-FT33ZCSB.js";
+import {
+  git_gh_command
+} from "./chunk-NRULNBYI.js";
+import {
+  MEASURED_LABEL,
+  MEASURED_UNMET_LABEL
+} from "./chunk-QQBMVC5W.js";
+import {
+  session_cite
+} from "./chunk-22DVQCP6.js";
+
+// scripts/issue/issue-measured-close.ts
+async function apply_label(issue_number, label = MEASURED_LABEL) {
+  const write = await git_gh_command.issue_apply_label(issue_number, label);
+  if (!write.is_applied) console.error(`${label} not applied: ${write.reason}`);
+  return write.is_applied;
+}
+async function close_issue(issue_number) {
+  const is_closed = await git_gh_command.issue_close(issue_number, void 0);
+  if (is_closed) await epic_close.close_completed_epics({ issue_number, is_merged: true });
+  else console.error(`Issue ${session_cite.issue(issue_number)} not closed`);
+  return is_closed;
+}
+async function label_and_close(issue_number) {
+  return await apply_label(issue_number) && await close_issue(issue_number);
+}
+async function mark_unmet_and_close(issue_number) {
+  return await apply_label(issue_number, MEASURED_UNMET_LABEL) && await label_and_close(issue_number);
+}
+var COMMAND = "issue:measured";
+var MEASURED_EXIT = { command: COMMAND, finish: label_and_close };
+var MEASURED_UNMET_EXIT = { command: COMMAND, finish: mark_unmet_and_close };
+async function close(issue_number, evidence) {
+  return await issue_evidence_exit.write({ issue_number, evidence }, MEASURED_EXIT);
+}
+var issue_measured_close = { MEASURED_EXIT, MEASURED_UNMET_EXIT, close };
+
+export {
+  issue_measured_close
+};

package/dist/commands/chunk-ES42XPAD.js

@@ -0,0 +1,123 @@
+import {
+  lane_report
+} from "./chunk-D6CF5QGM.js";
+import {
+  epic_busy
+} from "./chunk-6LDEZFYR.js";
+import {
+  run_preflight
+} from "./chunk-GAVSK6P6.js";
+import {
+  run_progress_clock
+} from "./chunk-3YT3RCSI.js";
+import {
+  lane_registry
+} from "./chunk-NEOCCN6D.js";
+import {
+  run_liveness
+} from "./chunk-DHJRFBKO.js";
+import {
+  run_hold
+} from "./chunk-F5N2QIFD.js";
+import {
+  run_carry
+} from "./chunk-DS53UUDH.js";
+import {
+  git_command
+} from "./chunk-IXZZSST7.js";
+
+// scripts/run/progress/run-progress-read.ts
+import { loadavg } from "node:os";
+var { mark, parse_stamp, read_last_report } = run_progress_clock;
+var FIRST_LOAD_AVERAGE = 0;
+var IDLE_READ = { kind: "idle" };
+var UNREADABLE_READ = { kind: "unreadable" };
+async function worktree_git_directory() {
+  const [git_directory] = await git_command.git_directories();
+  return git_directory;
+}
+async function stamp_target() {
+  return run_progress_clock.stamp_target_of(await worktree_git_directory());
+}
+async function log_target() {
+  return run_progress_clock.log_path_of(await stamp_target());
+}
+async function live_target() {
+  return run_progress_clock.life_target_of(await worktree_git_directory());
+}
+function to_labels(issue) {
+  return (issue.labels ?? []).map((label) => label.name);
+}
+async function to_child(issue) {
+  const number = String(issue.number);
+  const child = await run_preflight.read_child_state(number);
+  return { issue: number, title: issue.title, labels: to_labels(issue), pr_state: child.pr_state };
+}
+async function read_children(repo) {
+  const read = await epic_busy.read_repository(repo);
+  if (read.kind === "idle") return [];
+  if (read.kind !== "busy") return void 0;
+  return await Promise.all(read.issues.map(async (issue) => await to_child(issue)));
+}
+async function read_lanes() {
+  const lanes = await lane_registry.list_lanes();
+  return lanes.map((lane) => ({ issue: lane.issue, state: lane_report.lane_state(lane) }));
+}
+function is_mtime(value) {
+  return value !== void 0;
+}
+function read_record_age(paths, now_ms) {
+  const times = paths.map((output_path) => run_liveness.sample_output(output_path)?.mtime_ms).filter(is_mtime);
+  if (times.length === 0) return void 0;
+  return now_ms - Math.max(...times);
+}
+function is_hold_present(read) {
+  return read.kind === "held" || read.kind === "stale";
+}
+function is_carry_present(read) {
+  return read.kind === "carried";
+}
+function hold_present(worktree) {
+  return worktree !== void 0 && is_hold_present(run_hold.read_hold(run_hold.hold_path(worktree)));
+}
+function carry_present(repository) {
+  if (repository === void 0) return false;
+  return is_carry_present(run_carry.read_carry(run_carry.carry_path(repository)));
+}
+async function has_run_record() {
+  const [worktree, repository] = await git_command.git_directories();
+  return hold_present(worktree) || carry_present(repository);
+}
+async function has_run_started(lanes) {
+  return lanes.length > 0 || await has_run_record();
+}
+async function read_observations(request) {
+  const [children, lanes] = await Promise.all([read_children(request.repo), read_lanes()]);
+  if (children === void 0) return UNREADABLE_READ;
+  if (children.length === 0 && !await has_run_started(lanes)) return IDLE_READ;
+  const observations = {
+    repo: request.repo,
+    children,
+    lanes,
+    load_average: loadavg()[FIRST_LOAD_AVERAGE] ?? 0,
+    record_age_ms: read_record_age(request.output_paths, request.now_ms)
+  };
+  return { kind: "observed", observations };
+}
+var run_progress_read = {
+  has_run_started,
+  live_target,
+  log_target,
+  mark,
+  parse_stamp,
+  read_children,
+  read_last_report,
+  read_lanes,
+  read_observations,
+  read_record_age,
+  stamp_target
+};
+
+export {
+  run_progress_read
+};