@joshuafolkken/kit 1.3041.0 → 1.3092.0

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

@@ -0,0 +1,74 @@
+import {
+  eslint_cache_dependencies
+} from "./chunk-6O45F6YI.js";
+import {
+  lint_shard
+} from "./chunk-ZECFKW7D.js";
+import {
+  lint_related_scope
+} from "./chunk-DLHH3MLS.js";
+import {
+  project_checks
+} from "./chunk-RO4QEZJO.js";
+import {
+  eslint_heap
+} from "./chunk-CGYDIYHD.js";
+import {
+  direct_launch
+} from "./chunk-SVV4U5AR.js";
+
+// scripts/lint/format-steps.ts
+import { execa } from "execa";
+async function in_order(steps, execute) {
+  const results = [];
+  for (const step of steps) {
+    results.push(await execute(step));
+  }
+  return results;
+}
+async function run_step(step, directory) {
+  const environment = step.check === "eslint" ? { env: eslint_heap.environment(), extendEnv: false } : {};
+  const launch = direct_launch(directory, step.args);
+  const result = await execa(launch.file, [...launch.args], {
+    cwd: directory,
+    stdio: "inherit",
+    reject: false,
+    ...environment
+  });
+  return result.exitCode ?? 1;
+}
+async function run_unless_skipped(step, directory) {
+  const reason = step.check === "eslint" ? project_checks.eslint_skip_reason(directory) : project_checks.prettier_skip_reason(directory);
+  if (reason === void 0) return await run_step(step, directory);
+  console.info(project_checks.skip_notice(step.check, reason));
+  return 0;
+}
+async function run(steps, cache_file, directory) {
+  const results = await in_order(steps, async (step) => {
+    if (step.check !== "eslint") return await run_unless_skipped(step, directory);
+    return await eslint_cache_dependencies.guard(
+      cache_file,
+      async () => await run_unless_skipped(step, directory),
+      directory
+    );
+  });
+  return results.find((code) => code !== 0) ?? 0;
+}
+async function run_scoped(scope, directory) {
+  const files = scope.mode === "all" ? [lint_shard.WHOLE_TREE] : scope.files;
+  const eslint = [...lint_related_scope.eslint_arguments(files), "--fix"];
+  const prettier = lint_related_scope.prettier_arguments(files, void 0, directory);
+  const steps = [{ check: "eslint", args: eslint }];
+  if (scope.mode === "all" || !prettier.includes(project_checks.WEB_FILES)) {
+    steps.push({
+      check: "prettier",
+      args: prettier.map((argument) => argument === "--check" ? "--write" : argument)
+    });
+  }
+  return await run(steps, lint_related_scope.RELATED_CACHES.eslint_file, directory);
+}
+var format_steps = { in_order, run, run_scoped };
+
+export {
+  format_steps
+};

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

