@joshuafolkken/kit 1.3041.0 → 1.3092.0

package/dist/commands/chunk-RLRIMYXM.js

@@ -0,0 +1,178 @@
+import {
+  lane_install
+} from "./chunk-LKSSQVDA.js";
+import {
+  USAGE_ERROR_EXIT_CODE,
+  composite_arguments
+} from "./chunk-RSSJWMQS.js";
+import {
+  git_worktree
+} from "./chunk-WNBJK6QE.js";
+import {
+  error_text
+} from "./chunk-CDY4NFQG.js";
+import {
+  git_command
+} from "./chunk-IXZZSST7.js";
+import {
+  git_spawn
+} from "./chunk-B5HP6T4L.js";
+
+// scripts/git/gone-branch.ts
+var FIELD_SEPARATOR = "	";
+var GONE_TRACK = "[gone]";
+var BRANCH_NAME = "%(refname:lstrip=2)";
+var RECORD_FORMAT = [BRANCH_NAME, "%(upstream:track)", "%(upstream)", "%(worktreepath)"].join(
+  FIELD_SEPARATOR
+);
+var LOCAL_HEADS = "refs/heads";
+var REMOTE_HEADS = "refs/remotes/";
+var FOR_EACH_REF = "for-each-ref";
+var NAME_FIELD = 0;
+var TRACK_FIELD = 1;
+var UPSTREAM_FIELD = 2;
+var WORKTREE_FIELD = 3;
+function non_empty_lines(output) {
+  return output.split("\n").filter((line) => line.trim() !== "");
+}
+function parse_record(line) {
+  const fields = line.split(FIELD_SEPARATOR);
+  return {
+    name: fields[NAME_FIELD] ?? "",
+    is_gone: fields[TRACK_FIELD] === GONE_TRACK && (fields[UPSTREAM_FIELD] ?? "").startsWith(REMOTE_HEADS),
+    is_checked_out: (fields[WORKTREE_FIELD] ?? "") !== ""
+  };
+}
+function parse_records(output) {
+  return non_empty_lines(output).map((line) => parse_record(line));
+}
+function select_prunable(records, merged, default_branch) {
+  return records.filter((record2) => record2.is_gone && !record2.is_checked_out && merged.has(record2.name)).map((record2) => record2.name).filter((name) => name !== default_branch);
+}
+async function read_candidates(default_branch) {
+  const records = await git_spawn.read([FOR_EACH_REF, `--format=${RECORD_FORMAT}`, LOCAL_HEADS]);
+  const merged = await git_spawn.read([
+    FOR_EACH_REF,
+    `--merged=refs/heads/${default_branch}`,
+    `--format=${BRANCH_NAME}`,
+    LOCAL_HEADS
+  ]);
+  return select_prunable(parse_records(records), new Set(non_empty_lines(merged)), default_branch);
+}
+async function delete_each(names) {
+  const result = { deleted: [], failed: [] };
+  for (const name of names) {
+    try {
+      await git_spawn.read(["branch", "-d", name]);
+      result.deleted.push(name);
+    } catch {
+      result.failed.push(name);
+    }
+  }
+  return result;
+}
+async function prune(default_branch) {
+  await git_spawn.read_remote(["fetch", "--prune"]);
+  return await delete_each(await read_candidates(default_branch));
+}
+var gone_branch = { parse_records, prune, select_prunable };
+
+// scripts/git/lockfile-sync.ts
+import { createHash } from "node:crypto";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import path from "node:path";
+var LOCKFILE_NAME = "pnpm-lock.yaml";
+var RECORD_PATH = path.join("node_modules", ".josh-installed-lock");
+var UP_TO_DATE = { is_installed: true, output: "" };
+function read_text(file_path) {
+  return existsSync(file_path) ? readFileSync(file_path, "utf8") : void 0;
+}
+function digest(content) {
+  return createHash("sha256").update(content).digest("hex");
+}
+function record(directory, lock_digest) {
+  const record_path = path.join(directory, RECORD_PATH);
+  mkdirSync(path.dirname(record_path), { recursive: true });
+  writeFileSync(record_path, lock_digest);
+}
+async function reinstall_if_stale(directory) {
+  const lock = read_text(path.join(directory, LOCKFILE_NAME));
+  if (lock === void 0) return UP_TO_DATE;
+  const lock_digest = digest(lock);
+  if (read_text(path.join(directory, RECORD_PATH)) === lock_digest) return UP_TO_DATE;
+  const result = await lane_install.install_dependencies(directory);
+  if (result.is_installed) record(directory, lock_digest);
+  return result;
+}
+var lockfile_sync = { reinstall_if_stale };
+
+// scripts/git/main-sync.ts
+var SUCCESS_EXIT_CODE = 0;
+var FAILURE_EXIT_CODE = 1;
+var COMMAND_NAME = "main:sync";
+var INSTALL_FAILURE = "node_modules is behind pnpm-lock.yaml and `pnpm install --frozen-lockfile` failed; run `pnpm josh ms` again, or the install here by hand.";
+var LANE_REFUSAL = [
+  `josh ${COMMAND_NAME} cannot run inside a linked work tree.`,
+  "Checking the default branch out here takes it from whichever work tree holds it, and a lane that loses its own branch drops out of `josh lane:list` with its port seat still allocated.",
+  "Run `pnpm josh ms` in the primary checkout instead; a lane is finished with `pnpm josh lane:close <issue-number>`."
+].join("\n");
+function report_prune(result) {
+  if (result.deleted.length > 0) {
+    console.info(`pruned ${String(result.deleted.length)} merged branch(es) whose remote is gone`);
+  }
+  for (const name of result.failed) console.error(`kept ${name}: git branch -d refused it`);
+}
+async function prune_quietly(default_branch) {
+  try {
+    report_prune(await gone_branch.prune(default_branch));
+  } catch (error) {
+    console.error(`branch prune skipped: ${error_text.message_of(error)}`);
+  }
+}
+async function fast_forward_quietly(default_branch) {
+  if (await git_command.branch() === default_branch) return;
+  try {
+    await git_command.fast_forward_local(default_branch);
+  } catch {
+  }
+}
+async function reinstall(root) {
+  const result = await lockfile_sync.reinstall_if_stale(root);
+  if (result.is_installed) return SUCCESS_EXIT_CODE;
+  console.error(`${INSTALL_FAILURE}
+${result.output}`);
+  return FAILURE_EXIT_CODE;
+}
+async function synchronize() {
+  const default_branch = await git_command.get_default_branch();
+  await fast_forward_quietly(default_branch);
+  await git_command.checkout(default_branch);
+  await git_command.pull_fast_forward();
+  await prune_quietly(default_branch);
+  console.info(default_branch);
+  return await reinstall(await git_command.repository_root());
+}
+async function dispatch(argv) {
+  if (argv.length > 0) {
+    console.error(composite_arguments.format_rejection(COMMAND_NAME, []));
+    return USAGE_ERROR_EXIT_CODE;
+  }
+  if (await git_worktree.is_linked()) {
+    console.error(LANE_REFUSAL);
+    return FAILURE_EXIT_CODE;
+  }
+  return await synchronize();
+}
+async function run(argv) {
+  try {
+    return await dispatch(argv);
+  } catch (error) {
+    console.error(error_text.message_of(error));
+    return FAILURE_EXIT_CODE;
+  }
+}
+var main_sync = { run };
+
+export {
+  main_sync
+};

