@joshuafolkken/kit 1.3041.0 → 1.3092.0

package/dist/commands/chunk-RYKK75YT.js

@@ -0,0 +1,289 @@
+import {
+  git_grep_hits
+} from "./chunk-LU5EOGFQ.js";
+import {
+  session_language
+} from "./chunk-OKYFQJW3.js";
+import {
+  file_reader
+} from "./chunk-ZNX2LJCQ.js";
+
+// scripts/cases/cases-interaction-scan.ts
+import path from "node:path";
+
+// scripts/cases/cases-interaction.ts
+var INTERACTIONS = ["state", "env"];
+var QUOTED_LITERAL = /(?<quote>['"`])(?<literal>[^'"`\s]+)\k<quote>/gu;
+var STATE_PATH = /(?:\.josh\/[^/])|(?:[^/]\.lock$)|(?:^josh-[a-z][\w-]*-$)/u;
+var PLACEHOLDER = /\$\{|<|\*/u;
+var CONSTANT_BINDING = /\b(?:const|let)\s+(?<name>[A-Za-z_]\w*)\s*(?::[^=\n]+)?=\s*(?<quote>['"`])(?<value>[^'"`\n]+)\k<quote>/gu;
+var ENV_MARK = "process.env";
+var ENV_LITERAL_KEY = /\bprocess\.env\.(?<dotted>[A-Za-z_]\w*)|\b(?:process\.env|environment)\[\s*['"](?<quoted>\w+)['"]\s*\]/gu;
+var ENV_CONSTANT_KEY = /\b(?:process\.env|environment)\[\s*(?<key>[A-Za-z_]\w*)\s*\]/gu;
+var ENV_NAME = /^[A-Z][A-Z0-9_]*$/u;
+var RESIDENT = /\b[\w-]*(?:[_-](?:daemon|beacon)|(?:daemon|beacon)[_-])[\w-]*/giu;
+var RESIDENT_KIND = /daemon|beacon/iu;
+var SLASH = "/";
+var JAPANESE = {
+  state: "\u5171\u6709\u72B6\u614B",
+  variable: "\u74B0\u5883\u5909\u6570",
+  resident: "\u5E38\u99D0\u30D7\u30ED\u30BB\u30B9",
+  others: "\u4ED6\u306E\u8AAD\u307F\u66F8\u304D",
+  no_others: "\u306A\u3057",
+  search_failed: "\u691C\u7D22\u5931\u6557",
+  state_cases: [
+    "\u4ED6\u306E\u66F8\u304D\u624B\u3068\u306E\u4E26\u884C\u66F8\u304D\u8FBC\u307F",
+    "\u4ED6\u306E\u8AAD\u307F\u624B\u304C\u53E4\u3044\u5F62\u5F0F\u30FB\u9014\u4E2D\u306E\u72B6\u614B\u3092\u8AAD\u3080",
+    "\u81EA\u5206\u304C\u66F8\u304F\u524D\u306B\u4ED6\u306E\u66F8\u304D\u624B\u304C\u6D88\u3059"
+  ],
+  variable_cases: [
+    "\u672A\u8A2D\u5B9A",
+    "\u89AA\u30D7\u30ED\u30BB\u30B9\u304B\u3089\u7D99\u627F\u3057\u305F\u5024\uFF08\u4F8B GIT_DIR\uFF09",
+    "lane \u306E work tree \u3068 main \u3067\u5024\u304C\u9055\u3046"
+  ],
+  resident_cases: [
+    "\u5E38\u99D0\u30D7\u30ED\u30BB\u30B9\u304C\u53E4\u3044",
+    "\u5E38\u99D0\u30D7\u30ED\u30BB\u30B9\u304C\u4E0D\u5728",
+    "lane \u306E work tree \u3068 main \u3067\u5225\u306E\u30D7\u30ED\u30BB\u30B9\u306B\u7E4B\u304C\u308B"
+  ]
+};
+var ENGLISH = {
+  state: "shared state",
+  variable: "environment variable",
+  resident: "resident process",
+  others: "also read or written by",
+  no_others: "none",
+  search_failed: "search failed",
+  state_cases: [
+    "concurrent write by another writer",
+    "another reader reads an old format or a partial state",
+    "another writer deletes it before this write"
+  ],
+  variable_cases: [
+    "unset",
+    "value inherited from the parent process (e.g. GIT_DIR)",
+    "differs between the lane work tree and main"
+  ],
+  resident_cases: [
+    "resident process is stale",
+    "resident process is absent",
+    "the lane work tree and main reach different processes"
+  ]
+};
+function fixed_head(literal) {
+  const placeholder = PLACEHOLDER.exec(literal);
+  const head = placeholder === null ? literal : literal.slice(0, placeholder.index);
+  return head.endsWith(SLASH) ? head.slice(0, -1) : head;
+}
+function bindings(content) {
+  return [...content.matchAll(CONSTANT_BINDING)].map((match) => ({
+    name: match.groups?.["name"] ?? "",
+    value: match.groups?.["value"] ?? ""
+  }));
+}
+function state_literals(content) {
+  const heads = [...content.matchAll(QUOTED_LITERAL)].map(
+    (match) => fixed_head(match.groups?.["literal"] ?? "")
+  );
+  return [...new Set(heads.filter((head) => STATE_PATH.test(head)))];
+}
+function state_paths_in(content) {
+  const declared = bindings(content);
+  return state_literals(content).map((path2) => ({
+    path: path2,
+    constants: declared.filter((binding) => fixed_head(binding.value) === path2).map((binding) => binding.name)
+  }));
+}
+function constant_keys(content) {
+  const values = new Map(bindings(content).map((binding) => [binding.name, binding.value]));
+  const keys = [...content.matchAll(ENV_CONSTANT_KEY)].map(
+    (match) => values.get(match.groups?.["key"] ?? "")
+  );
+  return keys.filter((name) => name !== void 0 && ENV_NAME.test(name));
+}
+function variables_in(content) {
+  if (!content.includes(ENV_MARK)) return [];
+  const literal = [...content.matchAll(ENV_LITERAL_KEY)].map(
+    (match) => match.groups?.["dotted"] ?? match.groups?.["quoted"] ?? ""
+  );
+  const names = [.../* @__PURE__ */ new Set([...literal, ...constant_keys(content)])];
+  return names.length === 0 ? [ENV_MARK] : names;
+}
+function environment_in(content) {
+  const residents = [...content.matchAll(RESIDENT)].map(
+    (match) => (RESIDENT_KIND.exec(match[0])?.[0] ?? "").toLowerCase()
+  );
+  return { variables: variables_in(content), residents: [...new Set(residents)] };
+}
+function wording(lang = session_language.DEFAULT_SESSION_LANG) {
+  return session_language.is_japanese(lang) ? JAPANESE : ENGLISH;
+}
+var cases_interaction = { INTERACTIONS, state_paths_in, environment_in, wording };
+
+// scripts/cases/cases-interaction-scan.ts
+var SOURCE_EXTENSIONS = /* @__PURE__ */ new Set([".ts", ".js", ".mjs", ".cjs", ".svelte"]);
+var SOURCE_PATHSPECS = [
+  "*.ts",
+  "*.js",
+  "*.mjs",
+  "*.cjs",
+  "*.svelte",
+  ":(exclude)*.test.ts"
+];
+var WHOLE_WORD = ["-w"];
+var MAX_OTHERS = 10;
+function is_source(file) {
+  return SOURCE_EXTENSIONS.has(path.extname(file));
+}
+function repo_relative(file) {
+  return path.relative(process.cwd(), path.resolve(file));
+}
+async function constant_hits(name) {
+  const result = await git_grep_hits.search(name, WHOLE_WORD, SOURCE_PATHSPECS);
+  const declaration = new RegExp(String.raw`\b(?:const|let|var)\s+${name}\b`, "u");
+  const declaring = new Set(
+    result.hits.filter((hit) => declaration.test(hit.excerpt)).map((hit) => hit.path)
+  );
+  return { ...result, hits: result.hits.filter((hit) => !declaring.has(hit.path)) };
+}
+async function shared_state(state, own) {
+  const results = await Promise.all([
+    git_grep_hits.search(state.path, [], SOURCE_PATHSPECS),
+    ...state.constants.map(async (name) => await constant_hits(name))
+  ]);
+  const sites = results.flatMap((result) => result.hits).filter((hit) => !own.has(hit.path)).map((hit) => `${hit.path}:${hit.line}`);
+  return {
+    path: state.path,
+    others: [...new Set(sites)],
+    has_failed: results.some((result) => result.has_failed)
+  };
+}
+async function scan(paths) {
+  const content = paths.filter((file) => is_source(file)).map((file) => file_reader.read_if_readable(file) ?? "").join("\n");
+  const own = new Set(paths.map((file) => repo_relative(file)));
+  const states = await Promise.all(
+    cases_interaction.state_paths_in(content).map(async (state) => await shared_state(state, own))
+  );
+  return { states, ...cases_interaction.environment_in(content) };
+}
+function interactions_of(findings) {
+  const has_environment = findings.variables.length + findings.residents.length > 0;
+  const crossed = { state: findings.states.length > 0, env: has_environment };
+  return cases_interaction.INTERACTIONS.filter((interaction) => crossed[interaction]);
+}
+function others_text(state, words) {
+  if (state.has_failed) return words.search_failed;
+  if (state.others.length === 0) return words.no_others;
+  const shown = state.others.slice(0, MAX_OTHERS);
+  const rest = state.others.length - shown.length;
+  return rest > 0 ? `${shown.join(", ")}, +${String(rest)}` : shown.join(", ");
+}
+function line(label, subject, owed) {
+  return `${label} ${subject}: ${owed.join(" / ")}`;
+}
+function lines_for(findings, lang) {
+  const words = cases_interaction.wording(lang);
+  const state_lines = findings.states.map(
+    (state) => line(
+      words.state,
+      `\`${state.path}\` (${words.others}: ${others_text(state, words)})`,
+      words.state_cases
+    )
+  );
+  const variable_lines = findings.variables.map(
+    (name) => line(words.variable, `\`${name}\``, words.variable_cases)
+  );
+  const resident_lines = findings.residents.map(
+    (name) => line(words.resident, `\`${name}\``, words.resident_cases)
+  );
+  return [...state_lines, ...variable_lines, ...resident_lines];
+}
+var cases_interaction_scan = { scan, interactions_of, lines_for };
+
+// scripts/cases/cases-logic.ts
+var NONE = "none";
+var BOUNDARIES = [
+  {
+    boundary: "network",
+    // Keyed on a networking API, never a bare URL: a URL in a comment, a doc link or a
+    // string constant crosses no boundary at test time, so matching `https://` text alone
+    // would fire `network` on every markdown edit and defeat the oracle.
+    pattern: /\b(?:fetch|axios|undici|node:https?|XMLHttpRequest)\b/u,
+    cases: ["\u975E200", "\u30BF\u30A4\u30E0\u30A2\u30A6\u30C8", "\u63A5\u7D9A\u65AD", "\u7A7A\u30EC\u30B9\u30DD\u30F3\u30B9", "\u4E0D\u6B63JSON", "\u30EC\u30FC\u30C8\u5236\u9650"],
+    english_cases: [
+      "non-200",
+      "timeout",
+      "connection drop",
+      "empty response",
+      "invalid JSON",
+      "rate limit"
+    ]
+  },
+  {
+    boundary: "process",
+    // The module name and the `*Sync` forms are unambiguous; the short verbs (`exec`, `spawn`,
+    // `execFile`) require a call paren, so prose like "exec the plan" or a local named `exec`
+    // no longer fires the boundary.
+    pattern: /\b(?:child_process|execSync|execFileSync|spawnSync)\b|\b(?:exec|execFile|spawn)\s*\(/u,
+    cases: ["\u975E\u30BC\u30ED\u7D42\u4E86", "\u30BF\u30A4\u30E0\u30A2\u30A6\u30C8", "\u6A19\u6E96\u30A8\u30E9\u30FC\u51FA\u529B", "\u5B9F\u884C\u30D5\u30A1\u30A4\u30EB\u4E0D\u5728"],
+    english_cases: ["non-zero exit", "timeout", "stderr output", "missing executable"]
+  },
+  {
+    boundary: "fs",
+    // Same rule as process: the module names and `*Sync` forms are unambiguous, and the short
+    // verbs (`readFile`, `writeFile`, `mkdir`, `unlink`, `readdir`, `rm`) require a call paren,
+    // so prose like "rm the old files" no longer fires the boundary.
+    pattern: /\b(?:node:fs|fs\/promises|readFileSync|writeFileSync)\b|\b(?:readFile|writeFile|mkdir|unlink|readdir|rm)\s*\(/u,
+    cases: ["\u30D5\u30A1\u30A4\u30EB\u4E0D\u5728", "\u6A29\u9650\u30A8\u30E9\u30FC", "\u7A7A\u30D5\u30A1\u30A4\u30EB", "\u4E0D\u6B63\u306A\u5185\u5BB9", "\u4E26\u884C\u66F8\u304D\u8FBC\u307F"],
+    english_cases: [
+      "missing file",
+      "permission error",
+      "empty file",
+      "invalid content",
+      "concurrent write"
+    ]
+  },
+  {
+    boundary: "time",
+    // The absence boundary: a change that coordinates over time — timers, schedules, retries,
+    // heartbeats — owes the cases where the awaited thing never happens, which no diff of an I/O
+    // call can surface. Same over-firing discipline as process and fs: the
+    // verbs (`setInterval`, `schedule`, `retry`) require a call paren so prose like "schedule the
+    // release" no longer fires, while the domain nouns (`cron`, `heartbeat`, `watchdog`, `liveness`)
+    // are unambiguous enough in source to match bare.
+    pattern: /\b(?:setInterval|setTimeout|setImmediate|schedule|reschedule|retry)\s*\(|\b(?:cron|crontab|heartbeat|watchdog|liveness)\b/u,
+    cases: ["\u671F\u5F85\u3057\u305F\u4E8B\u8C61\u304C\u5230\u6765\u3057\u306A\u3044", "\u671F\u9650\u8D85\u904E", "\u91CD\u8907\u767A\u706B", "\u518D\u8A66\u884C\u304C\u5C3D\u304D\u308B"],
+    english_cases: [
+      "awaited event never arrives",
+      "deadline exceeded",
+      "duplicate firing",
+      "retries exhausted"
+    ]
+  }
+];
+function read_file(path2) {
+  return file_reader.read_if_readable(path2) ?? "";
+}
+function boundaries_in(paths) {
+  const content = paths.map((path2) => read_file(path2)).join("\n");
+  return BOUNDARIES.filter((definition) => definition.pattern.test(content)).map(
+    (definition) => definition.boundary
+  );
+}
+function cases_for(boundaries, lang = session_language.DEFAULT_SESSION_LANG) {
+  const is_japanese = session_language.is_japanese(lang);
+  return BOUNDARIES.filter((definition) => boundaries.includes(definition.boundary)).flatMap(
+    (definition) => is_japanese ? definition.cases : definition.english_cases
+  );
+}
+var VOCABULARY = [
+  ...BOUNDARIES.map((definition) => definition.boundary),
+  ...cases_interaction.INTERACTIONS,
+  NONE
+];
+var cases = { NONE, VOCABULARY, boundaries_in, cases_for };
+
+export {
+  cases_interaction_scan,
+  cases
+};