@wrongstack/plugins 0.295.0 → 0.296.2

package/dist/secret-scanner.js

@@ -1,20 +1,61 @@
-// src/secret-scanner/index.ts
-var BASE_PATTERNS = [
+// src/runtime/local-bin.ts
+import { buildWin32CmdShimInvocation, resolveWin32Command } from "@wrongstack/tools/win32";
+
+// src/runtime/handles.ts
+function releaseHandle(off) {
+  if (off) {
+    try {
+      off();
+    } catch {
+    }
+  }
+  return null;
+}
+
+// src/runtime/index.ts
+var MAX_BUFFER_BYTES = 16 * 1024 * 1024;
+
+// src/runtime/credential-patterns.ts
+var CREDENTIAL_PATTERNS = [
   // LLM provider keys
   {
     type: "anthropic_key",
     regex: /(?<![A-Za-z0-9])sk-ant-api\d+-[A-Za-z0-9_-]{20,}(?![A-Za-z0-9])/g
   },
-  { type: "openai_key", regex: /(?<![A-Za-z0-9])sk-(?:proj-)?[A-Za-z0-9_-]{20,}(?![A-Za-z0-9])/g },
-  // GitHub
+  { type: "openai_key", regex: /(?<![A-Za-z0-9])sk-(?!ant)(?:proj-)?[A-Za-z0-9_-]{20,}(?![A-Za-z0-9])/g },
+  // GitHub. `ghp_` is only the personal-access-token prefix — the OAuth
+  // (`gho_`), user-to-server (`ghu_`), server-to-server (`ghs_`) and
+  // refresh (`ghr_`) tokens grant the same or broader access and were
+  // previously not detected at all.
   { type: "github_pat", regex: /(?<![A-Za-z0-9])ghp_[A-Za-z0-9]{36,}(?![A-Za-z0-9])/g },
+  {
+    type: "github_oauth_token",
+    regex: /(?<![A-Za-z0-9])gh[ousr]_[A-Za-z0-9]{36,}(?![A-Za-z0-9])/g
+  },
   { type: "github_pat_v2", regex: /(?<![A-Za-z0-9])github_pat_[A-Za-z0-9_]{50,}(?![A-Za-z0-9])/g },
+  // GitLab
+  { type: "gitlab_pat", regex: /(?<![A-Za-z0-9])glpat-[A-Za-z0-9_-]{20,}(?![A-Za-z0-9_-])/g },
+  {
+    type: "gitlab_runner_token",
+    regex: /(?<![A-Za-z0-9])glrt-[A-Za-z0-9_-]{20,}(?![A-Za-z0-9_-])/g
+  },
+  // npm — a leaked publish token is a supply-chain compromise.
+  { type: "npm_token", regex: /(?<![A-Za-z0-9])npm_[A-Za-z0-9]{36}(?![A-Za-z0-9])/g },
   // AWS
   { type: "aws_access_key", regex: /(?<![A-Za-z0-9])AKIA[0-9A-Z]{16}(?![A-Za-z0-9])/g },
   // GCP
   { type: "gcp_key", regex: /(?<![A-Za-z0-9])AIza[0-9A-Za-z_-]{35}(?![A-Za-z0-9])/g },
-  // Slack
-  { type: "slack_token", regex: /(?<![A-Za-z0-9-])xox[abpos]-[A-Za-z0-9-]{10,}(?![A-Za-z0-9-])/g },
+  // Slack. `xoxe` (token-rotation) and `xapp` (app-level) were missing;
+  // both are as sensitive as the bot/user tokens already covered.
+  {
+    type: "slack_token",
+    regex: /(?<![A-Za-z0-9-])xox[abposer]-[A-Za-z0-9-]{10,}(?![A-Za-z0-9-])/g
+  },
+  { type: "slack_app_token", regex: /(?<![A-Za-z0-9-])xapp-\d-[A-Za-z0-9-]{10,}(?![A-Za-z0-9-])/g },
+  {
+    type: "slack_webhook",
+    regex: /https:\/\/hooks\.slack\.com\/services\/T[A-Za-z0-9_-]+\/B[A-Za-z0-9_-]+\/[A-Za-z0-9]{16,}/g
+  },
   // Stripe
   {
     type: "stripe_key",
@@ -25,7 +66,7 @@ var BASE_PATTERNS = [
   // Telegram
   {
     type: "telegram_bot_token",
-    regex: /\/bot\d+:[A-Za-z0-9_-]{20,}(?![A-Za-z0-9_-])/g
+    regex: /(?:(?<![A-Za-z0-9_])|(?<=(?:^|[^A-Za-z0-9_])bot))\d+:[A-Za-z0-9_-]{20,}(?![A-Za-z0-9_-])/g
   },
   // JWT
   {
@@ -35,35 +76,93 @@ var BASE_PATTERNS = [
   // Private keys
   {
     type: "private_key",
-    regex: /(?:^|\n)-----BEGIN (?:RSA|EC|OPENSSH|DSA|PGP)? ?PRIVATE KEY-----[\s\S]*?-----END (?:RSA|EC|OPENSSH|DSA|PGP)? ?PRIVATE KEY-----(?!\S)/g
+    regex: /(?:^|\n)(?:-----BEGIN (?:RSA|EC|OPENSSH|DSA)? ?PRIVATE KEY-----[\s\S]*?-----END (?:RSA|EC|OPENSSH|DSA)? ?PRIVATE KEY-----|-----BEGIN PGP PRIVATE KEY BLOCK-----[\s\S]*?-----END PGP PRIVATE KEY BLOCK-----)(?!\S)/g
   },
   // AI/ML provider tokens
   { type: "huggingface_token", regex: /(?<![A-Za-z0-9])hf_[A-Za-z0-9]{34}(?![A-Za-z0-9])/g },
   { type: "replicate_token", regex: /(?<![A-Za-z0-9])r8_[A-Za-z0-9]{40,}(?![A-Za-z0-9])/g },
   { type: "perplexity_key", regex: /(?<![A-Za-z0-9])pplx-[A-Za-z0-9]{40,}(?![A-Za-z0-9])/g },
   { type: "groq_key", regex: /(?<![A-Za-z0-9])gsk_[A-Za-z0-9]{40,}(?![A-Za-z0-9])/g },
+  // SaaS / infrastructure tokens — each grants API access on the user's
+  // account, and each was previously invisible to this gate.
+  { type: "sendgrid_key", regex: /(?<![A-Za-z0-9])SG\.[A-Za-z0-9_-]{20,}\.[A-Za-z0-9_-]{20,}(?![A-Za-z0-9_-])/g },
+  { type: "digitalocean_token", regex: /(?<![A-Za-z0-9])dop_v1_[a-f0-9]{64}(?![A-Za-z0-9])/g },
+  { type: "doppler_token", regex: /(?<![A-Za-z0-9])dp\.(?:pt|st|sa|scim|audit)\.[A-Za-z0-9]{40,}(?![A-Za-z0-9])/g },
+  { type: "shopify_token", regex: /(?<![A-Za-z0-9])shp(?:at|ca|pa|ss)_[a-fA-F0-9]{32}(?![A-Za-z0-9])/g },
+  { type: "docker_pat", regex: /(?<![A-Za-z0-9])dckr_pat_[A-Za-z0-9_-]{20,}(?![A-Za-z0-9_-])/g },
+  { type: "linear_key", regex: /(?<![A-Za-z0-9])lin_api_[A-Za-z0-9]{40,}(?![A-Za-z0-9])/g },
+  { type: "atlassian_token", regex: /(?<![A-Za-z0-9])ATATT3[A-Za-z0-9_\-=]{40,}(?![A-Za-z0-9_\-=])/g },
+  { type: "square_token", regex: /(?<![A-Za-z0-9])(?:sq0(?:atp|csp)-|EAAA)[A-Za-z0-9_-]{20,}(?![A-Za-z0-9_-])/g },
+  {
+    type: "azure_storage_key",
+    regex: /AccountKey=[A-Za-z0-9+/]{80,}={0,2}/g
+  },
+  {
+    type: "google_oauth_client_secret",
+    regex: /(?<![A-Za-z0-9_-])GOCSPX-[A-Za-z0-9_-]{20,}(?![A-Za-z0-9_-])/g
+  },
   // Bearer tokens
   {
     type: "bearer_token",
-    regex: /(?:^|[^A-Za-z0-9_.~+/-])Bearer\s+[A-Za-z0-9._~+/-]{12,512}=*(?![A-Za-z0-9._~+/-])/g
+    regex: /(?<![A-Za-z0-9_.~+/-])Bearer\s+[A-Za-z0-9._~+/-]{12,512}=*(?![A-Za-z0-9._~+/-])/g
+  },
+  // Database URIs. Require password-bearing user-info; credential-free values stay scannable.
+  { type: "mongodb_uri", regex: /mongodb(?:\+srv)?:\/\/[^\s:/@"'`]*:[^\s/@"'`]+@[^\s"'`]+/g },
+  {
+    type: "postgres_uri",
+    // Query parsers decode percent-encoded parameter names. Recognize each
+    // encoded character in `password` so mixed forms such as `pass%77ord`
+    // cannot bypass detection while keeping the scan strictly bounded.
+    regex: /postgres(?:ql)?:\/\/(?:[^\s:/@"'`]*:[^\s/@"'`]+@[^\s"'`]+|[^&\s?"'`#]{1,2048}\?(?:(?!(?:p|%70)(?:a|%61)(?:s|%73)(?:s|%73)(?:w|%77)(?:o|%6[fF])(?:r|%72)(?:d|%64)=)[^&\s#"'`]{1,256}&){0,32}(?:p|%70)(?:a|%61)(?:s|%73)(?:s|%73)(?:w|%77)(?:o|%6[fF])(?:r|%72)(?:d|%64)=[^&\s#"'`]{1,4096})/g
   },
-  // Database URIs
-  { type: "mongodb_uri", regex: /mongodb(?:\+srv)?:\/\/[^\s"'`]+/g },
-  { type: "postgres_uri", regex: /postgres(?:ql)?:\/\/[^\s"'`]+/g },
-  { type: "mysql_uri", regex: /mysql:\/\/[^\s"'`]+/g },
-  { type: "redis_uri", regex: /redis:\/\/[^\s"'`]+/g }
+  { type: "mysql_uri", regex: /mysql:\/\/[^\s:/@"'`]*:[^\s/@"'`]+@[^\s"'`]+/g },
+  { type: "redis_uri", regex: /redis:\/\/[^\s:/@"'`]*:[^\s/@"'`]+@[^\s"'`]+/g }
 ];
+function cloneCredentialPatterns() {
+  return CREDENTIAL_PATTERNS.map((p) => ({
+    type: p.type,
+    regex: new RegExp(p.regex.source, p.regex.flags)
+  }));
+}
+
+// src/secret-scanner/index.ts
+var BASE_PATTERNS = cloneCredentialPatterns();
 var PATTERNS = [...BASE_PATTERNS];
 var patternCacheKey = "";
+var GROUP_INDEX_OF_PATTERN = [];
 var COMBINED_REGEX = buildCombinedRegex(PATTERNS);
-var RE_DOS_MAX_SCAN_LENGTH = 1e5;
+var SCAN_WINDOW_LENGTH = 1e5;
+var SCAN_WINDOW_OVERLAP = 4096;
+var MAX_TOTAL_SCAN_LENGTH = 8 * 1024 * 1024;
+var TOO_LARGE_MARKER = "unscannable_oversized_input";
 var RE_DOS_TIMEOUT_MS = 100;
+function countCaptureGroups(source) {
+  try {
+    return new RegExp(`${source}|`).exec("").length - 1;
+  } catch {
+    return 0;
+  }
+}
+function patternTypeForGroups(groups) {
+  for (let i = 0; i < PATTERNS.length; i++) {
+    const at = GROUP_INDEX_OF_PATTERN[i];
+    if (at !== void 0 && groups[at] !== void 0) return PATTERNS[i].type;
+  }
+  return void 0;
+}
 function buildCombinedRegex(patterns) {
-  const newCacheKey = JSON.stringify(patterns.map((p) => p.type));
+  const newCacheKey = JSON.stringify(patterns.map((p) => [p.type, p.regex.source]));
   if (newCacheKey === patternCacheKey && COMBINED_REGEX) {
     return COMBINED_REGEX;
   }
   patternCacheKey = newCacheKey;
+  const offsets = [];
+  let cursor = 0;
+  for (const p of patterns) {
+    offsets.push(cursor);
+    cursor += 1 + countCaptureGroups(p.regex.source);
+  }
+  GROUP_INDEX_OF_PATTERN = offsets;
   return new RegExp(patterns.map((p) => `(${p.regex.source})`).join("|"), "g");
 }
 var state = {
@@ -81,29 +180,37 @@ var state = {
   /** PostToolUse hook handle so teardown can unregister. */
   postHookUnregister: null
 };
-function findMatches(text) {
-  if (!text) return [];
-  if (text.length > RE_DOS_MAX_SCAN_LENGTH) return [];
-  const found = /* @__PURE__ */ new Set();
+function scanWindow(window, found, startTime) {
   COMBINED_REGEX.lastIndex = 0;
   let m;
-  const startTime = performance.now();
-  while ((m = COMBINED_REGEX.exec(text)) !== null) {
+  while ((m = COMBINED_REGEX.exec(window)) !== null) {
     if (performance.now() - startTime > RE_DOS_TIMEOUT_MS) {
       throw new Error(
-        `secret-scanner: ReDoS timeout \u2014 regex scan exceeded ${RE_DOS_TIMEOUT_MS}ms on ${text.length}-char input`
+        `secret-scanner: ReDoS timeout \u2014 regex scan exceeded ${RE_DOS_TIMEOUT_MS}ms on ${window.length}-char window`
       );
     }
-    for (let i = 0; i < PATTERNS.length; i++) {
-      if (m[i + 1] !== void 0) {
-        found.add(PATTERNS[i].type);
-        break;
-      }
-    }
+    const type = patternTypeForGroups(m.slice(1));
+    if (type !== void 0) found.add(type);
     if (m.index === COMBINED_REGEX.lastIndex) {
       COMBINED_REGEX.lastIndex += 1;
     }
   }
+}
+function findMatches(text) {
+  if (!text) return [];
+  const found = /* @__PURE__ */ new Set();
+  const startTime = performance.now();
+  if (text.length <= SCAN_WINDOW_LENGTH) {
+    scanWindow(text, found, startTime);
+    return Array.from(found).sort();
+  }
+  if (text.length > MAX_TOTAL_SCAN_LENGTH) {
+    return [TOO_LARGE_MARKER];
+  }
+  const stride = SCAN_WINDOW_LENGTH - SCAN_WINDOW_OVERLAP;
+  for (let offset = 0; offset < text.length; offset += stride) {
+    scanWindow(text.slice(offset, offset + SCAN_WINDOW_LENGTH), found, startTime);
+  }
   return Array.from(found).sort();
 }
 function scanInput(input, depth = 0) {
@@ -129,30 +236,55 @@ function scanInput(input, depth = 0) {
   }
   return null;
 }
+function redactString(text) {
+  if (text.length > SCAN_WINDOW_LENGTH) {
+    return { ok: false, reason: "oversized_input" };
+  }
+  const startTime = performance.now();
+  let cursor = 0;
+  let output = "";
+  COMBINED_REGEX.lastIndex = 0;
+  let match;
+  while ((match = COMBINED_REGEX.exec(text)) !== null) {
+    if (performance.now() - startTime > RE_DOS_TIMEOUT_MS) {
+      return { ok: false, reason: "oversized_input" };
+    }
+    const type = patternTypeForGroups(match.slice(1));
+    output += text.slice(cursor, match.index);
+    output += `[REDACTED:${type ?? "unknown"}]`;
+    cursor = COMBINED_REGEX.lastIndex;
+    if (match.index === COMBINED_REGEX.lastIndex) {
+      COMBINED_REGEX.lastIndex += 1;
+    }
+  }
+  if (cursor === 0) return { ok: true, value: text };
+  return { ok: true, value: output + text.slice(cursor) };
+}
 function redactInput(input, depth = 0) {
-  if (input === null || input === void 0) return input;
-  if (depth > 50) return input;
+  if (input === null || input === void 0) return { ok: true, value: input };
+  if (depth > 50) return { ok: false, reason: "maximum_depth_exceeded" };
   if (typeof input === "string") {
-    return input.replace(COMBINED_REGEX, (_match, ...groups) => {
-      for (let i = 0; i < PATTERNS.length; i++) {
-        if (groups[i] !== void 0) {
-          return `[REDACTED:${PATTERNS[i].type}]`;
-        }
-      }
-      return "[REDACTED:unknown]";
-    });
+    return redactString(input);
   }
   if (Array.isArray(input)) {
-    return input.map((item) => redactInput(item, depth + 1));
+    const out = [];
+    for (const item of input) {
+      const redacted = redactInput(item, depth + 1);
+      if (!redacted.ok) return redacted;
+      out.push(redacted.value);
+    }
+    return { ok: true, value: out };
   }
   if (typeof input === "object") {
     const out = {};
     for (const [k, v] of Object.entries(input)) {
-      out[k] = redactInput(v, depth + 1);
+      const redacted = redactInput(v, depth + 1);
+      if (!redacted.ok) return redacted;
+      out[k] = redacted.value;
     }
-    return out;
+    return { ok: true, value: out };
   }
-  return input;
+  return { ok: true, value: input };
 }
 var DEFAULTS = {
   matcher: "bash|write|edit",
@@ -212,20 +344,21 @@ function buildHook(cfg, log) {
     }
     if (cfg.mode === "redact") {
       const redacted = redactInput(input.toolInput);
-      if (redacted !== null && typeof redacted === "object" && !Array.isArray(redacted)) {
+      if (redacted.ok && redacted.value !== null && typeof redacted.value === "object" && !Array.isArray(redacted.value)) {
         state.redactCount += 1;
         log.info(`[secret-scanner] redacted ${toolName} \u2014 matched: ${summary}`);
         return {
           decision: "allow",
-          modifiedInput: redacted,
+          modifiedInput: redacted.value,
           additionalContext: `secret-scanner: redacted ${matched.length} credential pattern(s) from the ${toolName} arguments before execution.`
         };
       }
       state.blockCount += 1;
       state.lastBlock = { toolName, matchedTypes: matched, when };
+      const detail = !redacted.ok ? redacted.reason === "oversized_input" ? "an input field exceeds the safe scan limit" : "the input exceeds the safe nesting depth" : "the input has a non-object shape";
       return {
         decision: "block",
-        reason: `secret-scanner: cannot safely redact '${toolName}' input (non-object shape); refusing to run.`
+        reason: `secret-scanner: cannot safely redact '${toolName}' because ${detail}; refusing to run.`
       };
     }
     state.allowCount += 1;
@@ -243,10 +376,21 @@ function buildPostHook(cfg, log) {
     const matched = findMatches(result.content);
     if (matched.length === 0) return;
     const toolName = input.toolName ?? "unknown";
-    const summary = matched.join(", ");
+    const oversized = matched.includes(TOO_LARGE_MARKER);
+    const credentialMatches = matched.filter((type) => type !== TOO_LARGE_MARKER);
+    if (oversized && credentialMatches.length === 0) {
+      log.warn(
+        `[secret-scanner] POST-TOOL UNSCANNABLE: ${toolName} output exceeds ${MAX_TOTAL_SCAN_LENGTH} characters`
+      );
+      return {
+        additionalContext: `
+\u26A0\uFE0F secret-scanner: the output of '${toolName}' exceeds the safe scan limit and could not be inspected for plaintext credentials. Do not treat this output as verified clean; avoid echoing, storing, committing, or transmitting it until it can be reviewed in smaller bounded sections.`
+      };
+    }
+    const summary = credentialMatches.join(", ");
     const when = (/* @__PURE__ */ new Date()).toISOString();
     state.leakCount += 1;
-    state.lastLeak = { toolName, matchedTypes: matched, when };
+    state.lastLeak = { toolName, matchedTypes: credentialMatches, when };
     log.warn(`[secret-scanner] POST-TOOL LEAK: ${toolName} output matched ${summary}`);
     return {
       additionalContext: `
@@ -308,8 +452,8 @@ var plugin = {
     state.leakCount = 0;
     state.lastBlock = null;
     state.lastLeak = null;
-    state.hookUnregister = null;
-    state.postHookUnregister = null;
+    state.hookUnregister = releaseHandle(state.hookUnregister);
+    state.postHookUnregister = releaseHandle(state.postHookUnregister);
     const cfg = readConfig(api.config.extensions?.["secret-scanner"]);
     PATTERNS = [...BASE_PATTERNS];
     for (const cp of cfg.customPatterns) {

package/dist/security-hotspot-scanner/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/security-hotspot-scanner/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAIH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AA6QrD,QAAA,MAAM,MAAM,EAAE,MAkQb,CAAC;eAEa,MAAM"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/security-hotspot-scanner/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAIH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AAkRrD,QAAA,MAAM,MAAM,EAAE,MAkQb,CAAC;eAEa,MAAM"}

package/dist/security-hotspot-scanner.js

@@ -4,6 +4,137 @@ import { isAbsolute as isAbsolute2, relative as relative2, resolve as resolve2 }
 
 // src/runtime/index.ts
 import { basename, extname, isAbsolute, relative, resolve } from "node:path";
+
+// src/runtime/local-bin.ts
+import { buildWin32CmdShimInvocation, resolveWin32Command } from "@wrongstack/tools/win32";
+
+// src/runtime/bounded-map.ts
+var BoundedMap = class {
+  map = /* @__PURE__ */ new Map();
+  max;
+  ttlMs;
+  now;
+  /** Entries dropped to stay under `max`. Surfaced by plugin health(). */
+  evictions = 0;
+  constructor(options) {
+    const normalizedMax = Math.floor(options.max);
+    this.max = Number.isSafeInteger(normalizedMax) ? Math.max(1, normalizedMax) : 1;
+    this.ttlMs = options.ttlMs;
+    this.now = options.now ?? Date.now;
+  }
+  expired(entry) {
+    return this.ttlMs !== void 0 && this.now() - entry.storedAt > this.ttlMs;
+  }
+  get(key) {
+    const entry = this.map.get(key);
+    if (entry === void 0) return void 0;
+    if (this.expired(entry)) {
+      this.map.delete(key);
+      return void 0;
+    }
+    this.map.delete(key);
+    this.map.set(key, entry);
+    return entry.value;
+  }
+  /**
+   * Read without promoting the key to most-recently-used. Use for
+   * diagnostics that must not perturb the eviction order.
+   */
+  peek(key) {
+    const entry = this.map.get(key);
+    if (entry === void 0 || this.expired(entry)) return void 0;
+    return entry.value;
+  }
+  has(key) {
+    const entry = this.map.get(key);
+    if (entry === void 0) return false;
+    if (this.expired(entry)) {
+      this.map.delete(key);
+      return false;
+    }
+    return true;
+  }
+  set(key, value) {
+    this.map.delete(key);
+    this.map.set(key, { value, storedAt: this.now() });
+    while (this.map.size > this.max) {
+      const coldest = this.map.keys().next().value;
+      if (coldest === void 0) break;
+      this.map.delete(coldest);
+      this.evictions += 1;
+    }
+    return this;
+  }
+  delete(key) {
+    return this.map.delete(key);
+  }
+  clear() {
+    this.map.clear();
+    this.evictions = 0;
+  }
+  get size() {
+    return this.map.size;
+  }
+  /** How many entries have been dropped to respect `max`, since the last clear. */
+  get evictionCount() {
+    return this.evictions;
+  }
+  /** Drop every expired entry. Cheap enough to call from a status tool. */
+  prune() {
+    if (this.ttlMs === void 0) return 0;
+    let removed = 0;
+    for (const [key, entry] of this.map) {
+      if (this.expired(entry)) {
+        this.map.delete(key);
+        removed += 1;
+      }
+    }
+    return removed;
+  }
+  /** Live (non-expired) entries, coldest first. */
+  *entries() {
+    for (const [key, entry] of this.map) {
+      if (!this.expired(entry)) yield [key, entry.value];
+    }
+  }
+  [Symbol.iterator]() {
+    return this.entries();
+  }
+};
+var BoundedSet = class {
+  inner;
+  constructor(options) {
+    this.inner = new BoundedMap(options);
+  }
+  has(value) {
+    return this.inner.has(value);
+  }
+  add(value) {
+    this.inner.set(value, true);
+    return this;
+  }
+  delete(value) {
+    return this.inner.delete(value);
+  }
+  clear() {
+    this.inner.clear();
+  }
+  get size() {
+    return this.inner.size;
+  }
+  /** How many entries have been dropped to respect `max`, since the last clear. */
+  get evictionCount() {
+    return this.inner.evictionCount;
+  }
+  *values() {
+    for (const [key] of this.inner) yield key;
+  }
+  [Symbol.iterator]() {
+    return this.values();
+  }
+};
+
+// src/runtime/index.ts
 var MAX_BUFFER_BYTES = 16 * 1024 * 1024;
 function hasLeadingDash(arg) {
   return arg.length > 0 && arg.startsWith("-");
@@ -30,7 +161,7 @@ var state = {
   skippedCount: 0,
   blockedCount: 0,
   lastResult: null,
-  knownHotspots: /* @__PURE__ */ new Set(),
+  knownHotspots: new BoundedSet({ max: 5e3 }),
   hookUnregister: null
 };
 var DEFAULTS = {

package/dist/semantic-search-indexer/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/semantic-search-indexer/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAKH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AA6brD,QAAA,MAAM,MAAM,EAAE,MA6Nb,CAAC;eAEa,MAAM"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/semantic-search-indexer/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAKH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AAqcrD,QAAA,MAAM,MAAM,EAAE,MA6Nb,CAAC;eAEa,MAAM"}

package/dist/semantic-search-indexer.js

@@ -1,7 +1,9 @@
 // src/semantic-search-indexer/index.ts
 import * as fs from "node:fs/promises";
 import { isAbsolute, relative, resolve } from "node:path";
+import { DEFAULT_WALK_IGNORE_DIRS } from "@wrongstack/core/utils";
 var API_VERSION = "^0.1.10";
+var escapeRegex = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 var state = {
   index: null,
   cachedPath: null,
@@ -45,7 +47,11 @@ var DEFAULTS = {
     ".scss",
     ".html"
   ],
-  excludePatterns: ["node_modules", "\\.git", "\\.wrongstack", "\\.temp_files", "coverage", "dist"],
+  excludePatterns: [
+    ...DEFAULT_WALK_IGNORE_DIRS.map(escapeRegex),
+    "\\.wrongstack",
+    "\\.temp_files"
+  ],
   maxFileBytes: 1e6,
   defaultLimit: 10,
   minTokenLength: 2,

package/dist/semver-bump/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/semver-bump/index.ts"],"names":[],"mappings":"AAEA;;;;;;;GAOG;AACH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AAuCrD,KAAK,QAAQ,GAAG,OAAO,GAAG,OAAO,GAAG,OAAO,GAAG,MAAM,CAAC;AAErD,UAAU,kBAAkB;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC3B,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,OAAO,CAAC;CACnB;AAqGD;+DAC+D;AAC/D,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC,kBAAkB,EAAE,MAAM,CAAC,CAQnF;AAmBD,wBAAgB,aAAa,CAAC,OAAO,EAAE,kBAAkB,EAAE,GAAG,QAAQ,CAIrE;AAmED,QAAA,MAAM,MAAM,EAAE,MAgcb,CAAC;eAEa,MAAM"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/semver-bump/index.ts"],"names":[],"mappings":"AAEA;;;;;;;GAOG;AACH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AAuCrD,KAAK,QAAQ,GAAG,OAAO,GAAG,OAAO,GAAG,OAAO,GAAG,MAAM,CAAC;AAErD,UAAU,kBAAkB;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC3B,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,OAAO,CAAC;CACnB;AAqGD;+DAC+D;AAC/D,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC,kBAAkB,EAAE,MAAM,CAAC,CAQnF;AAmBD,wBAAgB,aAAa,CAAC,OAAO,EAAE,kBAAkB,EAAE,GAAG,QAAQ,CAIrE;AAmED,QAAA,MAAM,MAAM,EAAE,MA0db,CAAC;eAEa,MAAM"}

package/dist/semver-bump.js

@@ -293,10 +293,29 @@ var plugin = {
           }
         }
       } else {
+        const pending = [];
         for (const manifest of changed) {
-          const pkgData = JSON.parse(await readFile(manifest, "utf-8"));
+          let pkgData;
+          try {
+            pkgData = JSON.parse(await readFile(manifest, "utf-8"));
+          } catch (err) {
+            return {
+              ok: false,
+              error: `cannot bump: ${manifest} is not readable as JSON (${toErrorMessage(err)}). No manifests were modified.`
+            };
+          }
+          if (!pkgData || typeof pkgData !== "object") {
+            return {
+              ok: false,
+              error: `cannot bump: ${manifest} does not contain a JSON object. No manifests were modified.`
+            };
+          }
           pkgData.version = newVersion;
-          await writeFile(manifest, JSON.stringify(pkgData, null, 2) + "\n", "utf-8");
+          pending.push({ path: manifest, contents: `${JSON.stringify(pkgData, null, 2)}
+` });
+        }
+        for (const { path, contents } of pending) {
+          await writeFile(path, contents, "utf-8");
         }
       }
       try {

package/dist/session-recap/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/session-recap/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AACH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AA4MrD,QAAA,MAAM,MAAM,EAAE,MA4Yb,CAAC;eAEa,MAAM"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/session-recap/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AACH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AA6MrD,QAAA,MAAM,MAAM,EAAE,MA4Yb,CAAC;eAEa,MAAM"}

package/dist/session-recap.js

@@ -1,3 +1,20 @@
+// src/runtime/local-bin.ts
+import { buildWin32CmdShimInvocation, resolveWin32Command } from "@wrongstack/tools/win32";
+
+// src/runtime/handles.ts
+function releaseHandle(off) {
+  if (off) {
+    try {
+      off();
+    } catch {
+    }
+  }
+  return null;
+}
+
+// src/runtime/index.ts
+var MAX_BUFFER_BYTES = 16 * 1024 * 1024;
+
 // src/session-recap/index.ts
 var state = {
   recapsPublished: 0,
@@ -155,7 +172,7 @@ var plugin = {
     state.commitCount = 0;
     state.startedAt = null;
     state.lastActivityAt = null;
-    state.stopHookUnregister = null;
+    state.stopHookUnregister = releaseHandle(state.stopHookUnregister);
     for (const off of state.eventUnsubscribers) {
       try {
         off();

package/dist/smart-rename/index.d.ts

@@ -19,6 +19,8 @@
  * @public
  */
 import type { Plugin } from '@wrongstack/core/types';
+/** True when `name` is something this tool may safely substitute. */
+export declare function isIdentifier(name: string): boolean;
 declare const plugin: Plugin;
 export default plugin;
 //# sourceMappingURL=index.d.ts.map

package/dist/smart-rename/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/smart-rename/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAIH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AA0FrD,QAAA,MAAM,MAAM,EAAE,MAqIb,CAAC;eAEa,MAAM"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/smart-rename/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAIH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AAkFrD,qEAAqE;AACrE,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAElD;AAmCD,QAAA,MAAM,MAAM,EAAE,MAgJb,CAAC;eAEa,MAAM"}

package/dist/smart-rename.js

@@ -38,8 +38,15 @@ function relativePath(p) {
 function escapeRegex(s) {
   return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
+var IDENTIFIER_RE = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
+function isIdentifier(name) {
+  return IDENTIFIER_RE.test(name);
+}
 function renameInContent(content, oldName, newName) {
-  const re = new RegExp(`\\b${escapeRegex(oldName)}\\b`, "g");
+  const re = new RegExp(
+    `(?<![A-Za-z0-9_$])${escapeRegex(oldName)}(?![A-Za-z0-9_$])`,
+    "g"
+  );
   let replacements = 0;
   const preview = content.replace(re, () => {
     replacements++;
@@ -101,6 +108,12 @@ var plugin = {
         if (!newName || typeof newName !== "string" || newName.length === 0) {
           return { ok: false, error: "newName is required" };
         }
+        if (!isIdentifier(oldName)) {
+          return { ok: false, error: `oldName "${oldName}" is not a valid identifier` };
+        }
+        if (!isIdentifier(newName)) {
+          return { ok: false, error: `newName "${newName}" is not a valid identifier` };
+        }
         if (!withinProject(rawPath)) {
           return { ok: false, error: "path is outside the project root" };
         }
@@ -166,5 +179,6 @@ var plugin = {
 };
 var smart_rename_default = plugin;
 export {
-  smart_rename_default as default
+  smart_rename_default as default,
+  isIdentifier
 };

package/dist/spec-linker/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/spec-linker/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AAGH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AAwPrD,QAAA,MAAM,MAAM,EAAE,MAuOb,CAAC;eAEa,MAAM"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/spec-linker/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AAGH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AAyPrD,QAAA,MAAM,MAAM,EAAE,MAuOb,CAAC;eAEa,MAAM"}