@@ -0,0 +1,60 @@
+import {
+  hook_ledger
+} from "./chunk-4NSIW3UB.js";
+import {
+  json_value
+} from "./chunk-HIU2WXB6.js";
+
+// scripts/hooks/hook-demoted.ts
+import { readFileSync } from "node:fs";
+import { mkdir, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { z } from "zod";
+var DEMOTED_FILE = ".josh/hook-demoted.json";
+var NOTICE_HEADER = "\u2139 Demoted rule \u2014 this call ran; do not reissue it. The refusal it would have given:\n";
+var INDENT = "	";
+var rules_schema = z.object({ rules: z.array(z.string()) });
+function read_rules(file = DEMOTED_FILE) {
+  try {
+    return new Set(json_value.parse_with(readFileSync(file, "utf8"), rules_schema)?.rules);
+  } catch {
+    return /* @__PURE__ */ new Set();
+  }
+}
+function rules(environment = process.env) {
+  return environment["VITEST"] === void 0 ? read_rules() : /* @__PURE__ */ new Set();
+}
+async function write_rules(demoted, file = DEMOTED_FILE) {
+  const sorted = [...demoted].toSorted((left, right) => left.localeCompare(right));
+  const body = JSON.stringify({ rules: sorted }, void 0, INDENT);
+  await mkdir(path.dirname(file), { recursive: true });
+  await writeFile(file, `${body}
+`);
+}
+function is_demoted(reason, demoted) {
+  return demoted.has(hook_ledger.rule_of(reason));
+}
+function verdict(reasons, demoted) {
+  const blocking = reasons.find((reason) => !is_demoted(reason, demoted));
+  if (blocking !== void 0) return { reason: blocking, notice: void 0, fault: void 0 };
+  const [first] = reasons;
+  return first === void 0 ? void 0 : { reason: void 0, notice: `${NOTICE_HEADER}${first}`, fault: void 0 };
+}
+function refusal_of(notice, demoted) {
+  if (notice?.startsWith(NOTICE_HEADER) !== true) return void 0;
+  const reason = notice.slice(NOTICE_HEADER.length);
+  return is_demoted(reason, demoted) ? reason : void 0;
+}
+var hook_demoted = {
+  DEMOTED_FILE,
+  NOTICE_HEADER,
+  read_rules,
+  refusal_of,
+  rules,
+  verdict,
+  write_rules
+};
+
+export {
+  hook_demoted
+};

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

@@ -0,0 +1,94 @@
+// scripts/init/distributed-paths.ts
+var KIT_PACKAGE_PATH_PREFIX = "node_modules/@joshuafolkken/kit/";
+var PROMPTS_PACKAGE_PREFIX = `${KIT_PACKAGE_PATH_PREFIX}prompts/`;
+var ESLINT_PACKAGE_PREFIX = `${KIT_PACKAGE_PATH_PREFIX}eslint/`;
+var GITHUB_REPO_BLOB_BASE = "https://github.com/joshuafolkken/kit/blob/main/";
+var GITHUB_REPO_TREE_BASE = "https://github.com/joshuafolkken/kit/tree/main/";
+var CLAUDE_MD_IMPORT_LINE = "@node_modules/@joshuafolkken/kit/dist/CLAUDE.md";
+var OLD_CLAUDE_MD_BOOTSTRAPS = [
+  "> Fresh checkout: if kit is not installed, run `pnpm install` first, then reread this file before doing any other work.",
+  '> Fresh checkout: before `pnpm install`, run `pnpm config get "@joshuafolkken:registry"` from the project root to check the effective registry, including user-level settings. If it points to GitHub Packages, [set up authentication](https://github.com/joshuafolkken/kit/blob/main/docs/authentication.md#1-get-a-token-from-the-gh-cli) first. Then run `pnpm install` and reread this file before doing any other work.'
+];
+var CLAUDE_MD_BOOTSTRAP = '> Fresh checkout: before `pnpm install`, run `pnpm config get "@joshuafolkken:registry"` from the project root to check the effective registry, including user-level settings. If it points to GitHub Packages, [migrate the project to npm](https://github.com/joshuafolkken/kit/blob/main/docs/registry-migration.md) first, or [set up authentication](https://github.com/joshuafolkken/kit/blob/main/docs/authentication.md#1-get-a-token-from-the-gh-cli) while it still installs from there. Then run `pnpm install` and reread this file before doing any other work.';
+function transform_prompt_paths(content) {
+  return content.replaceAll(
+    /`prompts\/([^`*]+)`/gu,
+    (_match, prompt_path) => `\`${PROMPTS_PACKAGE_PREFIX}${prompt_path}\``
+  );
+}
+function transform_eslint_paths(content) {
+  return content.replaceAll(
+    /`eslint\/([^`*]+)`/gu,
+    (_match, eslint_path) => `\`${ESLINT_PACKAGE_PREFIX}${eslint_path}\``
+  );
+}
+function transform_test_file_paths(content) {
+  return content.replaceAll(
+    /`([^`*]+\.(?:test|spec)\.ts)`/gu,
+    (_match, test_path) => `\`${GITHUB_REPO_BLOB_BASE}${test_path}\``
+  );
+}
+function github_url_base(reference_path) {
+  return reference_path.endsWith("/") ? GITHUB_REPO_TREE_BASE : GITHUB_REPO_BLOB_BASE;
+}
+function transform_documentation_paths(content) {
+  return content.replaceAll(
+    /`(docs\/[^`*]*)`/gu,
+    (_match, documentation_path) => `\`${github_url_base(documentation_path)}${documentation_path}\``
+  );
+}
+function transform_distributed_paths(content) {
+  const with_prompts = transform_prompt_paths(content);
+  const with_eslint = transform_eslint_paths(with_prompts);
+  const with_tests = transform_test_file_paths(with_eslint);
+  return transform_documentation_paths(with_tests);
+}
+function replace_old_bootstraps(content) {
+  let updated = content;
+  for (const old of OLD_CLAUDE_MD_BOOTSTRAPS) {
+    updated = updated.replace(old, () => CLAUDE_MD_BOOTSTRAP);
+  }
+  return updated;
+}
+function ensure_claude_md_import(existing) {
+  if (existing === void 0) return `${CLAUDE_MD_BOOTSTRAP}
+
+${CLAUDE_MD_IMPORT_LINE}
+`;
+  const updated = replace_old_bootstraps(existing);
+  if (updated.includes(CLAUDE_MD_IMPORT_LINE)) {
+    if (updated.includes(CLAUDE_MD_BOOTSTRAP)) return updated;
+    return `${CLAUDE_MD_BOOTSTRAP}
+
+${updated}`;
+  }
+  return `${CLAUDE_MD_BOOTSTRAP}
+
+${CLAUDE_MD_IMPORT_LINE}
+
+${updated}`;
+}
+var FULL_CLAUDE_MD_LINES = /* @__PURE__ */ new Set([
+  CLAUDE_MD_BOOTSTRAP,
+  ...OLD_CLAUDE_MD_BOOTSTRAPS,
+  CLAUDE_MD_IMPORT_LINE
+]);
+function remove_claude_md_import(content) {
+  const lines = content.split("\n");
+  return lines.filter((line, index) => {
+    if (FULL_CLAUDE_MD_LINES.has(line)) return false;
+    return line !== "" || !FULL_CLAUDE_MD_LINES.has(lines[index - 1] ?? "");
+  }).join("\n");
+}
+var distributed_paths = {
+  transform_prompt_paths,
+  transform_distributed_paths,
+  ensure_claude_md_import,
+  remove_claude_md_import,
+  CLAUDE_MD_IMPORT_LINE,
+  KIT_PACKAGE_PATH_PREFIX
+};
+
+export {
+  distributed_paths
+};

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

