@wrongstack/plugins 0.292.1 → 0.295.0

package/dist/diff-summary.js

@@ -1,5 +1,5 @@
 // src/diff-summary/index.ts
-import { execFileSync } from "node:child_process";
+import { execFile } from "node:child_process";
 
 // src/runtime/index.ts
 import { basename, extname, isAbsolute, relative, resolve } from "node:path";
@@ -15,7 +15,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/diff-summary/index.ts
@@ -64,36 +65,34 @@ function contentHash(s) {
   return h >>> 0;
 }
 var pathMemo = /* @__PURE__ */ new Map();
-function getGitDiff(filePath, contextLines, cwd) {
-  const opts = {
-    encoding: "utf-8",
-    timeout: 3e3,
-    cwd,
-    stdio: ["pipe", "pipe", "pipe"]
-  };
-  let isTracked = false;
-  try {
-    execFileSync("git", ["ls-files", "--error-unmatch", "--", filePath], opts);
-    isTracked = true;
-  } catch {
-    isTracked = false;
-  }
+function runGit(args, cwd) {
+  return new Promise((resolveCommand) => {
+    execFile(
+      "git",
+      args,
+      {
+        encoding: "utf8",
+        timeout: 3e3,
+        cwd,
+        windowsHide: true,
+        maxBuffer: 5 * 1024 * 1024
+      },
+      (error, stdout) => resolveCommand({ ok: !error, stdout })
+    );
+  });
+}
+async function getGitDiff(filePath, contextLines, cwd) {
+  const tracked = await runGit(["ls-files", "--error-unmatch", "--", filePath], cwd);
+  const isTracked = tracked.ok;
   try {
     let rawDiff;
     const contextFlag = `-U${contextLines}`;
     if (isTracked) {
-      rawDiff = execFileSync("git", ["diff", contextFlag, "--", filePath], opts);
+      const result = await runGit(["diff", contextFlag, "--", filePath], cwd);
+      if (!result.ok) return null;
+      rawDiff = result.stdout;
     } else {
-      try {
-        rawDiff = execFileSync(
-          "git",
-          ["diff", "--no-index", contextFlag, "/dev/null", filePath],
-          opts
-        );
-      } catch (err) {
-        const e = err;
-        rawDiff = e.stdout ?? "";
-      }
+      rawDiff = (await runGit(["diff", "--no-index", contextFlag, "/dev/null", filePath], cwd)).stdout;
     }
     if (!rawDiff.trim()) {
       return { diff: "", added: 0, removed: 0, isNewFile: !isTracked };
@@ -185,7 +184,7 @@ var plugin = {
     pathMemo.clear();
     const cfg = readConfig(api.config.extensions?.["diff-summary"]);
     const cwd = typeof process.cwd === "function" ? process.cwd() : void 0;
-    const hook = (input) => {
+    const hook = async (input) => {
       if (cfg.mode === "off") return;
       if (input.toolResult?.isError) return;
       const toolName = input.toolName ?? "";
@@ -212,7 +211,7 @@ var plugin = {
           return;
         }
       }
-      const result = getGitDiff(filePath, cfg.includeContext, cwd);
+      const result = await getGitDiff(filePath, cfg.includeContext, cwd);
       if (!result) {
         state.fallbackCount += 1;
         return;

package/dist/doc-sync-guard/index.d.ts

@@ -25,7 +25,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/doc-sync-guard/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/doc-sync-guard/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAGH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AA0I/C,QAAA,MAAM,MAAM,EAAE,MAuJb,CAAC;eAEa,MAAM"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/doc-sync-guard/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAGH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AA0IrD,QAAA,MAAM,MAAM,EAAE,MAuJb,CAAC;eAEa,MAAM"}

package/dist/doc-sync-guard.js

@@ -15,7 +15,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/doc-sync-guard/index.ts

package/dist/duplicate-code-detector/index.d.ts

@@ -25,7 +25,32 @@
  *
  * @public
  */
-import type { Plugin } from '@wrongstack/core';
+import type { Plugin } from '@wrongstack/core/types';
+/**
+ * Tunable budgets that bound the hook fingerprint index. Keeping the defaults
+ * together makes the file, fingerprint, and byte limits explicit.
+ */
+export declare const hookIndexBudgets: {
+    /** Max number of files retained in the hook fingerprint index (LRU-evicted). */
+    maxFiles: number;
+    /** Max total fingerprints across the whole index (running-sum enforced, LRU-evicted). */
+    maxFingerprints: number;
+    /**
+     * Max candidate windows hashed and cached per file by the advisory hook. The
+     * on-demand detect_duplicate_code tool intentionally scans every window.
+     */
+    maxFingerprintsPerFile: number;
+    /** Files larger than this are skipped entirely by the hook (never read/extracted/cached). */
+    maxFileBytes: number;
+};
+/**
+ * Compact 53-bit hash of a fingerprint string. The hook index can retain up to
+ * 300k fingerprints, where a 32-bit hash has a material birthday-collision risk
+ * and can emit a false duplicate warning. The result remains a JS-safe integer,
+ * so the index keeps the compact `Set<number>` representation instead of storing
+ * raw fingerprint text.
+ */
+export declare function hashFingerprint(fp: string): number;
 declare const plugin: Plugin;
 export default plugin;
 //# sourceMappingURL=index.d.ts.map

package/dist/duplicate-code-detector/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/duplicate-code-detector/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAIH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAiN/C,QAAA,MAAM,MAAM,EAAE,MAySb,CAAC;eAEa,MAAM"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/duplicate-code-detector/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAIH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AA8ErD;;;GAGG;AACH,eAAO,MAAM,gBAAgB;IAC3B,gFAAgF;IAChF,QAAQ;IACR,yFAAyF;IACzF,eAAe;IACf;;;OAGG;IACH,sBAAsB;IACtB,6FAA6F;IAC7F,YAAY;CACb,CAAC;AAyGF;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,CAelD;AA4HD,QAAA,MAAM,MAAM,EAAE,MA4Wb,CAAC;eAEa,MAAM"}

package/dist/duplicate-code-detector.js

@@ -1,9 +1,8 @@
 // src/duplicate-code-detector/index.ts
-import { readFileSync, statSync as statSync2 } from "node:fs";
-import { isAbsolute as isAbsolute2, relative as relative2, resolve as resolve2 } from "node:path";
+import { readFile, realpath, stat } from "node:fs/promises";
+import { isAbsolute as isAbsolute2, relative as relative2, resolve as resolve2, sep } from "node:path";
 
 // src/runtime/index.ts
-import { existsSync, readdirSync, statSync } from "node:fs";
 import { basename, extname, isAbsolute, relative, resolve } from "node:path";
 var MAX_BUFFER_BYTES = 16 * 1024 * 1024;
 function hasLeadingDash(arg) {
@@ -17,44 +16,45 @@ 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) === ".";
 }
 var DEFAULT_EXCLUDE_DIRS = ["node_modules", "dist", ".git", "coverage"];
-function collectSourceFiles(root, opts) {
+async function collectSourceFilesAsync(root, opts) {
+  const { readdir, stat: stat2 } = await import("node:fs/promises");
   const files = [];
-  if (!existsSync(root)) return files;
-  const s = statSync(root);
-  if (s.isFile()) {
-    if (matchesExtension(root, opts.extensions)) files.push(root);
+  try {
+    const s = await stat2(root);
+    if (s.isFile()) {
+      if (matchesExtension(root, opts.extensions)) files.push(root);
+      return files;
+    }
+    if (!s.isDirectory()) return files;
+  } catch {
     return files;
   }
-  if (!s.isDirectory()) return files;
   const exclude = opts.excludeDirs ?? DEFAULT_EXCLUDE_DIRS;
-  function walk(dir, depth) {
+  const excludeSet = new Set(exclude);
+  async function walk(dir, depth) {
     if (opts.maxDepth !== void 0 && depth > opts.maxDepth) return;
     let entries;
     try {
-      entries = readdirSync(dir);
+      entries = await readdir(dir, { withFileTypes: true });
     } catch {
       return;
     }
+    entries.sort((a, b) => a.name.localeCompare(b.name));
     for (const entry of entries) {
-      if (exclude.includes(entry)) continue;
-      const full = resolve(dir, entry);
-      let st;
-      try {
-        st = statSync(full);
-      } catch {
-        continue;
-      }
-      if (st.isDirectory()) {
-        walk(full, depth + 1);
-      } else if (st.isFile() && matchesExtension(full, opts.extensions)) {
+      if (excludeSet.has(entry.name)) continue;
+      const full = resolve(dir, entry.name);
+      if (entry.isDirectory()) {
+        await walk(full, depth + 1);
+      } else if (entry.isFile() && matchesExtension(full, opts.extensions)) {
         files.push(full);
       }
     }
   }
-  walk(root, 0);
+  await walk(root, 0);
   return files;
 }
 function matchesExtension(p, exts) {
@@ -71,7 +71,24 @@ var state = {
   errorCount: 0,
   hookUnregister: null,
   lastHookWarning: /* @__PURE__ */ new Map(),
-  fileIndex: /* @__PURE__ */ new Map()
+  fileIndex: /* @__PURE__ */ new Map(),
+  inFlightFingerprintReads: /* @__PURE__ */ new Map(),
+  indexFingerprintCount: 0,
+  hookIndexEvictions: 0,
+  oversizedFileSkips: 0
+};
+var hookIndexBudgets = {
+  /** Max number of files retained in the hook fingerprint index (LRU-evicted). */
+  maxFiles: 5e3,
+  /** Max total fingerprints across the whole index (running-sum enforced, LRU-evicted). */
+  maxFingerprints: 3e5,
+  /**
+   * Max candidate windows hashed and cached per file by the advisory hook. The
+   * on-demand detect_duplicate_code tool intentionally scans every window.
+   */
+  maxFingerprintsPerFile: 25e3,
+  /** Files larger than this are skipped entirely by the hook (never read/extracted/cached). */
+  maxFileBytes: 2 * 1024 * 1024
 };
 var DEFAULTS = {
   enabled: false,
@@ -81,18 +98,28 @@ var DEFAULTS = {
   excludeDirs: ["node_modules", "dist", ".git", "coverage"],
   maxFindings: 5
 };
+var extensionsSet = new Set(DEFAULTS.extensions);
 function readConfig(raw) {
-  if (!raw || typeof raw !== "object") return { ...DEFAULTS };
+  if (!raw || typeof raw !== "object") {
+    extensionsSet = new Set(DEFAULTS.extensions);
+    return { ...DEFAULTS };
+  }
   const r = raw;
+  const extensions = Array.isArray(r["extensions"]) ? r["extensions"].filter((x) => typeof x === "string") : DEFAULTS.extensions;
+  extensionsSet = new Set(extensions);
   return {
     enabled: r["enabled"] === true,
     minLines: typeof r["minLines"] === "number" && r["minLines"] >= 2 && r["minLines"] <= 100 ? r["minLines"] : DEFAULTS.minLines,
     threshold: typeof r["threshold"] === "number" && r["threshold"] > 0 && r["threshold"] <= 1 ? r["threshold"] : DEFAULTS.threshold,
-    extensions: Array.isArray(r["extensions"]) ? r["extensions"].filter((x) => typeof x === "string") : DEFAULTS.extensions,
+    extensions,
     excludeDirs: Array.isArray(r["excludeDirs"]) ? r["excludeDirs"].filter((x) => typeof x === "string") : DEFAULTS.excludeDirs,
     maxFindings: typeof r["maxFindings"] === "number" && r["maxFindings"] >= 1 && r["maxFindings"] <= 500 ? r["maxFindings"] : DEFAULTS.maxFindings
   };
 }
+function isWithinRoot(projectRoot, candidate) {
+  const rel = relative2(projectRoot, candidate);
+  return rel === "" || rel !== ".." && !rel.startsWith(`..${sep}`) && !isAbsolute2(rel);
+}
 function toPosix(p) {
   return p.replace(/\\/g, "/");
 }
@@ -111,6 +138,40 @@ function normalizeLine(line) {
 function buildFingerprint(lines) {
   return lines.map(normalizeLine).filter((l) => l.length > 0).join("\n");
 }
+function hashFingerprint(fp) {
+  let low = 3735928559;
+  let high = 1103547991;
+  for (let index = 0; index < fp.length; index += 1) {
+    const code = fp.charCodeAt(index);
+    low = Math.imul(low ^ code, 2654435761);
+    high = Math.imul(high ^ code, 1597334677);
+  }
+  low = Math.imul(low ^ low >>> 16, 2246822507) ^ Math.imul(high ^ high >>> 13, 3266489909);
+  high = Math.imul(high ^ high >>> 16, 2246822507) ^ Math.imul(low ^ low >>> 13, 3266489909);
+  return 4294967296 * (high & 2097151) + (low >>> 0);
+}
+function extractFingerprintHashes(content, minLines, maxWindows) {
+  const rawLines = content.split(/\r?\n/);
+  const normalizedLines = rawLines.map(normalizeLine);
+  const fingerprints = /* @__PURE__ */ new Set();
+  const windowCount = Math.min(Math.max(rawLines.length - minLines + 1, 0), maxWindows);
+  for (let index = 0; index < windowCount; index += 1) {
+    const fingerprint = normalizedLines.slice(index, index + minLines).filter((line) => line.length > 0).join("\n");
+    if (fingerprint.length > 0) fingerprints.add(hashFingerprint(fingerprint));
+  }
+  return fingerprints;
+}
+function evictHookIndex() {
+  while (state.fileIndex.size > hookIndexBudgets.maxFiles || state.indexFingerprintCount > hookIndexBudgets.maxFingerprints) {
+    const oldest = state.fileIndex.keys().next();
+    if (oldest.done) break;
+    const key = oldest.value;
+    const entry = state.fileIndex.get(key);
+    if (entry) state.indexFingerprintCount -= entry.fingerprints.size;
+    state.fileIndex.delete(key);
+    state.hookIndexEvictions += 1;
+  }
+}
 function extractWindows(filePath, content, minLines) {
   const rawLines = content.split(/\r?\n/);
   const windows = [];
@@ -153,14 +214,17 @@ function findDuplicates(files, minLines, maxFindings) {
   }
   return findings;
 }
-function scanPath(rawPath, cfg) {
+async function scanPath(rawPath, cfg) {
   const root = process.cwd();
   const resolved = isAbsolute2(rawPath) ? resolve2(rawPath) : resolve2(root, rawPath);
-  const filePaths = collectSourceFiles(resolved, { extensions: cfg.extensions, excludeDirs: cfg.excludeDirs });
+  const filePaths = await collectSourceFilesAsync(resolved, {
+    extensions: cfg.extensions,
+    excludeDirs: cfg.excludeDirs
+  });
   const files = /* @__PURE__ */ new Map();
   for (const p of filePaths) {
     try {
-      files.set(p, readFileSync(p, "utf-8"));
+      files.set(p, await readFile(p, "utf-8"));
     } catch {
     }
   }
@@ -220,6 +284,9 @@ var plugin = {
     state.errorCount = 0;
     state.lastHookWarning.clear();
     state.fileIndex.clear();
+    state.indexFingerprintCount = 0;
+    state.hookIndexEvictions = 0;
+    state.oversizedFileSkips = 0;
     if (state.hookUnregister) {
       try {
         state.hookUnregister();
@@ -228,77 +295,103 @@ var plugin = {
       state.hookUnregister = null;
     }
     const cfg = readConfig(api.config.extensions?.["duplicate-code-detector"]);
-    function readCachedWindows(filePath, minLines) {
+    async function readCachedFingerprints(filePath, minLines) {
       let st;
       try {
-        st = statSync2(filePath);
+        st = await stat(filePath);
       } catch {
         return null;
       }
       const cached = state.fileIndex.get(filePath);
       if (cached && cached.mtimeMs === st.mtimeMs && cached.size === st.size) {
-        return cached.windows;
+        state.fileIndex.delete(filePath);
+        state.fileIndex.set(filePath, cached);
+        return cached.fingerprints;
+      }
+      if (st.size > hookIndexBudgets.maxFileBytes) {
+        if (cached) {
+          state.indexFingerprintCount -= cached.fingerprints.size;
+          state.fileIndex.delete(filePath);
+        }
+        state.oversizedFileSkips += 1;
+        api.log.trace("duplicate-code-detector: skipped oversized file in hook index", {
+          file: relativePath(filePath),
+          sizeBytes: st.size,
+          maxFileBytes: hookIndexBudgets.maxFileBytes
+        });
+        return /* @__PURE__ */ new Set();
       }
       let content;
       try {
-        content = readFileSync(filePath, "utf-8");
+        content = await readFile(filePath, "utf-8");
       } catch {
         return null;
       }
-      const windows = extractWindows(filePath, content, minLines);
-      state.fileIndex.set(filePath, { mtimeMs: st.mtimeMs, size: st.size, windows });
-      return windows;
+      const fingerprints = extractFingerprintHashes(
+        content,
+        minLines,
+        hookIndexBudgets.maxFingerprintsPerFile
+      );
+      if (cached) state.indexFingerprintCount -= cached.fingerprints.size;
+      state.fileIndex.set(filePath, { mtimeMs: st.mtimeMs, size: st.size, fingerprints });
+      state.indexFingerprintCount += fingerprints.size;
+      evictHookIndex();
+      return fingerprints;
     }
-    const hook = (input) => {
+    const hook = async (input) => {
       if (!cfg.enabled) return;
       if (input.toolResult?.isError) return;
       const inp = input.toolInput ?? {};
       const sourcePath = inp["path"];
       if (!sourcePath || typeof sourcePath !== "string") return;
-      if (!withinProject(sourcePath)) return;
+      const projectRoot = resolve2(process.cwd());
+      const resolvedFile = isAbsolute2(sourcePath) ? resolve2(sourcePath) : resolve2(projectRoot, sourcePath);
+      if (!isWithinRoot(projectRoot, resolvedFile)) return;
+      let changedFile;
+      try {
+        changedFile = await realpath(resolvedFile);
+      } catch {
+        state.errorCount += 1;
+        return;
+      }
+      if (!isWithinRoot(projectRoot, changedFile)) return;
       const ext = sourcePath.includes(".") ? sourcePath.slice(sourcePath.lastIndexOf(".")).toLowerCase() : "";
-      if (!cfg.extensions.includes(ext)) return;
+      if (!extensionsSet.has(ext)) return;
       state.hookInvocationCount += 1;
       const now = Date.now();
-      const lastWarning = state.lastHookWarning.get(sourcePath);
+      const lastWarning = state.lastHookWarning.get(changedFile);
       if (lastWarning !== void 0 && now - lastWarning < 6e4) return;
-      const changedFile = resolve2(process.cwd(), sourcePath);
-      const changedWindows = readCachedWindows(changedFile, cfg.minLines);
-      if (changedWindows === null) {
+      const changedFps = await readCachedFingerprints(changedFile, cfg.minLines);
+      if (changedFps === null) {
         state.errorCount += 1;
         return;
       }
-      if (changedWindows.length === 0) return;
-      const projectRoot = resolve2(process.cwd());
+      if (changedFps.size === 0) return;
       let otherFilePaths;
       try {
-        otherFilePaths = collectSourceFiles(projectRoot, {
+        otherFilePaths = await collectSourceFilesAsync(projectRoot, {
           extensions: cfg.extensions,
           excludeDirs: cfg.excludeDirs
-        }).filter((p) => p !== changedFile);
+        });
       } catch {
         state.errorCount += 1;
         return;
       }
-      const existingWindows = [];
+      const matched = /* @__PURE__ */ new Set();
       for (const p of otherFilePaths) {
-        const w = readCachedWindows(p, cfg.minLines);
-        if (w !== null) existingWindows.push(...w);
-      }
-      const hits = [];
-      for (const cw of changedWindows) {
-        for (const ew of existingWindows) {
-          if (cw.fingerprint === ew.fingerprint) {
-            hits.push(ew);
-            break;
-          }
+        if (resolve2(p) === resolve2(changedFile)) continue;
+        const otherFps = await readCachedFingerprints(p, cfg.minLines);
+        if (otherFps === null || otherFps.size === 0) continue;
+        for (const fp of changedFps) {
+          if (!matched.has(fp) && otherFps.has(fp)) matched.add(fp);
         }
+        if (matched.size === changedFps.size) break;
       }
-      if (hits.length === 0) return;
-      state.warningCount += hits.length;
-      state.lastHookWarning.set(sourcePath, now);
+      if (matched.size === 0) return;
+      state.warningCount += matched.size;
+      state.lastHookWarning.set(changedFile, now);
       return {
-        additionalContext: `\u26A0\uFE0F duplicate-code-detector: ${sourcePath} contains ${hits.length} block(s) already present elsewhere. Run detect_duplicate_code for details.`,
+        additionalContext: `\u26A0\uFE0F duplicate-code-detector: ${sourcePath} contains ${matched.size} block(s) already present elsewhere. Run detect_duplicate_code for details.`,
         contextAs: "separate"
       };
     };
@@ -324,7 +417,7 @@ var plugin = {
         state.scanCount += 1;
         let result;
         try {
-          result = scanPath(rawPath, cfg);
+          result = await scanPath(rawPath, cfg);
         } catch (err) {
           state.errorCount += 1;
           return { ok: false, error: String(err) };
@@ -360,7 +453,15 @@ var plugin = {
             findings: state.findingCount,
             hookInvocations: state.hookInvocationCount,
             warnings: state.warningCount,
-            errors: state.errorCount
+            errors: state.errorCount,
+            // Hook fingerprint-index footprint (bounded; see hookIndexBudgets).
+            indexedFiles: state.fileIndex.size,
+            indexedFingerprints: state.indexFingerprintCount,
+            hookIndexEvictions: state.hookIndexEvictions,
+            oversizedFileSkips: state.oversizedFileSkips,
+            // Rough retained-bytes estimate: ~8B per numeric fingerprint + ~120B
+            // per file entry (key string + Set/entry overhead). Compact by design.
+            approxIndexBytes: state.indexFingerprintCount * 8 + state.fileIndex.size * 120
           }
         };
       }
@@ -392,6 +493,10 @@ var plugin = {
     state.warningCount = 0;
     state.errorCount = 0;
     state.lastHookWarning.clear();
+    state.fileIndex.clear();
+    state.indexFingerprintCount = 0;
+    state.hookIndexEvictions = 0;
+    state.oversizedFileSkips = 0;
     api.log.info("duplicate-code-detector: teardown complete", { final });
   },
   async health() {
@@ -403,12 +508,18 @@ var plugin = {
         findings: state.findingCount,
         hookInvocations: state.hookInvocationCount,
         warnings: state.warningCount,
-        errors: state.errorCount
+        errors: state.errorCount,
+        indexedFiles: state.fileIndex.size,
+        indexedFingerprints: state.indexFingerprintCount,
+        hookIndexEvictions: state.hookIndexEvictions,
+        oversizedFileSkips: state.oversizedFileSkips
       }
     };
   }
 };
 var duplicate_code_detector_default = plugin;
 export {
-  duplicate_code_detector_default as default
+  duplicate_code_detector_default as default,
+  hashFingerprint,
+  hookIndexBudgets
 };

package/dist/error-lens/index.d.ts

@@ -43,7 +43,7 @@
  *
  * @public
  */
-import type { Plugin } from '@wrongstack/core';
+import type { Plugin } from '@wrongstack/core/types';
 export interface FailureRecord {
     when: string;
     tool: string;

package/dist/error-lens/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/error-lens/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AACH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAM/C,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;CACjB;AA6FD,kEAAkE;AAClE,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAM9D;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,EAAE,CAuBzE;AAUD,QAAA,MAAM,MAAM,EAAE,MAoOb,CAAC;eAEa,MAAM"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/error-lens/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AACH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AAMrD,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;CACjB;AA6FD,kEAAkE;AAClE,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAM9D;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,EAAE,CAuBzE;AAUD,QAAA,MAAM,MAAM,EAAE,MAoOb,CAAC;eAEa,MAAM"}

package/dist/factories/index.d.ts

@@ -0,0 +1,4 @@
+import type { Plugin } from '@wrongstack/core/types';
+export declare const OFFICIAL_PLUGIN_SPECIFIERS: readonly ['@wrongstack/plugins/agent-handoff', '@wrongstack/plugins/cost-tracker', '@wrongstack/plugins/file-watcher', '@wrongstack/plugins/git-autocommit', '@wrongstack/plugins/auto-doc', '@wrongstack/plugins/shell-check', '@wrongstack/plugins/cron', '@wrongstack/plugins/template-engine', '@wrongstack/plugins/semver-bump', '@wrongstack/plugins/secret-scanner', '@wrongstack/plugins/todo-tracker', '@wrongstack/plugins/token-budget', '@wrongstack/plugins/lint-gate', '@wrongstack/plugins/branch-guard', '@wrongstack/plugins/diff-summary', '@wrongstack/plugins/commit-validator', '@wrongstack/plugins/format-on-save', '@wrongstack/plugins/test-runner-gate', '@wrongstack/plugins/import-organizer', '@wrongstack/plugins/knowledge-graph', '@wrongstack/plugins/todo-listener', '@wrongstack/plugins/session-recap', '@wrongstack/plugins/spec-linker', '@wrongstack/plugins/loop-breaker', '@wrongstack/plugins/path-guard', '@wrongstack/plugins/process-guard', '@wrongstack/plugins/context-pins', '@wrongstack/plugins/checkpoint', '@wrongstack/plugins/error-lens', '@wrongstack/plugins/dep-guard', '@wrongstack/plugins/config-validator', '@wrongstack/plugins/notify-hub', '@wrongstack/plugins/changelog-writer', '@wrongstack/plugins/injection-shield', '@wrongstack/plugins/llm-cache', '@wrongstack/plugins/model-router', '@wrongstack/plugins/pr-drafter', '@wrongstack/plugins/prompt-firewall', '@wrongstack/plugins/auto-escalate', '@wrongstack/plugins/test-coverage-gate', '@wrongstack/plugins/type-gate', '@wrongstack/plugins/token-throttle', '@wrongstack/plugins/plugin-stack-observer', '@wrongstack/plugins/dead-code-detector', '@wrongstack/plugins/dependency-vulnerability-gate', '@wrongstack/plugins/migration-planner', '@wrongstack/plugins/semantic-search-indexer', '@wrongstack/plugins/auto-i18n-extractor', '@wrongstack/plugins/doc-sync-guard', '@wrongstack/plugins/api-compatibility-gate', '@wrongstack/plugins/performance-regression-gate', '@wrongstack/plugins/test-flake-detector', '@wrongstack/plugins/schema-evolution-guard', '@wrongstack/plugins/license-audit-gate', '@wrongstack/plugins/accessibility-auditor', '@wrongstack/plugins/security-hotspot-scanner', '@wrongstack/plugins/duplicate-code-detector', '@wrongstack/plugins/code-metrics', '@wrongstack/plugins/refactor-suggester', '@wrongstack/plugins/test-generator', '@wrongstack/plugins/release-notes-generator', '@wrongstack/plugins/smart-rename', '@wrongstack/plugins/feature-flag-tracker', '@wrongstack/plugins/interface-contract-guard'];
+export declare const OFFICIAL_PLUGIN_FACTORIES: readonly (() => Promise<Plugin>)[];
+//# sourceMappingURL=index.d.ts.map

package/dist/factories/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/factories/index.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AAErD,eAAO,MAAM,0BAA0B,YACrC,mCAAmC,EACnC,kCAAkC,EAClC,kCAAkC,EAClC,oCAAoC,EACpC,8BAA8B,EAC9B,iCAAiC,EACjC,0BAA0B,EAC1B,qCAAqC,EACrC,iCAAiC,EACjC,oCAAoC,EACpC,kCAAkC,EAClC,kCAAkC,EAClC,+BAA+B,EAC/B,kCAAkC,EAClC,kCAAkC,EAClC,sCAAsC,EACtC,oCAAoC,EACpC,sCAAsC,EACtC,sCAAsC,EACtC,qCAAqC,EACrC,mCAAmC,EACnC,mCAAmC,EACnC,iCAAiC,EACjC,kCAAkC,EAClC,gCAAgC,EAChC,mCAAmC,EACnC,kCAAkC,EAClC,gCAAgC,EAChC,gCAAgC,EAChC,+BAA+B,EAC/B,sCAAsC,EACtC,gCAAgC,EAChC,sCAAsC,EACtC,sCAAsC,EACtC,+BAA+B,EAC/B,kCAAkC,EAClC,gCAAgC,EAChC,qCAAqC,EACrC,mCAAmC,EACnC,wCAAwC,EACxC,+BAA+B,EAC/B,oCAAoC,EACpC,2CAA2C,EAC3C,wCAAwC,EACxC,mDAAmD,EACnD,uCAAuC,EACvC,6CAA6C,EAC7C,yCAAyC,EACzC,oCAAoC,EACpC,4CAA4C,EAC5C,iDAAiD,EACjD,yCAAyC,EACzC,4CAA4C,EAC5C,wCAAwC,EACxC,2CAA2C,EAC3C,8CAA8C,EAC9C,6CAA6C,EAC7C,kCAAkC,EAClC,wCAAwC,EACxC,oCAAoC,EACpC,6CAA6C,EAC7C,kCAAkC,EAClC,0CAA0C,EAC1C,8CAA8C,CACtC,CAAC;AAEX,eAAO,MAAM,yBAAyB,EAAE,SAAS,CAAC,MAAM,OAAO,CAAC,MAAM,CAAC,CAAC,EAGrE,CAAC"}

package/dist/factories.d.ts

@@ -0,0 +1 @@
+export * from './factories/index.js';