@joshuafolkken/kit 1.872.0

package/dist/hooks/chunk-JR25IFML.js

@@ -0,0 +1,77 @@
+import {
+  lane_guard_policy,
+  time_batch_guard
+} from "./chunk-OQZEZW5G.js";
+import {
+  hook_decision
+} from "./chunk-F2SDYJU4.js";
+
+// scripts/hooks/batch-guard.ts
+import { text } from "node:stream/consumers";
+import { fileURLToPath } from "node:url";
+var SWITCH_ENV_KEY = "JOSH_BATCH_GUARD";
+function is_batch_candidate(call) {
+  return time_batch_guard.is_guarded_call(call) || time_batch_guard.is_notice_call(call);
+}
+function batching_mode() {
+  return lane_guard_policy.mode_here("batching");
+}
+function is_candidate(call) {
+  return is_batch_candidate(call) && batching_mode() !== "off";
+}
+function should_block_here(tail, call, refused_at_ms) {
+  if (batching_mode() !== "refuse") return false;
+  return time_batch_guard.should_block(tail, call, refused_at_ms);
+}
+function should_notify_here(tail, call, notified_at_ms) {
+  if (time_batch_guard.should_notify(tail, call, notified_at_ms)) return true;
+  if (batching_mode() !== "notice") return false;
+  return time_batch_guard.should_block(
+    tail,
+    call,
+    notified_at_ms,
+    time_batch_guard.NOTICE_REFIRE_EVERY
+  );
+}
+function notice_text(call, tail) {
+  const base = time_batch_guard.is_notice_call(call) ? time_batch_guard.NOTICE : time_batch_guard.LANE_NOTICE;
+  return `${base}${time_batch_guard.recent_candidates(tail)}`;
+}
+var GUARD = hook_decision.create_transcript_guard({
+  prefix: time_batch_guard.STAMP_PREFIX,
+  switch_key: SWITCH_ENV_KEY,
+  is_candidate,
+  should_block: should_block_here,
+  reason: time_batch_guard.REASON,
+  // The whole-file write is notified rather than refused, on a record of its own so it never spends
+  // the refusal's stamp (joshuafolkken/kit#1848); the lane-child refusable-call notice kit#2164 added
+  // here fires again since kit#2276 restored batching to `notice` in a lane child.
+  notify: {
+    prefix: time_batch_guard.NOTICE_STAMP_PREFIX,
+    should_notify: should_notify_here,
+    text: notice_text
+  }
+});
+var batch_refusal = GUARD.refusal;
+var batch_outcome = GUARD.outcome;
+var { is_enabled, refusal_path } = GUARD;
+var notice_refusal_path = hook_decision.create_refusal_stamp(
+  time_batch_guard.NOTICE_STAMP_PREFIX
+).path;
+var { deny_envelope, load_environment_file, DISABLED_VALUES } = hook_decision;
+if (process.argv[1] === fileURLToPath(import.meta.url)) {
+  if (process.stdin.isTTY) hook_decision.report_no_payload("batch:guard");
+  else hook_decision.write_outcome(await text(process.stdin), batch_outcome);
+}
+
+export {
+  SWITCH_ENV_KEY,
+  batch_refusal,
+  batch_outcome,
+  is_enabled,
+  refusal_path,
+  notice_refusal_path,
+  deny_envelope,
+  load_environment_file,
+  DISABLED_VALUES
+};

package/dist/hooks/chunk-JT5AUXFI.js

