@joshuafolkken/kit 1.3044.0 → 1.3099.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-3LUPGBW4.js

@@ -0,0 +1,137 @@
+import {
+  lane_implement_signals
+} from "./chunk-CNL3SLM6.js";
+import {
+  run_event_step
+} from "./chunk-X4LYH6Q4.js";
+import {
+  run_hold_cli
+} from "./chunk-YD7XK2TX.js";
+import {
+  lane_breakdown_implement,
+  lane_transcript_stats
+} from "./chunk-A3JYZWBS.js";
+import {
+  lane_plan
+} from "./chunk-MDGPJOLK.js";
+import {
+  run_stage
+} from "./chunk-UWLLZQJB.js";
+import {
+  run_step
+} from "./chunk-F4YMLVWN.js";
+import {
+  run_event_stream_emit
+} from "./chunk-26JL4UU4.js";
+import {
+  run_event_stream
+} from "./chunk-KGSEWOKI.js";
+
+// scripts/run/entry/run-entry.ts
+var SUMMARY_PREFIX = "entry #";
+var SUMMARY_DASH = " \u2014 ";
+var FIELD_SEPARATOR = " \xB7 ";
+var HOLD_LABEL = "hold: ";
+var COST_LABEL = "cost: ";
+var VERDICT_LABEL = "verdict: ";
+var SECTION_SEPARATOR = "\n\n";
+var COST_UNDER = "under";
+var COST_OVER = "over";
+var COST_SKIPPED = "skipped";
+var NO_VERDICT = "-";
+var GATE_VERDICT = "gate";
+var SUCCESS_EXIT_CODE = 0;
+var FAILURE_EXIT_CODE = 1;
+function summary(parts) {
+  const fields = [
+    `${HOLD_LABEL}${parts.hold}`,
+    `${COST_LABEL}${parts.cost}`,
+    `${VERDICT_LABEL}${parts.verdict}`
+  ];
+  return `${SUMMARY_PREFIX}${parts.issue_number}${SUMMARY_DASH}${fields.join(FIELD_SEPARATOR)}`;
+}
+function format_report(parts) {
+  return [summary(parts), parts.report].join(SECTION_SEPARATOR);
+}
+function can_proceed(hold, cost) {
+  return hold === run_hold_cli.HOLD_VERDICT && cost !== COST_OVER;
+}
+function exit_code(parts) {
+  const is_ok = can_proceed(parts.hold, parts.cost) && parts.verdict !== run_step.UNKNOWN;
+  return is_ok ? SUCCESS_EXIT_CODE : FAILURE_EXIT_CODE;
+}
+function stage_verdict(state, verdict) {
+  return state === run_stage.PR_OPEN && verdict === run_step.IMPLEMENT ? GATE_VERDICT : verdict;
+}
+var run_entry = {
+  COST_OVER,
+  COST_SKIPPED,
+  COST_UNDER,
+  GATE_VERDICT,
+  NO_VERDICT,
+  exit_code,
+  format_report,
+  can_proceed,
+  summary,
+  stage_verdict
+};
+
+// scripts/lane/lane-implement-signals-record.ts
+function lane_calls(issue) {
+  const directories = lane_breakdown_implement.transcript_directories(issue);
+  return lane_transcript_stats.read_calls(directories, { since_ms: 0, until_ms: Date.now() });
+}
+function planned_paths(issue) {
+  const plan = lane_plan.read(issue, process.cwd());
+  return [...plan?.paths ?? [], ...plan?.cleared_paths ?? []];
+}
+var STREAM_IO = {
+  read: run_event_stream_emit.all_events,
+  emit: run_event_stream_emit.emit,
+  calls: lane_calls,
+  planned: planned_paths,
+  root: process.cwd()
+};
+async function record(issue, io = STREAM_IO) {
+  const number = Number(issue);
+  const events = await io.read();
+  if (events.some((event) => lane_implement_signals.is_signals_of(event, number))) return;
+  const signals = lane_implement_signals.counts_of(io.calls(number), io.planned(number), io.root);
+  await io.emit(lane_implement_signals.KIND, lane_implement_signals.text_of(issue, signals));
+}
+var lane_implement_signals_record = { record };
+
+// scripts/run/run-step-progress.ts
+var { STEP } = run_event_step;
+var KIND = run_event_stream.EVENT_KIND;
+var VERDICT_STEPS = {
+  [run_step.UPDATE_DEPS]: STEP.UPDATE_DEPS,
+  [run_step.IMPLEMENT]: STEP.IMPLEMENT,
+  [run_step.HUMAN_REVIEW]: STEP.IMPLEMENT,
+  [run_entry.GATE_VERDICT]: STEP.GATE
+};
+var EVENT_STEPS = {
+  [KIND.REVIEW_ROUND]: STEP.GATE,
+  [KIND.PR_OPENED]: STEP.FOLLOWUP
+};
+function step_of(line, last_event = "") {
+  return VERDICT_STEPS[line] ?? EVENT_STEPS[last_event];
+}
+var STREAM_IO2 = {
+  step: async (issue, step) => {
+    await run_event_step.record(issue, step);
+  },
+  signals: lane_implement_signals_record.record
+};
+async function record2(issue, line, last_event, io = STREAM_IO2) {
+  const step = step_of(line, last_event);
+  if (step === void 0) return;
+  await io.step(issue, step);
+  if (step === STEP.GATE) await io.signals(issue);
+}
+var run_step_progress = { record: record2, step_of };
+
+export {
+  run_entry,
+  run_step_progress
+};

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
+};