package/dist/commands/chunk-RNB3DQOZ.js

@@ -0,0 +1,70 @@
+import {
+  run_merge_token
+} from "./chunk-TXRWAL63.js";
+import {
+  json_value
+} from "./chunk-HIU2WXB6.js";
+
+// scripts/run/merge/run-merge-driver.ts
+import { z } from "zod";
+
+// scripts/run/merge/run-merge-outcome.ts
+var CHILD_OUTCOMES = [
+  "merged",
+  "withdrawn",
+  "yielded",
+  "human-review",
+  "parked",
+  "split",
+  "cut",
+  "outage",
+  "unauthenticated",
+  "usage-limit",
+  "failed",
+  "unresolved",
+  "shipping"
+];
+var run_merge_outcome = { CHILD_OUTCOMES };
+
+// scripts/run/merge/run-merge-driver.ts
+var COMMAND = "run:merge";
+var DRIVER_FLAG = "--driver";
+var JSON_KEY = "merge";
+var LINE_BREAK = "\n";
+var DEFERRED_OFFER = "deferred";
+var control_schema = z.object({
+  token: z.enum(Object.values(run_merge_token.MERGE_TOKEN)),
+  code: z.number(),
+  is_offer: z.literal(false),
+  outcome: z.enum(run_merge_outcome.CHILD_OUTCOMES),
+  is_parked: z.boolean().optional()
+});
+var offer_schema = z.object({
+  token: z.string(),
+  code: z.number(),
+  is_offer: z.literal(true),
+  outcome: z.enum(run_merge_outcome.CHILD_OUTCOMES),
+  is_parked: z.boolean().optional()
+});
+var printed_schema = z.object({
+  [JSON_KEY]: z.discriminatedUnion("is_offer", [control_schema, offer_schema])
+});
+function argv_of(merge) {
+  const output = merge.output === void 0 ? [] : ["--output", merge.output];
+  return [COMMAND, merge.child, "--owner", merge.owner, DRIVER_FLAG, ...output];
+}
+function print(result) {
+  return JSON.stringify({ [JSON_KEY]: result });
+}
+function printed(argv, result) {
+  return argv.includes(DRIVER_FLAG) ? print(result) : result.token;
+}
+function read(out) {
+  const last = out.trimEnd().split(LINE_BREAK).at(-1) ?? "";
+  return json_value.parse_with(last, printed_schema)?.[JSON_KEY];
+}
+var run_merge_driver = { DEFERRED_OFFER, DRIVER_FLAG, argv_of, print, printed, read };
+
+export {
+  run_merge_driver
+};

