@wrongstack/plugins 0.293.0 → 0.295.1

package/dist/secret-scanner.js

@@ -1,20 +1,44 @@
-// src/secret-scanner/index.ts
-var BASE_PATTERNS = [
+// 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 +49,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,29 +59,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, 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 = {
@@ -75,30 +163,38 @@ 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;
     }
   }
-  return Array.from(found);
+}
+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) {
   if (input === null || input === void 0) return null;
@@ -123,30 +219,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",
@@ -206,20 +327,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;
@@ -237,10 +359,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: `

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

@@ -22,7 +22,7 @@
  *
  * @public
  */
-import type { Plugin } from '@wrongstack/core';
+import type { Plugin } from '@wrongstack/core/types';
 declare const plugin: Plugin;
 export default plugin;
 //# sourceMappingURL=index.d.ts.map

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,kBAAkB,CAAC;AAgQ/C,QAAA,MAAM,MAAM,EAAE,MAiQb,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

@@ -1,9 +1,140 @@
 // src/security-hotspot-scanner/index.ts
-import { readdirSync, readFileSync, statSync } from "node:fs";
+import { readdir, readFile, stat } from "node:fs/promises";
 import { isAbsolute as isAbsolute2, relative as relative2, resolve as resolve2 } from "node:path";
 
 // 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("-");
@@ -16,7 +147,8 @@ function withinProjectPath(projectRoot, candidate) {
   return rel === "" || !rel.startsWith("..") && !isAbsolute(rel);
 }
 function withinProject(p) {
-  return withinProjectPath(process.cwd(), p) || relative(process.cwd(), p) === ".";
+  const cwd = process.cwd();
+  return withinProjectPath(cwd, p) || relative(cwd, p) === ".";
 }
 
 // src/security-hotspot-scanner/index.ts
@@ -29,7 +161,7 @@ var state = {
   skippedCount: 0,
   blockedCount: 0,
   lastResult: null,
-  knownHotspots: /* @__PURE__ */ new Set(),
+  knownHotspots: new BoundedSet({ max: 5e3 }),
   hookUnregister: null
 };
 var DEFAULTS = {
@@ -38,14 +170,20 @@ var DEFAULTS = {
   maxFindings: 10,
   scanOnChange: [".js", ".jsx", ".ts", ".tsx", ".mjs", ".cjs", ".py", ".java", ".go", ".rb", ".php"]
 };
+var scanOnChangeSet = new Set(DEFAULTS.scanOnChange);
 function readConfig(raw) {
-  if (!raw || typeof raw !== "object") return { ...DEFAULTS };
+  if (!raw || typeof raw !== "object") {
+    scanOnChangeSet = new Set(DEFAULTS.scanOnChange);
+    return { ...DEFAULTS };
+  }
   const r = raw;
+  const scanOnChange = Array.isArray(r["scanOnChange"]) ? r["scanOnChange"].filter((x) => typeof x === "string") : DEFAULTS.scanOnChange;
+  scanOnChangeSet = new Set(scanOnChange);
   return {
     enabled: r["enabled"] === true,
     severity: r["severity"] === "block" ? "block" : DEFAULTS.severity,
     maxFindings: typeof r["maxFindings"] === "number" && r["maxFindings"] >= 1 && r["maxFindings"] <= 100 ? r["maxFindings"] : DEFAULTS.maxFindings,
-    scanOnChange: Array.isArray(r["scanOnChange"]) ? r["scanOnChange"].filter((x) => typeof x === "string") : DEFAULTS.scanOnChange
+    scanOnChange
   };
 }
 var PATTERNS = [
@@ -101,7 +239,7 @@ function isSourceFile(filePath, extensions) {
   const lower = filePath.toLowerCase();
   return extensions.some((ext) => lower.endsWith(ext));
 }
-function scanPath(inputPath, cfg) {
+async function scanPath(inputPath, cfg) {
   const start = Date.now();
   const root = process.cwd();
   const resolved = isAbsolute2(inputPath) ? resolve2(inputPath) : resolve2(root, inputPath);
@@ -118,10 +256,10 @@ function scanPath(inputPath, cfg) {
   let filesScanned = 0;
   const allFindings = [];
   const maxPerFile = Math.max(1, Math.floor(cfg.maxFindings / 2));
-  const scanFile = (filePath) => {
+  const scanFile = async (filePath) => {
     if (!isSourceFile(filePath, cfg.scanOnChange)) return;
     try {
-      const content = readFileSync(filePath, "utf-8");
+      const content = await readFile(filePath, "utf-8");
       filesScanned += 1;
       const findings = scanSource(content, maxPerFile);
       for (const f of findings) {
@@ -131,10 +269,10 @@ function scanPath(inputPath, cfg) {
     } catch {
     }
   };
-  const walk = (dir) => {
+  const walk = async (dir) => {
     let entries;
     try {
-      entries = readdirSync(dir);
+      entries = await readdir(dir);
     } catch {
       return;
     }
@@ -142,25 +280,25 @@ function scanPath(inputPath, cfg) {
       if (allFindings.length >= cfg.maxFindings) return;
       const full = resolve2(dir, entry);
       try {
-        const st = statSync(full);
+        const st = await stat(full);
         if (st.isDirectory()) {
           if (entry.startsWith(".") || entry === "node_modules" || entry === "dist" || entry === "coverage") {
             continue;
           }
-          walk(full);
+          await walk(full);
         } else if (st.isFile()) {
-          scanFile(full);
+          await scanFile(full);
         }
       } catch {
       }
     }
   };
   try {
-    const st = statSync(resolved);
+    const st = await stat(resolved);
     if (st.isDirectory()) {
-      walk(resolved);
+      await walk(resolved);
     } else if (st.isFile()) {
-      scanFile(resolved);
+      await scanFile(resolved);
     } else {
       return {
         path: inputPath,
@@ -238,7 +376,7 @@ var plugin = {
       state.hookUnregister = null;
     }
     const cfg = readConfig(api.config.extensions?.["security-hotspot-scanner"]);
-    const hook = (input) => {
+    const hook = async (input) => {
       if (!cfg.enabled) return;
       if (input.toolResult?.isError) return;
       const inp = input.toolInput ?? {};
@@ -246,12 +384,12 @@ var plugin = {
       if (!sourcePath || typeof sourcePath !== "string") return;
       if (!withinProject(sourcePath)) return;
       const ext = sourcePath.includes(".") ? sourcePath.slice(sourcePath.lastIndexOf(".")).toLowerCase() : "";
-      if (!cfg.scanOnChange.includes(ext)) {
+      if (!scanOnChangeSet.has(ext)) {
         state.skippedCount += 1;
         return;
       }
       state.hookInvocationCount += 1;
-      const result = scanPath(sourcePath, cfg);
+      const result = await scanPath(sourcePath, cfg);
       state.scanCount += 1;
       state.fileScanCount += result.filesScanned;
       if (!result.scanned) {
@@ -307,7 +445,7 @@ Review or remove the risky pattern(s).`;
       mutating: false,
       async execute(input) {
         if (!cfg.enabled) return { ok: false, error: "security-hotspot-scanner is disabled" };
-        const result = scanPath(input.path, cfg);
+        const result = await scanPath(input.path, cfg);
         state.scanCount += 1;
         state.fileScanCount += result.filesScanned;
         state.findingCount += result.findings.length;

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

@@ -30,7 +30,7 @@
  *
  * @public
  */
-import type { Plugin } from '@wrongstack/core';
+import type { Plugin } from '@wrongstack/core/types';
 declare const plugin: Plugin;
 export default plugin;
 //# sourceMappingURL=index.d.ts.map

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,kBAAkB,CAAC;AA6b/C,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

@@ -6,7 +6,7 @@
  * - semver_current: Show the current version from package.json
  * - semver_changelog: Generate a changelog between two versions
  */
-import type { Plugin } from '@wrongstack/core';
+import type { Plugin } from '@wrongstack/core/types';
 type BumpType = 'major' | 'minor' | 'patch' | 'auto';
 interface ConventionalCommit {
     hash: string;