@@ -0,0 +1,19 @@
+import {
+  start_exec
+} from "./chunk-5KSJEWXR.js";
+
+// scripts/init/initial-commit.ts
+var DEFAULT_BRANCH = "main";
+function create_repository(root) {
+  start_exec.git_run(["init", `--initial-branch=${DEFAULT_BRANCH}`], root);
+}
+function commit_all(root) {
+  start_exec.git_run(["add", "--all"], root);
+  start_exec.git_run(["commit", "--no-verify", "--message", "Initial commit"], root);
+  start_exec.git_run(["branch", "--move", "--force", DEFAULT_BRANCH], root);
+}
+var initial_commit = { create_repository, commit_all };
+
+export {
+  initial_commit
+};

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

@@ -0,0 +1,173 @@
+import {
+  repository_labels
+} from "./chunk-KKIIY5I5.js";
+import {
+  github_issue_url
+} from "./chunk-S4X5PJV7.js";
+import {
+  git_gh_command
+} from "./chunk-NRULNBYI.js";
+import {
+  MAX_SCANNED,
+  git_gh_issue_list
+} from "./chunk-TEXUEBGE.js";
+import {
+  git_gh_issue_write
+} from "./chunk-4F4KARQN.js";
+import {
+  RELEASE_LABEL
+} from "./chunk-QQBMVC5W.js";
+import {
+  session_cite
+} from "./chunk-22DVQCP6.js";
+import {
+  git_gh_exec
+} from "./chunk-43DU7DYZ.js";
+import {
+  error_text
+} from "./chunk-CDY4NFQG.js";
+import {
+  issue_number_shape
+} from "./chunk-G75GWNNY.js";
+import {
+  cli_flags
+} from "./chunk-2FE3C4PH.js";
+import {
+  json_value
+} from "./chunk-HIU2WXB6.js";
+
+// scripts/issue/issue-release.ts
+function is_listing_row(value) {
+  if (typeof value !== "object" || value === null) return false;
+  return Number.isSafeInteger(Reflect.get(value, "number"));
+}
+function open_release_of(json) {
+  const rows = (json_value.parse_array(json) ?? []).filter((row) => is_listing_row(row));
+  return rows.length === 0 ? void 0 : Math.min(...rows.map((row) => row.number));
+}
+function title_of(repo) {
+  return `Release ${repo} (next version)`;
+}
+function body_of(repo) {
+  return [
+    `Tracks the next release of ${repo}.`,
+    "",
+    "Every Issue this one is blocked by changes something a consumer can use only once it is published. Once they have merged, a person runs `pnpm josh release` in the primary checkout.",
+    "",
+    "`pnpm josh release` closes this Issue once that release is published: the next blocker files a new one, so an open release Issue names only unreleased work.",
+    "",
+    "Every Issue this one blocks needs the published version (`pnpm josh issue:release <N> --wait`); closing this Issue hands each of them back to the backlog.",
+    "",
+    "`auto-ok` is never applied to this Issue by a run; a person may apply it.",
+    ""
+  ].join("\n");
+}
+var RELEASE_LABELS = [RELEASE_LABEL];
+var issue_release = { RELEASE_LABELS, open_release_of, title_of, body_of };
+
+// scripts/issue/issue-release-cli.ts
+var SUCCESS_EXIT_CODE = 0;
+var FAILURE_EXIT_CODE = 1;
+var USAGE = "Usage: josh issue:release <issue-number> [--wait]";
+var NONE = "none";
+var UNKNOWN_REPO_MESSAGE = "Could not read this repository from `git remote` \u2014 check `gh auth status`.";
+var OPTIONS = { wait: { type: "boolean" } };
+async function find_open(target) {
+  const outcome = await git_gh_issue_list.issue_list({
+    json_fields: "number",
+    limit: MAX_SCANNED,
+    label: RELEASE_LABEL,
+    repo: target
+  });
+  if (outcome.json === void 0) return void 0;
+  return issue_release.open_release_of(outcome.json) ?? NONE;
+}
+async function file_release(target) {
+  repository_labels.ensure_labels(target);
+  const request = git_gh_issue_write.issue_create_request({
+    title: issue_release.title_of(target),
+    body: issue_release.body_of(target),
+    labels: issue_release.RELEASE_LABELS,
+    repo: target
+  });
+  try {
+    const url = await git_gh_exec.exec_gh_api(request);
+    const issue_number = Number(github_issue_url.parse(url)?.issue_number) || void 0;
+    if (issue_number === void 0) console.error(`\u2716 the release number is unreadable: ${url}`);
+    return issue_number;
+  } catch (error) {
+    console.error(`\u2716 the release Issue could not be filed: ${error_text.message_of(error)}`);
+    return void 0;
+  }
+}
+async function release_of(target) {
+  const open = await find_open(target);
+  if (open === void 0) {
+    console.error(`\u2716 the open ${RELEASE_LABEL} Issues of ${target} could not be listed`);
+    return void 0;
+  }
+  if (open !== NONE) return { issue_number: open, is_filed: false };
+  const filed = await file_release(target);
+  return filed === void 0 ? void 0 : { issue_number: filed, is_filed: true };
+}
+function release_label_of(release, target) {
+  const how = release.is_filed ? "filed" : "open";
+  return `${session_cite.issue(release.issue_number, void 0, target)} (${how})`;
+}
+function linked_line(release, request, target) {
+  const release_label = release_label_of(release, target);
+  const issue_label = session_cite.issue(request.issue_number, void 0, target);
+  return request.is_wait ? `release: ${issue_label} waits on ${release_label}` : `release: ${release_label} is blocked by ${issue_label}`;
+}
+function unlinked_line(edge, target) {
+  const blocker = session_cite.issue(edge.blocker, void 0, target);
+  return `\u2716 ${blocker} could not be recorded as a blocker of ${session_cite.issue(edge.blocked, void 0, target)}`;
+}
+function edge_of(release, request) {
+  return request.is_wait ? { blocked: request.issue_number, blocker: release.issue_number } : { blocked: release.issue_number, blocker: request.issue_number };
+}
+async function record(request, target) {
+  const release = await release_of(target);
+  if (release === void 0) return false;
+  const edge = edge_of(release, request);
+  const is_linked = await git_gh_issue_write.issue_add_blocked_by(
+    String(edge.blocked),
+    String(edge.blocker)
+  );
+  if (is_linked) console.info(linked_line(release, request, target));
+  else console.error(unlinked_line(edge, target));
+  return is_linked;
+}
+async function link(issue_number, target) {
+  return await record({ issue_number, is_wait: false }, target);
+}
+function issue_number_of(positionals) {
+  const [issue_number, ...rest] = positionals;
+  const is_single = rest.length === 0 && issue_number !== void 0;
+  return is_single && issue_number_shape.ISSUE_NUMBER_PATTERN.test(issue_number) ? Number(issue_number) : void 0;
+}
+function request_of(argv) {
+  const parsed = cli_flags.arguments_of(argv, OPTIONS);
+  const issue_number = issue_number_of(parsed?.positionals ?? []);
+  if (parsed === void 0 || issue_number === void 0) return void 0;
+  return { issue_number, is_wait: parsed.values.wait === true };
+}
+async function run(argv) {
+  const request = request_of(argv);
+  if (request === void 0) {
+    console.error(USAGE);
+    return FAILURE_EXIT_CODE;
+  }
+  const current = await git_gh_command.repo_get_name_with_owner();
+  if (current === void 0) {
+    console.error(UNKNOWN_REPO_MESSAGE);
+    return FAILURE_EXIT_CODE;
+  }
+  return await record(request, current) ? SUCCESS_EXIT_CODE : FAILURE_EXIT_CODE;
+}
+var issue_release_cli = { find_open, link, run };
+
+export {
+  NONE,
+  issue_release_cli
+};

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