package/dist/commands/chunk-RO4QEZJO.js

@@ -0,0 +1,172 @@
+import {
+  doctor_consumer
+} from "./chunk-S4OZJIXD.js";
+import {
+  own_formatter,
+  project_profile
+} from "./chunk-ZB52ZIEA.js";
+import {
+  NOT_USED_MARKER,
+  SKIP_MARKER
+} from "./chunk-IW6NWCSN.js";
+import {
+  find_local_bin_upwards
+} from "./chunk-SVV4U5AR.js";
+import {
+  ancestor_directories,
+  package_manifest
+} from "./chunk-WB4T3VY2.js";
+import {
+  json_value
+} from "./chunk-HIU2WXB6.js";
+
+// scripts/gate/project-checks.ts
+import { existsSync, globSync } from "node:fs";
+import path from "node:path";
+import { z } from "zod";
+var IGNORED_DIRS = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  ".venv",
+  "venv",
+  "target",
+  "dist",
+  "build",
+  ".svelte-kit"
+]);
+var WEB_EXTENSIONS = ["html", "css", "js", "jsx", "mjs", "cjs"];
+var WEB_FILES = `**/*.{${WEB_EXTENSIONS.join(",")}}`;
+var DEFAULT_FORMAT_SCOPE = "auto";
+var SCRIPT_FILES = "**/*.{js,jsx,mjs,cjs,ts,tsx,mts,cts}";
+var TYPE_FILES = "**/*.{ts,tsx,mts,cts}";
+var ESLINT_CONFIGS = [
+  "eslint.config.js",
+  "eslint.config.mjs",
+  "eslint.config.cjs",
+  "eslint.config.ts",
+  "eslint.config.mts",
+  "eslint.config.cts"
+];
+var CSPELL_CONFIGS = [
+  "cspell.config.yaml",
+  "cspell.config.yml",
+  "cspell.config.json",
+  "cspell.config.js",
+  "cspell.config.cjs",
+  "cspell.config.mjs",
+  "cspell.json",
+  "cspell.yaml"
+];
+var TYPE_CONFIGS = ["tsconfig.json", "jsconfig.json"];
+var DEPENDENCY_FIELDS = ["dependencies", "devDependencies"];
+var object_schema = z.record(z.string(), z.unknown());
+function project_root(directory) {
+  return ancestor_directories.nearest(
+    directory,
+    (candidate) => existsSync(package_manifest.manifest_path(candidate))
+  ) ?? directory;
+}
+function is_kit_repository(directory) {
+  return !doctor_consumer.is_kit_consumer(project_root(directory));
+}
+function is_ignored(entry) {
+  return entry.split(/[/\\]/u).some((part) => IGNORED_DIRS.has(part));
+}
+function has_files(directory, pattern) {
+  return globSync(pattern, { cwd: project_root(directory), exclude: is_ignored }).length > 0;
+}
+function has_config(directory, names) {
+  return names.some((name) => existsSync(path.join(project_root(directory), name)));
+}
+function has_bin(directory, bin_name) {
+  return find_local_bin_upwards(directory, bin_name) !== void 0;
+}
+function josh_settings(manifest) {
+  return json_value.is_record(manifest) ? manifest["josh"] : void 0;
+}
+function is_basic_manifest(manifest) {
+  const josh = josh_settings(manifest);
+  if (!json_value.is_record(josh)) return false;
+  return project_profile.parse_profile(josh["profile"]) === "basic";
+}
+function read_manifest(directory) {
+  return package_manifest.read_manifest_if_valid(project_root(directory), z.unknown());
+}
+function is_basic(directory) {
+  return is_basic_manifest(read_manifest(directory));
+}
+function is_declared(directory, package_name) {
+  const manifest = object_schema.safeParse(read_manifest(directory));
+  if (!manifest.success) return false;
+  return DEPENDENCY_FIELDS.some((field) => {
+    const dependencies = object_schema.safeParse(manifest.data[field]);
+    return dependencies.success && Object.hasOwn(dependencies.data, package_name);
+  });
+}
+function missing_tool_reason(directory, package_name, bin_name) {
+  if (has_bin(directory, bin_name) || is_declared(directory, package_name)) return void 0;
+  return `${package_name} is not installed`;
+}
+function skip_notice(check, reason) {
+  return `josh ${check}: ${reason} ${SKIP_MARKER} ${check}, ${NOT_USED_MARKER}.`;
+}
+function ran_notice(check) {
+  return `josh ${check}: ran and reported no problems.`;
+}
+function type_check_skip_reason(directory) {
+  if (!is_basic(directory)) return void 0;
+  if (!has_files(directory, TYPE_FILES)) return "no TypeScript files were found";
+  if (!has_config(directory, TYPE_CONFIGS)) return "no TypeScript configuration was found";
+  return missing_tool_reason(directory, "typescript", "tsc");
+}
+function prettier_skip_reason(directory) {
+  if (!is_basic(directory)) return void 0;
+  const formatter = own_formatter.find_config(project_root(directory));
+  if (formatter !== void 0) return `${formatter} configures the project's own formatter`;
+  if (!has_files(directory, WEB_FILES)) return "no HTML, CSS or JavaScript files were found";
+  return missing_tool_reason(directory, "prettier", "prettier");
+}
+function format_scope(directory) {
+  const manifest = package_manifest.read_manifest_if_valid(
+    project_root(directory),
+    package_manifest.josh_schemas.format
+  );
+  return manifest?.josh?.format ?? DEFAULT_FORMAT_SCOPE;
+}
+function is_web_file(file_path) {
+  return WEB_EXTENSIONS.includes(path.extname(file_path).slice(1));
+}
+function prettier_targets(directory, targets) {
+  if (!is_basic(directory) || format_scope(directory) === "all") return targets;
+  const web_targets = targets.filter((target) => is_web_file(target));
+  return web_targets.length > 0 ? web_targets : [WEB_FILES];
+}
+function eslint_skip_reason(directory) {
+  if (!is_basic(directory)) return void 0;
+  if (!has_files(directory, SCRIPT_FILES)) return "no JavaScript or TypeScript files were found";
+  if (!has_config(directory, ESLINT_CONFIGS)) return "no ESLint configuration was found";
+  return missing_tool_reason(directory, "eslint", "eslint");
+}
+var project_checks = {
+  CSPELL_CONFIGS,
+  ESLINT_CONFIGS,
+  TYPE_FILES,
+  WEB_FILES,
+  eslint_skip_reason,
+  has_bin,
+  has_config,
+  has_files,
+  is_basic,
+  is_kit_repository,
+  prettier_skip_reason,
+  prettier_targets,
+  project_root,
+  ran_notice,
+  read_manifest,
+  skip_notice,
+  type_check_skip_reason
+};
+
+export {
+  project_checks
+};

