@joshuafolkken/kit 1.1784.0 → 1.2114.0

package/dist/hooks/{chunk-VWWCFGWK.js → chunk-OPSRGWFU.js}

@@ -1,6 +1,6 @@
 import {
   FETCH_TIMEOUT_MS
-} from "./chunk-AZX4FGQ3.js";
+} from "./chunk-45CJJOO7.js";
 
 // scripts/lib/timed-fetch.ts
 async function timed_fetch(url, init = {}, timeout_ms = FETCH_TIMEOUT_MS) {

package/dist/hooks/{chunk-XGBNSWEI.js → chunk-UJ3FPMMM.js}

@@ -1,31 +1,30 @@
 import {
-  toolchain_inputs
-} from "./chunk-TUIFS5E7.js";
-import {
-  ESLINT_EDIT_CACHE_FLAGS,
   resolve_local_bin,
   resolve_package_bin,
   time_density_hook
-} from "./chunk-PT5R6UJD.js";
+} from "./chunk-Z6DQJKH3.js";
 import {
+  ESLINT_EDIT_CACHE_FLAGS,
   file_reader,
-  git_spawn_sync,
-  json_value
-} from "./chunk-WR2KQAYZ.js";
+  json_value,
+  toolchain_inputs
+} from "./chunk-7SIUNQXK.js";
 import {
   HOOK_PROCESS_TIMEOUT_MS,
   SUITE_TIMEOUT_MS,
-  atomic_write
-} from "./chunk-AZX4FGQ3.js";
+  atomic_write,
+  git_spawn_sync
+} from "./chunk-45CJJOO7.js";
 
 // scripts/hooks/format-edited-file.ts
 import { existsSync as existsSync3 } from "node:fs";
-import path3 from "node:path";
+import path4 from "node:path";
 
 // scripts/lint/eslint-daemon.ts
-import { lstatSync, readFileSync } from "node:fs";
+import { createHash as createHash2 } from "node:crypto";
+import { lstatSync, readFileSync as readFileSync2 } from "node:fs";
 import { createRequire } from "node:module";
-import path from "node:path";
+import path2 from "node:path";
 import { fileURLToPath } from "node:url";
 
 // scripts/lib/buffered-process.ts