@@ -0,0 +1,140 @@
+import {
+  error_text
+} from "./chunk-CDY4NFQG.js";
+import {
+  git_common_directory
+} from "./chunk-JPMAW2VZ.js";
+import {
+  stamp_file
+} from "./chunk-VLN6TSPJ.js";
+import {
+  MS_PER_MINUTE
+} from "./chunk-WPAQUMHC.js";
+import {
+  json_value
+} from "./chunk-HIU2WXB6.js";
+
+// scripts/run/progress/run-progress-clock.ts
+import { z } from "zod";
+var PROGRESS_PREFIX = "josh-run-progress-";
+var LIFE_PREFIX = "josh-run-progress-life-";
+var LOG_SUFFIX = ".log";
+var LOG_KEEP = 12;
+var LOG_STALE_MINUTES = 90;
+var LOG_STALE_MS = LOG_STALE_MINUTES * MS_PER_MINUTE;
+var BLOCK_SEPARATOR = "\n\n";
+var report_stamp_schema = z.object({ reported_at: z.string(), line: z.string().optional() });
+function parse_stamp(raw) {
+  const parsed = report_stamp_schema.safeParse(JSON.parse(raw));
+  if (!parsed.success) return void 0;
+  const reported_at = Date.parse(parsed.data.reported_at);
+  return Number.isNaN(reported_at) ? void 0 : reported_at;
+}
+function read_last_line(target) {
+  const raw = stamp_file.read_stamp_text(target);
+  if (raw === void 0) return void 0;
+  return json_value.parse_with(raw, report_stamp_schema)?.line;
+}
+function read_last_report(target) {
+  const raw = stamp_file.read_stamp_text(target);
+  if (raw === void 0) return void 0;
+  try {
+    return parse_stamp(raw);
+  } catch {
+    return void 0;
+  }
+}
+function log_path_of(target) {
+  return `${target}${LOG_SUFFIX}`;
+}
+function is_log_stale(target, now_ms) {
+  const previous_ms = read_last_report(target);
+  return previous_ms === void 0 || now_ms - previous_ms > LOG_STALE_MS;
+}
+function recent_blocks(log_target, is_fresh) {
+  if (is_fresh) return [];
+  const raw = stamp_file.read_stamp_text(log_target);
+  if (raw === void 0) return [];
+  return raw.split(BLOCK_SEPARATOR).map((block) => block.trimEnd()).filter((block) => block.length > 0);
+}
+function append_line(log_target, reported_at, line, is_fresh) {
+  const block = `${reported_at}
+${line}`;
+  const blocks = [...recent_blocks(log_target, is_fresh), block].slice(-LOG_KEEP);
+  stamp_file.write_text_stamp(log_target, `${blocks.join(BLOCK_SEPARATOR)}
+`);
+}
+function mark(target, now_ms, line) {
+  const reported_at = new Date(now_ms).toISOString();
+  const kept = line ?? read_last_line(target);
+  if (line !== void 0) {
+    append_line(log_path_of(target), reported_at, line, is_log_stale(target, now_ms));
+  }
+  stamp_file.write_stamp(target, kept === void 0 ? { reported_at } : { reported_at, line: kept });
+}
+function stamp_target_of(git_directory) {
+  return stamp_file.stamp_path(PROGRESS_PREFIX, git_directory);
+}
+function life_target_of(git_directory) {
+  return stamp_file.stamp_path(LIFE_PREFIX, git_directory);
+}
+var life_schema = z.object({ alive: z.literal(true), pinged_at: z.string().optional() });
+function begin_life(target) {
+  stamp_file.write_stamp(target, { alive: true, pinged_at: (/* @__PURE__ */ new Date()).toISOString() });
+}
+function ping_life(target) {
+  begin_life(target);
+}
+function parse_pinged_at(raw) {
+  const parsed = life_schema.safeParse(JSON.parse(raw));
+  if (!parsed.success || parsed.data.pinged_at === void 0) return void 0;
+  const pinged_ms = Date.parse(parsed.data.pinged_at);
+  return Number.isNaN(pinged_ms) ? void 0 : pinged_ms;
+}
+function is_life_fresh(target, threshold_ms) {
+  const raw = stamp_file.read_stamp_text(target);
+  if (raw === void 0) return false;
+  try {
+    const pinged_ms = parse_pinged_at(raw);
+    return pinged_ms !== void 0 && Date.now() - pinged_ms < threshold_ms;
+  } catch (error) {
+    error_text.trace_swallowed("run_progress_clock.is_life_fresh", error);
+    return false;
+  }
+}
+function is_life_ended(target) {
+  return stamp_file.read_stamp_text(target) === void 0;
+}
+function end_life(target) {
+  stamp_file.remove_stamp(target);
+}
+function stamp_target_sync() {
+  const directory = git_common_directory.own();
+  return directory === void 0 ? void 0 : stamp_target_of(directory);
+}
+function read_last_report_sync() {
+  const target = stamp_target_sync();
+  return target === void 0 ? void 0 : read_last_report(target);
+}
+var run_progress_clock = {
+  LIFE_PREFIX,
+  LOG_KEEP,
+  LOG_STALE_MS,
+  begin_life,
+  end_life,
+  is_life_ended,
+  is_life_fresh,
+  life_target_of,
+  log_path_of,
+  mark,
+  parse_stamp,
+  ping_life,
+  read_last_line,
+  read_last_report,
+  read_last_report_sync,
+  stamp_target_of
+};
+
+export {
+  run_progress_clock
+};