package/dist/commands/chunk-RS5HBJY6.js

@@ -0,0 +1,161 @@
+import {
+  markdown_section
+} from "./chunk-JZK33TA5.js";
+import {
+  issue_body_keys
+} from "./chunk-KXK2A2HB.js";
+import {
+  BREAKING_CHANGE_LABEL,
+  BUGFIX_LABEL,
+  BUG_LABEL,
+  ENHANCEMENT_LABEL,
+  OTHER_CHANGE_LABEL,
+  RELEASE_CLASSIFICATION_NAMES
+} from "./chunk-QQBMVC5W.js";
+import {
+  git_gh_api_path
+} from "./chunk-RDRN56E4.js";
+import {
+  git_gh_exec
+} from "./chunk-43DU7DYZ.js";
+import {
+  error_text
+} from "./chunk-CDY4NFQG.js";
+
+// scripts/ci/pr-classification.ts
+import { readFileSync } from "node:fs";
+import { z } from "zod";
+var CLASSIFICATION_SET = new Set(RELEASE_CLASSIFICATION_NAMES);
+var DECLARATION_PREFIX = `${issue_body_keys.prefix("release")} `;
+var DECLARATION = new RegExp(`^${DECLARATION_PREFIX}(.+)$`, "gmu");
+var DECLARATION_LINE = new RegExp(
+  String.raw`^(?:${issue_body_keys.prefix_variants("release").join("|")}) .*(?:\n|$)`,
+  "gmu"
+);
+var BACKGROUND_HEADING = issue_body_keys.heading("background");
+var BULLET = "- ";
+var NEWLINE = "\n";
+var DECLARE_COMMAND = "pnpm josh issue:release-class <issue> <label>";
+var DECIDING_LABELS = [ENHANCEMENT_LABEL, BUG_LABEL, BREAKING_CHANGE_LABEL].join(", ");
+var LEGACY_LABELS = /* @__PURE__ */ new Set(["semver-major", "semver-minor"]);
+var LABEL_NAMES_FILTER = ".[].name";
+var LABEL = z.object({ name: z.string() });
+var USER = z.object({ login: z.string() });
+var PULL_REQUEST = z.object({ number: z.number(), user: USER });
+var EVENT = z.object({
+  pull_request: PULL_REQUEST,
+  repository: z.object({ full_name: z.string() })
+});
+function classification_error(labels, author) {
+  const legacy = labels.filter((label) => LEGACY_LABELS.has(label.toLowerCase()));
+  if (legacy.length > 0) return `Remove legacy release labels: ${legacy.join(", ")}`;
+  const selected = labels.filter((label) => CLASSIFICATION_SET.has(label.toLowerCase()));
+  if (selected.length > 1) {
+    return `Choose exactly one release classification; found: ${selected.join(", ")}`;
+  }
+  if (selected.length === 1 || author.endsWith("[bot]")) return void 0;
+  return `Choose one release classification: ${RELEASE_CLASSIFICATION_NAMES.join(", ")}`;
+}
+function declaration(label) {
+  return `${DECLARATION_PREFIX}${label}`;
+}
+function block_end(lines) {
+  const first = lines.findIndex((line) => line.startsWith(BULLET));
+  if (first === -1) return 0;
+  const run = lines.slice(first).findIndex((line) => !line.startsWith(BULLET));
+  return run === -1 ? lines.length : first + run;
+}
+function append_line(before, line) {
+  const separator = before === "" || before.endsWith(NEWLINE) ? "" : NEWLINE;
+  return `${before}${separator}${line}${NEWLINE}`;
+}
+function insert_line(section, line) {
+  const lines = section.split(/(?<=\n)/u);
+  const at = block_end(lines);
+  return `${append_line(lines.slice(0, at).join(""), line)}${lines.slice(at).join("")}`;
+}
+function with_declaration(body, label) {
+  const stripped = body.replaceAll(DECLARATION_LINE, "");
+  if (!markdown_section.has_line(stripped, BACKGROUND_HEADING)) {
+    return append_line(stripped, declaration(label));
+  }
+  return markdown_section.map_section(
+    stripped.endsWith(NEWLINE) ? stripped : `${stripped}${NEWLINE}`,
+    (line) => line.trim() === BACKGROUND_HEADING,
+    (section) => insert_line(section, declaration(label))
+  );
+}
+function is_classification(value) {
+  return CLASSIFICATION_SET.has(value);
+}
+function release_candidates(candidates) {
+  if (!candidates.includes(BREAKING_CHANGE_LABEL)) return candidates;
+  return candidates.filter((candidate) => candidate !== ENHANCEMENT_LABEL);
+}
+function issue_candidates(labels, body) {
+  const names = labels.map((label) => label.toLowerCase());
+  const declared = [
+    ...markdown_section.canonical_lines(body).join(NEWLINE).matchAll(DECLARATION)
+  ].map((match) => match[1] ?? "");
+  const candidates = [...release_candidates([...names, ...declared].filter(is_classification))];
+  const unknown = declared.filter((value) => !is_classification(value));
+  if (unknown.length > 0) throw new Error(`Unknown release classification: ${unknown.join(", ")}`);
+  if (names.includes(BUG_LABEL) && !candidates.includes(BREAKING_CHANGE_LABEL)) {
+    candidates.push(BUGFIX_LABEL);
+  }
+  return candidates;
+}
+function selection_hint(selected) {
+  if (selected.length > 1) return `found: ${selected.join(", ")}. Keep one.`;
+  return `found: none. Add "${DECLARATION_PREFIX}<label>" to the Issue body \u2014 on a filed Issue, \`${DECLARE_COMMAND}\` writes it; a non-defect Issue with none of ${DECIDING_LABELS} takes ${OTHER_CHANGE_LABEL} as a Tier A choice.`;
+}
+function select_classification(labels, body) {
+  const selected = [...new Set(issue_candidates(labels, body))];
+  const [label] = selected;
+  if (label === void 0 || selected.length > 1) {
+    throw new Error(
+      `Choose one release classification before opening the PR: ${RELEASE_CLASSIFICATION_NAMES.join(", ")}; ${selection_hint(selected)}`
+    );
+  }
+  return label;
+}
+function select_issue_classification(issue_json) {
+  const issue = z.object({ labels: z.array(LABEL), body: z.string().nullable() }).parse(JSON.parse(issue_json));
+  return select_classification(
+    issue.labels.map((label) => label.name),
+    issue.body ?? ""
+  );
+}
+function fetch_current_labels(repository, pull_number) {
+  const path = git_gh_api_path.issue_labels_api_path(String(pull_number), repository);
+  try {
+    const names = git_gh_exec.exec_gh_api_sync({
+      path,
+      should_paginate: true,
+      jq_filter: LABEL_NAMES_FILTER
+    });
+    return names.split("\n").filter((name) => name !== "");
+  } catch (error) {
+    const detail = error_text.message_of(error);
+    throw new Error(`Could not read the pull request labels: ${detail}`, { cause: error });
+  }
+}
+function check_event(event_path, read_labels = fetch_current_labels) {
+  const event = EVENT.parse(JSON.parse(readFileSync(event_path, "utf8")));
+  const labels = read_labels(event.repository.full_name, event.pull_request.number);
+  return classification_error(labels, event.pull_request.user.login);
+}
+var pr_classification = {
+  classification_error,
+  check_event,
+  fetch_current_labels,
+  declaration,
+  with_declaration,
+  is_classification,
+  select_classification,
+  select_issue_classification
+};
+
+export {
+  pr_classification
+};