@@ -90,6 +89,54 @@ var buffered_process = { child_environment, is_process_failed, run_buffered_proc
 
 // scripts/lint/eslint-daemon.ts
 import { execa as execa2 } from "execa";
+
+// scripts/lint/eslint-daemon-sources.ts
+import { createHash } from "node:crypto";
+import { readFileSync } from "node:fs";
+import path from "node:path";
+var CHANGED_FILES = ["diff", "HEAD", "--name-only", "--relative", "-z"];
+var NEW_FILES = ["ls-files", "--others", "--exclude-standard", "-z"];
+var PATH_SEPARATOR = "\0";
+var LINE_SEPARATOR = "\n";
+var ENTRY_SEPARATOR = "	";
+var DIGEST_ALGORITHM = "sha256";
+var ABSENT = "absent";
+var UNREAD = ":unread";
+function by_text(left, right) {
+  return left.localeCompare(right);
+}
+function lines_of(text) {
+  return text.split(LINE_SEPARATOR).filter((line) => line !== "");
+}
+function content_digest(file) {
+  try {
+    return createHash(DIGEST_ALGORITHM).update(readFileSync(file)).digest("hex");
+  } catch {
+    return ABSENT;
+  }
+}
+function changed_paths(project_root) {
+  const listed = [CHANGED_FILES, NEW_FILES].map(
+    (git_arguments) => git_spawn_sync.read(git_arguments, { cwd: project_root }) ?? UNREAD
+  );
+  const paths = listed.join(PATH_SEPARATOR).split(PATH_SEPARATOR);
+  return [...new Set(paths.filter((relative) => relative !== ""))];
+}
+function snapshot(project_root) {
+  return changed_paths(project_root).map(
+    (relative) => `${relative}${ENTRY_SEPARATOR}${content_digest(path.join(project_root, relative))}`
+  ).toSorted(by_text).join(LINE_SEPARATOR);
+}
+function refresh(recorded, current, relative) {
+  const prefix = `${relative}${ENTRY_SEPARATOR}`;
+  const [inputs = "", ...entries] = lines_of(recorded);
+  const others = entries.filter((line) => !line.startsWith(prefix));
+  const fresh = lines_of(current).filter((line) => line.startsWith(prefix));
+  return [inputs, ...[...others, ...fresh].toSorted(by_text)].join(LINE_SEPARATOR);
+}
+var eslint_daemon_sources = { refresh, snapshot, LINE_SEPARATOR };
+
+// scripts/lint/eslint-daemon.ts
 var ESLINT_DAEMON = "eslint_d";
 var DAEMON_STOP = "stop";
 var PNPM_EXEC = "exec";
@@ -100,9 +147,11 @@ var DAEMON_RECORD = ".eslint_d";
 var FINGERPRINT_RECORD = ".eslint_d-toolchain";
 var RECORD_SEPARATOR = "\n";
 var NO_HEAD = "no-head";
-var MODULE_DIRECTORY = path.dirname(fileURLToPath(import.meta.url));
+var LIST_FILES = ["ls-files", "--cached", "--others", "--exclude-standard"];
+var DIGEST_ALGORITHM2 = "sha256";
+var MODULE_DIRECTORY = path2.dirname(fileURLToPath(import.meta.url));
 function is_borrowed_install(project_root) {
-  return lstatSync(path.join(project_root, NODE_MODULES), {
+  return lstatSync(path2.join(project_root, NODE_MODULES), {
     throwIfNoEntry: false
   })?.isSymbolicLink() === true;
 }
@@ -117,14 +166,20 @@ function eslint_arguments_of(pnpm_arguments) {
   if (pnpm_arguments[0] !== PNPM_EXEC || pnpm_arguments[1] !== ESLINT_BIN) return void 0;
   return pnpm_arguments.slice(PNPM_ESLINT_PREFIX_LENGTH);
 }
+function digest_of(text) {
+  return createHash2(DIGEST_ALGORITHM2).update(text).digest("hex");
+}
 function fingerprint(project_root) {
   const head = git_spawn_sync.read(["rev-parse", "HEAD"], { cwd: project_root }) ?? NO_HEAD;
-  return `${toolchain_inputs.digest(project_root)}:${head}`;
+  const files = git_spawn_sync.read(LIST_FILES, { cwd: project_root }) ?? NO_HEAD;
+  const inputs = `${toolchain_inputs.digest(project_root)}:${head}:${digest_of(files)}`;
+  const sources = eslint_daemon_sources.snapshot(project_root);
+  return sources === "" ? inputs : `${inputs}${eslint_daemon_sources.LINE_SEPARATOR}${sources}`;
 }
 function eslint_directory(project_root) {
   try {
-    return path.dirname(
-      createRequire(path.join(project_root, "package.json")).resolve("eslint/package.json")
+    return path2.dirname(
+      createRequire(path2.join(project_root, "package.json")).resolve("eslint/package.json")
     );
   } catch {
     return void 0;
@@ -132,7 +187,7 @@ function eslint_directory(project_root) {
 }
 function read_text(file) {
   try {
-    return readFileSync(file, "utf8");
+    return readFileSync2(file, "utf8");
   } catch {
     return void 0;
   }
@@ -141,8 +196,8 @@ function read_record(project_root) {
   const directory = eslint_directory(project_root);
   if (directory === void 0) return { daemon: void 0, recorded: void 0 };
   return {
-    daemon: read_text(path.join(directory, DAEMON_RECORD)),
-    recorded: read_text(path.join(directory, FINGERPRINT_RECORD))
+    daemon: read_text(path2.join(directory, DAEMON_RECORD)),
+    recorded: read_text(path2.join(directory, FINGERPRINT_RECORD))
   };
 }
 function record_text(daemon, current) {
@@ -155,19 +210,31 @@ function is_stale(record, current) {
 function remember(project_root, current) {
   const directory = eslint_directory(project_root);
   if (directory === void 0) return;
-  const daemon = read_text(path.join(directory, DAEMON_RECORD));
+  const daemon = read_text(path2.join(directory, DAEMON_RECORD));
   if (daemon === void 0) return;
   try {
     atomic_write.replace_file(
-      path.join(directory, FINGERPRINT_RECORD),
+      path2.join(directory, FINGERPRINT_RECORD),
       record_text(daemon, current)
     );
   } catch {
   }
 }
-function remember_started(project_root, before) {
-  if (read_record(project_root).daemon === before.daemon) return;
-  remember(project_root, fingerprint(project_root));
+function remember_read(project_root, record, relative) {
+  const { daemon, recorded } = record;
+  if (daemon === void 0 || recorded === void 0 || is_borrowed_install(project_root)) return;
+  const prefix = record_text(daemon, "");
+  if (!recorded.startsWith(prefix)) return;
+  const current = eslint_daemon_sources.snapshot(project_root);
+  remember(
+    project_root,
+    eslint_daemon_sources.refresh(recorded.slice(prefix.length), current, relative)
+  );
+}
+function remember_after_edit(project_root, before, edited) {
+  const after = read_record(project_root);
+  if (after.daemon !== before.daemon) remember(project_root, fingerprint(project_root));
+  else if (edited !== void 0) remember_read(project_root, after, edited);
 }
 async function spawn_daemon(cli, cli_arguments, options) {
   const result = await execa2(process.execPath, [cli, ...cli_arguments], {
@@ -216,7 +283,7 @@ var eslint_daemon = {
   is_stale,
   read_record,
   record_text,
-  remember_started,
+  remember_after_edit,
   resolve_daemon_cli,
   run,
   run_or_cold,
@@ -229,7 +296,7 @@ import { z } from "zod";
 
 // scripts/hooks/edited-cspell.ts
 import { existsSync as existsSync2 } from "node:fs";
-import path2 from "node:path";
+import path3 from "node:path";
 import { execa as execa3 } from "execa";
 var CSPELL_EXTENSIONS = /* @__PURE__ */ new Set([
   ".ts",
@@ -250,29 +317,36 @@ var CSPELL_EXTENSIONS = /* @__PURE__ */ new Set([
   ".css"
 ]);
 var CSPELL_ARGS = [
-  "exec",
-  "cspell",
   "lint",
   "--words-only",
   "--unique",
   "--no-progress",
   "--no-summary"
 ];
+var CSPELL_BIN = "cspell";
 var PNPM3 = "pnpm";
+var STDIN_SCHEME = "stdin://";
 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())) {
+  if (!existsSync2(file_path) || !CSPELL_EXTENSIONS.has(path3.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);
+  const relative = path3.relative(path3.resolve(project_root), path3.resolve(file_path));
+  return relative !== "" && !relative.startsWith("..") && !path3.isAbsolute(relative);
 }
-async function run_cspell(file_path, project_root) {
-  const result = await execa3(PNPM3, [...CSPELL_ARGS, file_path], {
+function cspell_command(project_root) {
+  const shim = resolve_local_bin(project_root, CSPELL_BIN);
+  return existsSync2(shim) ? [shim] : [PNPM3, "exec", CSPELL_BIN];
+}
+async function run_cspell(request) {
+  const [bin = PNPM3, ...prefix] = cspell_command(request.project_root);
+  const target = `${STDIN_SCHEME}${path3.resolve(request.file_path)}`;
+  const result = await execa3(bin, [...prefix, ...CSPELL_ARGS, target], {
     reject: false,
-    cwd: project_root,
+    cwd: request.project_root,
+    input: request.text,
     stdout: "pipe",
     stderr: "ignore",
     timeout: HOOK_PROCESS_TIMEOUT_MS
@@ -287,22 +361,22 @@ function format_unknown_words(stdout) {
   return `${HEADER}
 ${body}`;
 }
-async function spelling_diagnostics(file_path, project_root, runner = run_cspell) {
+async function spelling_diagnostics(file_path, project_root, text, 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));
+    return format_unknown_words(await runner({ file_path, project_root, text }));
   } catch {
     return void 0;
   }
 }
-var edited_cspell = { format_unknown_words, spelling_diagnostics };
+var edited_cspell = { cspell_command, format_unknown_words, run_cspell, spelling_diagnostics };
 
 // scripts/hooks/format-rewrite-notice.ts
 var MAX_REWRITE_CHARS = 600;
 var REWRITE_TRUNCATION_NOTICE = "\n\u2026(truncated)";
 var REWRITE_HEADER = "The format hook rewrote this file, so your copy is stale; re-read these lines before the next Edit.";
 var REWRITE_RANGE_PREFIX = "Lines ";
-var LINE_SEPARATOR = "\n";
+var LINE_SEPARATOR2 = "\n";
 var FIRST_LINE = 1;
 function common_prefix_length(before, after) {
   const limit = Math.min(before.length, after.length);
@@ -317,14 +391,14 @@ function common_suffix_length(before, after, prefix) {
   return index;
 }
 function changed_range(before, after) {
-  const before_lines = before.split(LINE_SEPARATOR);
-  const after_lines = after.split(LINE_SEPARATOR);
+  const before_lines = before.split(LINE_SEPARATOR2);
+  const after_lines = after.split(LINE_SEPARATOR2);
   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)
+    body: after_lines.slice(prefix, last).join(LINE_SEPARATOR2)
   };
 }
 function cap_body(body, budget) {
@@ -387,12 +461,12 @@ function parse_edited_path(raw_payload) {
   return json_value.parse_with(raw_payload, hook_payload_schema)?.tool_input?.file_path;
 }
 function is_excluded(relative_path) {
-  const segments = relative_path.split(path3.sep);
+  const segments = relative_path.split(path4.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);
+  const relative = path4.relative(path4.resolve(project_root), path4.resolve(file_path));
+  const is_inside_root = relative !== "" && relative.split(path4.sep)[0] !== PARENT_SEGMENT && !path4.isAbsolute(relative);
   return is_inside_root ? relative : void 0;
 }
 function is_formattable(file_path, project_root) {
@@ -401,7 +475,7 @@ function is_formattable(file_path, project_root) {
 }
 function plan_commands(file_path, project_root) {
   if (!is_formattable(file_path, project_root)) return [];
-  const extension = path3.extname(file_path).toLowerCase();
+  const extension = path4.extname(file_path).toLowerCase();
   const commands = [];
   if (ESLINT_EXTENSIONS.has(extension)) {
     commands.push({ bin: ESLINT_BIN2, command_arguments: [...ESLINT_ARGUMENTS, file_path] });
@@ -491,6 +565,10 @@ async function collect_unfixed(plan, runner, project_root) {
   }
   return unfixed;
 }
+function linted_path(plan, file_path, project_root) {
+  if (plan.every((command) => command.bin !== ESLINT_BIN2)) return void 0;
+  return relative_to_root(project_root, file_path);
+}
 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;
@@ -500,7 +578,11 @@ async function format_edited_file(raw_payload, runner, project_root) {
   ];
   const daemon_before = eslint_daemon.read_record(project_root);
   const unfixed = await collect_unfixed(plan, runner, project_root);
-  eslint_daemon.remember_started(project_root, daemon_before);
+  eslint_daemon.remember_after_edit(
+    project_root,
+    daemon_before,
+    linted_path(plan, file_path, project_root)
+  );
   return format_diagnostics(unfixed === "" ? void 0 : unfixed);
 }
 async function format_edited_payload(raw_payload, project_root) {
@@ -527,9 +609,10 @@ 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 pending_spelling = edited_cspell.spelling_diagnostics(file_path, process.cwd(), before);
   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 spelling = await pending_spelling;
   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)}

package/dist/hooks/chunk-VVNYJWEI.js

@@ -0,0 +1,30 @@
+import {
+  repo_discovery,
+  stamp_file
+} from "./chunk-45CJJOO7.js";
+
+// scripts/discovery/session-owner-pin.ts
+var PIN_PREFIX = "josh-session-owner-";
+var PIN_SUFFIX = ".txt";
+function pin_path(repository_path) {
+  return stamp_file.stamp_path(PIN_PREFIX, repository_path, PIN_SUFFIX);
+}
+function pin(repository_path = process.cwd()) {
+  const owner = repo_discovery.resolve_current_owner(repository_path);
+  try {
+    if (owner === void 0) stamp_file.remove_stamp(pin_path(repository_path));
+    else stamp_file.write_text_stamp(pin_path(repository_path), owner);
+  } catch {
+    return void 0;
+  }
+  return owner;
+}
+function pinned(repository_path = process.cwd()) {
+  const text = stamp_file.read_stamp_text(pin_path(repository_path))?.trim();
+  return text === "" ? void 0 : text;
+}
+var session_owner_pin = { pin, pin_path, pinned };
+
+export {
+  session_owner_pin
+};