@@ -0,0 +1,432 @@
+import {
+  ESLINT_EDIT_CACHE_FLAGS,
+  time_density_hook
+} from "./chunk-AYC7R6U4.js";
+
+// scripts/hooks/format-edited-file.ts
+import { existsSync as existsSync3 } from "node:fs";
+import path3 from "node:path";
+import { text } from "node:stream/consumers";
+import { fileURLToPath } from "node:url";
+
+// scripts/build/local-bin.ts
+import { existsSync, readFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import path from "node:path";
+
+// scripts/lib/schemas.ts
+import { z } from "zod";
+var overrides_snapshot_schema = z.record(z.string(), z.string());
+var package_version_schema = z.object({ version: z.string() });
+var package_named_version_schema = z.looseObject({ name: z.string(), version: z.string() });
+var package_with_version_schema = z.looseObject({ version: z.string() });
+var ls_global_dependency_schema = z.looseObject({ version: z.string() });
+var ls_global_dependencies_schema = z.record(z.string(), ls_global_dependency_schema).optional();
+var pnpm_ls_global_schema = z.array(
+  z.looseObject({
+    dependencies: ls_global_dependencies_schema
+  })
+);
+var vscode_settings_schema = z.record(z.string(), z.unknown());
+var with_scripts_schema = z.looseObject({
+  scripts: z.record(z.string(), z.string()).optional()
+});
+var with_development_deps_schema = z.looseObject({
+  devDependencies: z.record(z.string(), z.string()).optional()
+});
+var with_package_manager_schema = z.looseObject({
+  packageManager: z.string().optional()
+});
+var with_development_engine_schema = z.looseObject({
+  devEngines: z.record(z.string(), z.unknown()).optional()
+});
+var bin_entry_schema = z.union([z.string(), z.record(z.string(), z.string())]).optional();
+var package_bin_schema = z.looseObject({ bin: bin_entry_schema });
+var json_object_schema = z.record(z.string(), z.unknown());
+var string_array_schema = z.array(z.string());
+var string_record_schema = z.record(z.string(), z.string());
+
+// scripts/build/local-bin.ts
+var NODE_MODULES = "node_modules";
+var BIN_DIR = ".bin";
+var WINDOWS_PLATFORM = "win32";
+var WINDOWS_SHIM_SUFFIX = ".cmd";
+var PACKAGE_JSON = "package.json";
+function resolve_local_bin(project_root, bin_name) {
+  const shim = process.platform === WINDOWS_PLATFORM ? `${bin_name}${WINDOWS_SHIM_SUFFIX}` : bin_name;
+  return path.join(project_root, NODE_MODULES, BIN_DIR, shim);
+}
+function read_bin_entry(manifest_path, package_name, bin_name) {
+  const { bin } = package_bin_schema.parse(JSON.parse(readFileSync(manifest_path, "utf8")));
+  if (typeof bin === "string") return bin_name === path.basename(package_name) ? bin : void 0;
+  return bin?.[bin_name];
+}
+function resolve_package_bin(base_directory, package_name, bin_name) {
+  try {
+    const resolve_from = createRequire(path.join(base_directory, PACKAGE_JSON));
+    const manifest_path = resolve_from.resolve(`${package_name}/${PACKAGE_JSON}`);
+    const bin_entry = read_bin_entry(manifest_path, package_name, bin_name);
+    if (bin_entry === void 0) return void 0;
+    const cli_entry = path.join(path.dirname(manifest_path), bin_entry);
+    return existsSync(cli_entry) ? cli_entry : void 0;
+  } catch {
+    return void 0;
+  }
+}
+
+// scripts/hooks/format-edited-file.ts
+import { execa as execa2 } from "execa";
+import { z as z2 } from "zod";
+
+// scripts/hooks/edited-cspell.ts
+import { existsSync as existsSync2 } from "node:fs";
+import path2 from "node:path";
+import { execa } from "execa";
+var CSPELL_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".ts",
+  ".tsx",
+  ".js",
+  ".jsx",
+  ".mjs",
+  ".cjs",
+  ".svelte",
+  ".md",
+  ".mdx",
+  ".txt",
+  ".json",
+  ".jsonc",
+  ".yml",
+  ".yaml",
+  ".html",
+  ".css"
+]);
+var CSPELL_ARGS = [
+  "exec",
+  "cspell",
+  "lint",
+  "--words-only",
+  "--unique",
+  "--no-progress",
+  "--no-summary"
+];
+var PNPM = "pnpm";
+var PROCESS_TIMEOUT_MS = 15e3;
+var HEADER = "The edit hook found words cspell does not know; fix them or add them to `cspell.config.yaml` now rather than at the gate:";
+var MAX_DIAGNOSTIC_CHARS = 4e3;
+var TRUNCATION_NOTICE = "\n\u2026(unknown words truncated)";
+function is_checkable(file_path, project_root) {
+  if (!existsSync2(file_path) || !CSPELL_EXTENSIONS.has(path2.extname(file_path).toLowerCase())) {
+    return false;
+  }
+  const relative = path2.relative(path2.resolve(project_root), path2.resolve(file_path));
+  return relative !== "" && !relative.startsWith("..") && !path2.isAbsolute(relative);
+}
+async function run_cspell(file_path, project_root) {
+  const result = await execa(PNPM, [...CSPELL_ARGS, file_path], {
+    reject: false,
+    cwd: project_root,
+    stdout: "pipe",
+    stderr: "ignore",
+    timeout: PROCESS_TIMEOUT_MS
+  });
+  return result.stdout;
+}
+function format_unknown_words(stdout) {
+  const words = stdout.split("\n").map((word) => word.trim()).filter((word) => word.length > 0);
+  if (words.length === 0) return void 0;
+  const joined = words.join("\n");
+  const body = joined.length > MAX_DIAGNOSTIC_CHARS ? `${joined.slice(0, MAX_DIAGNOSTIC_CHARS)}${TRUNCATION_NOTICE}` : joined;
+  return `${HEADER}
+${body}`;
+}
+async function spelling_diagnostics(file_path, project_root, runner = run_cspell) {
+  if (file_path === void 0 || !is_checkable(file_path, project_root)) return void 0;
+  try {
+    return format_unknown_words(await runner(file_path, project_root));
+  } catch {
+    return void 0;
+  }
+}
+var edited_cspell = { format_unknown_words, is_checkable, spelling_diagnostics };
+
+// scripts/hooks/format-rewrite-notice.ts
+import { readFileSync as readFileSync2 } from "node:fs";
+var MAX_REWRITE_CHARS = 1200;
+var REWRITE_TRUNCATION_NOTICE = "\n\u2026(rewrite preview truncated)";
+var REWRITE_HEADER = "The format hook rewrote this file after your edit, so your in-memory copy is now stale \u2014 re-read it before the next Edit or the match will miss.";
+var REWRITE_RANGE_PREFIX = "Changed around lines ";
+var LINE_SEPARATOR = "\n";
+var FIRST_LINE = 1;
+function common_prefix_length(before, after) {
+  const limit = Math.min(before.length, after.length);
+  let index = 0;
+  while (index < limit && before[index] === after[index]) index += 1;
+  return index;
+}
+function common_suffix_length(before, after, prefix) {
+  const limit = Math.min(before.length, after.length) - prefix;
+  let index = 0;
+  while (index < limit && before.at(-1 - index) === after.at(-1 - index)) index += 1;
+  return index;
+}
+function changed_range(before, after) {
+  const before_lines = before.split(LINE_SEPARATOR);
+  const after_lines = after.split(LINE_SEPARATOR);
+  const prefix = common_prefix_length(before_lines, after_lines);
+  const last = after_lines.length - common_suffix_length(before_lines, after_lines, prefix);
+  return {
+    start_line: prefix + FIRST_LINE,
+    end_line: Math.max(prefix + FIRST_LINE, last),
+    body: after_lines.slice(prefix, last).join(LINE_SEPARATOR)
+  };
+}
+function cap_body(body) {
+  if (body.length <= MAX_REWRITE_CHARS) return body;
+  return `${body.slice(0, MAX_REWRITE_CHARS)}${REWRITE_TRUNCATION_NOTICE}`;
+}
+function build(before, after) {
+  if (before === after) return void 0;
+  const range = changed_range(before, after);
+  const location = `${REWRITE_RANGE_PREFIX}${String(range.start_line)}-${String(range.end_line)}:`;
+  return `${REWRITE_HEADER}
+${location}
+${cap_body(range.body)}`;
+}
+function read_text(file_path) {
+  if (file_path === void 0) return "";
+  try {
+    return readFileSync2(file_path, "utf8");
+  } catch {
+    return "";
+  }
+}
+var rewrite_notice = { build, read_text };
+
+// scripts/hooks/format-edited-file.ts
+var hook_payload_schema = z2.object({
+  tool_input: z2.object({ file_path: z2.string().min(1) }).optional()
+});
+var PRETTIER_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".ts",
+  ".tsx",
+  ".js",
+  ".jsx",
+  ".mjs",
+  ".cjs",
+  ".svelte",
+  ".json",
+  ".jsonc",
+  ".md",
+  ".yml",
+  ".yaml",
+  ".css",
+  ".html"
+]);
+var ESLINT_EXTENSIONS = /* @__PURE__ */ new Set([".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".svelte"]);
+var EXCLUDED_ANYWHERE = /* @__PURE__ */ new Set(["node_modules", ".git"]);
+var EXCLUDED_AT_ROOT = /* @__PURE__ */ new Set(["dist", "build"]);
+var PARENT_SEGMENT = "..";
+var PNPM2 = "pnpm";
+var PRETTIER_BIN = "prettier";
+var PRETTIER_ARGUMENTS = ["--write", "--ignore-unknown"];
+var ESLINT_BIN = "eslint";
+var ESLINT_ARGUMENTS = [
+  "--fix",
+  "--no-error-on-unmatched-pattern",
+  ...ESLINT_EDIT_CACHE_FLAGS
+];
+var ESLINT_DAEMON = "eslint_d";
+var DAEMON_RESTART = "restart";
+var ESLINT_CONFIG_DIR = "eslint";
+var ESLINT_CONFIG_ENTRY = /^eslint\.config\.[cm]?[jt]s$/u;
+var PROCESS_TIMEOUT_MS2 = 15e3;
+var DIAGNOSTIC_HEADER = "The edit hook could not auto-fix these lint problems; address them now rather than at the gate:";
+var MAX_DIAGNOSTIC_CHARS2 = 4e3;
+var DIAGNOSTIC_TRUNCATION_NOTICE = "\n\u2026(diagnostics truncated)";
+var SECTION_SEPARATOR = "\n\n";
+var MODULE_DIRECTORY = path3.dirname(fileURLToPath(import.meta.url));
+function parse_edited_path(raw_payload) {
+  try {
+    const result = hook_payload_schema.safeParse(JSON.parse(raw_payload));
+    return result.success ? result.data.tool_input?.file_path : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function is_excluded(relative_path) {
+  const segments = relative_path.split(path3.sep);
+  return segments.some((segment) => EXCLUDED_ANYWHERE.has(segment)) || EXCLUDED_AT_ROOT.has(segments[0] ?? "");
+}
+function relative_to_root(project_root, file_path) {
+  const relative = path3.relative(path3.resolve(project_root), path3.resolve(file_path));
+  const is_inside_root = relative !== "" && relative.split(path3.sep)[0] !== PARENT_SEGMENT && !path3.isAbsolute(relative);
+  return is_inside_root ? relative : void 0;
+}
+function is_formattable(file_path, project_root) {
+  const relative = relative_to_root(project_root, file_path);
+  return relative !== void 0 && !is_excluded(relative) && existsSync3(file_path);
+}
+function plan_commands(file_path, project_root) {
+  if (!is_formattable(file_path, project_root)) return [];
+  const extension = path3.extname(file_path).toLowerCase();
+  const commands = [];
+  if (ESLINT_EXTENSIONS.has(extension)) {
+    commands.push({ bin: ESLINT_BIN, command_arguments: [...ESLINT_ARGUMENTS, file_path] });
+  }
+  if (PRETTIER_EXTENSIONS.has(extension)) {
+    commands.push({ bin: PRETTIER_BIN, command_arguments: [...PRETTIER_ARGUMENTS, file_path] });
+  }
+  return commands;
+}
+function select_invocation(command, routes) {
+  if (routes.daemon_cli !== void 0) {
+    return {
+      bin: process.execPath,
+      command_arguments: [routes.daemon_cli, ...command.command_arguments]
+    };
+  }
+  if (routes.shim !== void 0) {
+    return { bin: routes.shim, command_arguments: command.command_arguments };
+  }
+  return { bin: PNPM2, command_arguments: ["exec", command.bin, ...command.command_arguments] };
+}
+var DAEMON_BINS = /* @__PURE__ */ new Set([ESLINT_BIN, ESLINT_DAEMON]);
+function resolve_daemon_cli(bin, project_root) {
+  if (!DAEMON_BINS.has(bin)) return void 0;
+  return resolve_package_bin(MODULE_DIRECTORY, ESLINT_DAEMON, ESLINT_DAEMON) ?? resolve_package_bin(project_root, ESLINT_DAEMON, ESLINT_DAEMON);
+}
+function is_eslint_config_input(relative_path) {
+  return relative_path.split(path3.sep)[0] === ESLINT_CONFIG_DIR || ESLINT_CONFIG_ENTRY.test(relative_path);
+}
+function plan_daemon_restart(file_path, project_root) {
+  const relative = relative_to_root(project_root, file_path);
+  if (relative === void 0 || !is_eslint_config_input(relative)) return [];
+  if (resolve_daemon_cli(ESLINT_DAEMON, project_root) === void 0) return [];
+  return [{ bin: ESLINT_DAEMON, command_arguments: [DAEMON_RESTART] }];
+}
+function resolve_invocations(command, project_root) {
+  const shim = resolve_local_bin(project_root, command.bin);
+  const routes = {
+    daemon_cli: resolve_daemon_cli(command.bin, project_root),
+    shim: existsSync3(shim) ? shim : void 0
+  };
+  const without_daemon = select_invocation(command, { ...routes, daemon_cli: void 0 });
+  if (routes.daemon_cli === void 0) return [without_daemon];
+  return [select_invocation(command, routes), without_daemon];
+}
+function is_start_failure(outcome) {
+  return outcome.exit_code !== 0 && outcome.stdout.length === 0;
+}
+async function spawn_invocation(invocation, project_root) {
+  const result = await execa2(invocation.bin, [...invocation.command_arguments], {
+    reject: false,
+    cwd: project_root,
+    env: { ESLINT_D_MISS: "fail" },
+    stdout: "pipe",
+    stderr: "ignore",
+    timeout: PROCESS_TIMEOUT_MS2
+  });
+  return { exit_code: result.exitCode ?? 1, stdout: result.stdout };
+}
+async function run_command(command, project_root) {
+  let outcome = { exit_code: 0, stdout: "" };
+  for (const invocation of resolve_invocations(command, project_root)) {
+    outcome = await spawn_invocation(invocation, project_root);
+    if (!is_start_failure(outcome)) return outcome;
+  }
+  return outcome;
+}
+function eslint_unfixed(command, outcome) {
+  if (command.bin !== ESLINT_BIN) return void 0;
+  if (outcome.exit_code === 0 || outcome.stdout.length === 0) return void 0;
+  return outcome.stdout;
+}
+function format_diagnostics(unfixed) {
+  if (unfixed === void 0) return void 0;
+  const is_over = unfixed.length > MAX_DIAGNOSTIC_CHARS2;
+  const body = is_over ? `${unfixed.slice(0, MAX_DIAGNOSTIC_CHARS2)}${DIAGNOSTIC_TRUNCATION_NOTICE}` : unfixed;
+  return `${DIAGNOSTIC_HEADER}
+${body}`;
+}
+async function collect_unfixed(plan, runner, project_root) {
+  let unfixed = "";
+  for (const command of plan) {
+    try {
+      unfixed = eslint_unfixed(command, await runner(command, project_root)) ?? unfixed;
+    } catch {
+      continue;
+    }
+  }
+  return unfixed;
+}
+async function format_edited_file(raw_payload, runner, project_root) {
+  const file_path = parse_edited_path(raw_payload);
+  if (file_path === void 0) return void 0;
+  const plan = [
+    ...plan_commands(file_path, project_root),
+    ...plan_daemon_restart(file_path, project_root)
+  ];
+  const unfixed = await collect_unfixed(plan, runner, project_root);
+  return format_diagnostics(unfixed === "" ? void 0 : unfixed);
+}
+async function format_edited_payload(raw_payload, project_root) {
+  return await format_edited_file(raw_payload, run_command, project_root);
+}
+var HOOK_EVENT_NAME = "PostToolUse";
+function build_envelope(additional_context) {
+  return JSON.stringify({
+    hookSpecificOutput: { hookEventName: HOOK_EVENT_NAME, additionalContext: additional_context }
+  });
+}
+function density_envelope(raw_payload) {
+  const notice = time_density_hook.density_notice(raw_payload);
+  return notice === void 0 ? void 0 : build_envelope(notice);
+}
+function compose_context(notice, diagnostics) {
+  const sections = [notice, diagnostics].filter(
+    (section) => section !== void 0
+  );
+  return sections.length === 0 ? void 0 : sections.join(SECTION_SEPARATOR);
+}
+function report_no_payload() {
+  process.stderr.write(
+    "format:edited reads a Claude Code PostToolUse payload on stdin; it is not run by hand.\n"
+  );
+}
+async function run_hook(payload) {
+  const notice = time_density_hook.density_notice(payload);
+  const file_path = parse_edited_path(payload);
+  const before = rewrite_notice.read_text(file_path);
+  const lint = await format_edited_payload(payload, process.cwd());
+  const rewrite = rewrite_notice.build(before, rewrite_notice.read_text(file_path));
+  const spelling = await edited_cspell.spelling_diagnostics(file_path, process.cwd());
+  const parts = compose_context(rewrite, compose_context(lint, spelling));
+  const context = compose_context(notice, parts);
+  if (context !== void 0) process.stdout.write(`${build_envelope(context)}
+`);
+}
+if (process.argv[1] === fileURLToPath(import.meta.url)) {
+  if (process.stdin.isTTY) {
+    report_no_payload();
+  } else {
+    await run_hook(await text(process.stdin));
+  }
+}
+
+export {
+  ESLINT_DAEMON,
+  PROCESS_TIMEOUT_MS2 as PROCESS_TIMEOUT_MS,
+  MAX_DIAGNOSTIC_CHARS2 as MAX_DIAGNOSTIC_CHARS,
+  parse_edited_path,
+  relative_to_root,
+  plan_commands,
+  select_invocation,
+  plan_daemon_restart,
+  resolve_invocations,
+  is_start_failure,
+  format_edited_file,
+  format_edited_payload,
+  build_envelope,
+  density_envelope,
+  compose_context
+};