deep-slop 1.4.1 → 1.6.0

package/dist/deep-slop-bundled.js

@@ -3899,636 +3899,192 @@ var init_file_cache = __esm({
   }
 });
 
-// src/plugins/loader.ts
-async function loadPlugin(pluginPath) {
-  try {
-    const mod = await import(pluginPath);
-    const engine = mod.default;
-    if (!engine || typeof engine !== "object") {
-      return null;
+// src/utils/tree-sitter.ts
+function clearParseCache() {
+  parseCache.clear();
+}
+async function initParser() {
+  if (initDone) return initOk;
+  if (initPromise) return initPromise;
+  initPromise = (async () => {
+    try {
+      const wt = await import("web-tree-sitter");
+      const { dirname: dirname9 } = await import("node:path");
+      const wasmDir = dirname9(
+        __require.resolve("web-tree-sitter/tree-sitter.wasm")
+      );
+      await wt.Parser.init({
+        locateFile: (name) => `${wasmDir}/${name}`
+      });
+      const parser = new wt.Parser();
+      parserInstance = parser;
+      const tsWasm = __require.resolve(
+        "tree-sitter-typescript/tree-sitter-typescript.wasm"
+      );
+      tsLang = await wt.Language.load(tsWasm);
+      const tsxWasm = __require.resolve(
+        "tree-sitter-typescript/tree-sitter-tsx.wasm"
+      );
+      tsxLang = await wt.Language.load(tsxWasm);
+      initDone = true;
+      initOk = true;
+      return true;
+    } catch (err) {
+      initDone = true;
+      initOk = false;
+      return false;
     }
-    if (typeof engine.name === "string" && typeof engine.description === "string" && Array.isArray(engine.supportedLanguages) && typeof engine.run === "function") {
-      return engine;
+  })();
+  return initPromise;
+}
+async function initPythonParser() {
+  if (pyInitDone) return pyInitOk;
+  if (!initOk) {
+    const baseOk = await initParser();
+    if (!baseOk) {
+      pyInitDone = true;
+      pyInitOk = false;
+      return false;
     }
-    return null;
+  }
+  try {
+    const pyWasm = __require.resolve(
+      "tree-sitter-python/python.wasm"
+    );
+    const wt = await import("web-tree-sitter");
+    pyLang = await wt.Language.load(pyWasm);
+    pyInitDone = true;
+    pyInitOk = true;
+    return true;
   } catch {
-    return null;
+    pyInitDone = true;
+    pyInitOk = false;
+    return false;
   }
 }
-async function loadPlugins(paths) {
-  const results = await Promise.allSettled(
-    paths.map((p) => loadPlugin(p))
-  );
-  const engines = [];
-  for (const r of results) {
-    if (r.status === "fulfilled" && r.value !== null) {
-      engines.push(r.value);
+async function initGoParser() {
+  if (goInitDone) return goInitOk;
+  if (!initOk) {
+    const baseOk = await initParser();
+    if (!baseOk) {
+      goInitDone = true;
+      goInitOk = false;
+      return false;
     }
   }
-  return engines;
-}
-var init_loader = __esm({
-  "src/plugins/loader.ts"() {
-    "use strict";
+  try {
+    const goWasm = __require.resolve(
+      "tree-sitter-go/go.wasm"
+    );
+    const wt = await import("web-tree-sitter");
+    goLang = await wt.Language.load(goWasm);
+    goInitDone = true;
+    goInitOk = true;
+    return true;
+  } catch {
+    goInitDone = true;
+    goInitOk = false;
+    return false;
   }
-});
-
-// src/plugins/registry.ts
-var registry_exports = {};
-__export(registry_exports, {
-  PLUGIN_DIR: () => PLUGIN_DIR,
-  discoverAndLoadPlugins: () => discoverAndLoadPlugins,
-  getPluginDir: () => getPluginDir,
-  pluginRegistry: () => pluginRegistry
-});
-import { join as join2 } from "node:path";
-import { readdir } from "node:fs/promises";
-import { existsSync as existsSync2 } from "node:fs";
-function getPluginDir(rootDir) {
-  return join2(rootDir, PLUGIN_DIR);
 }
-async function discoverAndLoadPlugins(rootDir) {
-  if (pluginRegistry.isLoaded) {
-    return pluginRegistry.getEngines();
+async function initRustParser() {
+  if (rustInitDone) return rustInitOk;
+  if (!initOk) {
+    const baseOk = await initParser();
+    if (!baseOk) {
+      rustInitDone = true;
+      rustInitOk = false;
+      return false;
+    }
   }
-  const pluginDir = getPluginDir(rootDir);
-  if (!existsSync2(pluginDir)) {
-    pluginRegistry.setLoaded(true);
-    return [];
+  try {
+    const rustWasm = __require.resolve(
+      "tree-sitter-rust/rust.wasm"
+    );
+    const wt = await import("web-tree-sitter");
+    rustLang = await wt.Language.load(rustWasm);
+    rustInitDone = true;
+    rustInitOk = true;
+    return true;
+  } catch {
+    rustInitDone = true;
+    rustInitOk = false;
+    return false;
+  }
+}
+async function initPhpParser() {
+  if (phpInitDone) return phpInitOk;
+  if (!initOk) {
+    const baseOk = await initParser();
+    if (!baseOk) {
+      phpInitDone = true;
+      phpInitOk = false;
+      return false;
+    }
   }
   try {
-    const files = await readdir(pluginDir);
-    const pluginPaths = files.filter((f) => f.endsWith(".js") || f.endsWith(".mjs")).map((f) => join2(pluginDir, f));
-    const engines = await loadPlugins(pluginPaths);
-    for (let i = 0; i < engines.length; i++) {
-      const engine = engines[i];
-      pluginRegistry.register({
-        id: engine.name,
-        path: pluginPaths[i],
-        engine,
-        loaded: true
-      });
+    const phpWasm = __require.resolve(
+      "tree-sitter-php/php.wasm"
+    );
+    const wt = await import("web-tree-sitter");
+    phpLang = await wt.Language.load(phpWasm);
+    phpInitDone = true;
+    phpInitOk = true;
+    return true;
+  } catch {
+    phpInitDone = true;
+    phpInitOk = false;
+    return false;
+  }
+}
+async function initCsharpParser() {
+  if (csharpInitDone) return csharpInitOk;
+  if (!initOk) {
+    const baseOk = await initParser();
+    if (!baseOk) {
+      csharpInitDone = true;
+      csharpInitOk = false;
+      return false;
     }
-    for (let i = 0; i < pluginPaths.length; i++) {
-      const path2 = pluginPaths[i];
-      const engine = engines.find((e) => {
-        const entry = pluginRegistry.getAll().find((ent) => ent.path === path2);
-        return entry?.engine;
-      });
-      if (!engine && !pluginRegistry.has(path2)) {
-        pluginRegistry.register({
-          id: `plugin-${i}`,
-          path: path2,
-          engine: null,
-          loaded: false,
-          error: "Failed to load plugin module"
-        });
-      }
+  }
+  try {
+    const csharpWasm = __require.resolve(
+      "tree-sitter-c-sharp/c_sharp.wasm"
+    );
+    const wt = await import("web-tree-sitter");
+    csharpLang = await wt.Language.load(csharpWasm);
+    csharpInitDone = true;
+    csharpInitOk = true;
+    return true;
+  } catch {
+    csharpInitDone = true;
+    csharpInitOk = false;
+    return false;
+  }
+}
+async function initSwiftParser() {
+  if (swiftInitDone) return swiftInitOk;
+  if (!initOk) {
+    const baseOk = await initParser();
+    if (!baseOk) {
+      swiftInitDone = true;
+      swiftInitOk = false;
+      return false;
     }
-    pluginRegistry.setLoaded(true);
-    return engines;
+  }
+  try {
+    const swiftWasm = __require.resolve(
+      "tree-sitter-swift/swift.wasm"
+    );
+    const wt = await import("web-tree-sitter");
+    swiftLang = await wt.Language.load(swiftWasm);
+    swiftInitDone = true;
+    swiftInitOk = true;
+    return true;
   } catch {
-    pluginRegistry.setLoaded(true);
-    return [];
-  }
-}
-var PluginRegistry, pluginRegistry, PLUGIN_DIR;
-var init_registry = __esm({
-  "src/plugins/registry.ts"() {
-    "use strict";
-    init_loader();
-    PluginRegistry = class {
-      entries = /* @__PURE__ */ new Map();
-      loaded = false;
-      /** Get all registered plugins */
-      getAll() {
-        return [...this.entries.values()];
-      }
-      /** Get all successfully loaded engines */
-      getEngines() {
-        return [...this.entries.values()].filter((e) => e.loaded).map((e) => e.engine);
-      }
-      /** Get a specific plugin by id */
-      get(id) {
-        return this.entries.get(id);
-      }
-      /** Get a loaded engine by name */
-      getEngine(name) {
-        const entry = this.entries.get(name);
-        return entry?.loaded ? entry.engine : void 0;
-      }
-      /** Register a plugin entry */
-      register(entry) {
-        this.entries.set(entry.id, entry);
-      }
-      /** Remove a plugin by id */
-      remove(id) {
-        return this.entries.delete(id);
-      }
-      /** Check if a plugin is registered */
-      has(id) {
-        return this.entries.has(id);
-      }
-      /** Number of registered plugins */
-      get size() {
-        return this.entries.size;
-      }
-      /** Whether the registry has been loaded from disk */
-      get isLoaded() {
-        return this.loaded;
-      }
-      /** Mark the registry as loaded */
-      setLoaded(loaded) {
-        this.loaded = loaded;
-      }
-      /** Clear all entries */
-      clear() {
-        this.entries.clear();
-        this.loaded = false;
-      }
-    };
-    pluginRegistry = new PluginRegistry();
-    PLUGIN_DIR = ".deep-slop/plugins";
-  }
-});
-
-// src/utils/suppress.ts
-import { join as join3 } from "node:path";
-import { readFileSync as readFileSync2 } from "node:fs";
-function parseSuppressDirectives(content) {
-  const entries = [];
-  const lines = content.split("\n");
-  for (let i = 0; i < lines.length; i++) {
-    const line = lines[i].trim();
-    const lineNum = i + 1;
-    const ignoreNextMatch = line.match(
-      /\/\/\s*deep-slop-ignore-next(?:\s+(.+))?$/
-    );
-    if (ignoreNextMatch) {
-      entries.push({
-        directiveLine: lineNum,
-        targetLine: lineNum + 1,
-        rules: parseRuleList(ignoreNextMatch[1]),
-        type: "next-line"
-      });
-      continue;
-    }
-    const ignoreLineMatch = line.match(
-      /\/\/\s*deep-slop-ignore-line(?:\s+(.+))?$/
-    );
-    if (ignoreLineMatch) {
-      entries.push({
-        directiveLine: lineNum,
-        targetLine: lineNum,
-        rules: parseRuleList(ignoreLineMatch[1]),
-        type: "line"
-      });
-      continue;
-    }
-    const ignoreRuleMatch = line.match(
-      /\/\/\s*deep-slop-ignore(?:\s+(.+))?$/
-    );
-    if (ignoreRuleMatch) {
-      const rulePart = ignoreRuleMatch[1];
-      if (rulePart !== "start" && rulePart !== "end") {
-        entries.push({
-          directiveLine: lineNum,
-          targetLine: lineNum + 1,
-          rules: parseRuleList(rulePart),
-          type: "next-line"
-        });
-        continue;
-      }
-    }
-    const ignoreStartMatch = line.match(
-      /\/\/\s*deep-slop-ignore-start(?:\s+(.+))?$/
-    );
-    if (ignoreStartMatch) {
-      entries.push({
-        directiveLine: lineNum,
-        targetLine: lineNum,
-        rules: parseRuleList(ignoreStartMatch[1]),
-        type: "block-start"
-      });
-      continue;
-    }
-    const ignoreEndMatch = line.match(
-      /\/\/\s*deep-slop-ignore-end/
-    );
-    if (ignoreEndMatch) {
-      entries.push({
-        directiveLine: lineNum,
-        targetLine: lineNum,
-        rules: /* @__PURE__ */ new Set(),
-        type: "block-end"
-      });
-      continue;
-    }
-    const nextLineMatch = line.match(
-      /\/\/\s*deep-slop-disable-next-line(?:\s+(.+))?$/
-    );
-    if (nextLineMatch) {
-      entries.push({
-        directiveLine: lineNum,
-        targetLine: lineNum + 1,
-        rules: parseRuleList(nextLineMatch[1]),
-        type: "next-line"
-      });
-      continue;
-    }
-    const lineMatch = line.match(
-      /\/\/\s*deep-slop-disable-line(?:\s+(.+))?$/
-    );
-    if (lineMatch) {
-      entries.push({
-        directiveLine: lineNum,
-        targetLine: lineNum,
-        rules: parseRuleList(lineMatch[1]),
-        type: "line"
-      });
-      continue;
-    }
-    const blockStart = line.match(
-      /\/\*\s*deep-slop-disable(?:\s+(.+))?\s*\//
-    );
-    if (blockStart) {
-      entries.push({
-        directiveLine: lineNum,
-        targetLine: lineNum,
-        rules: parseRuleList(blockStart[1]),
-        type: "block-start"
-      });
-      continue;
-    }
-    const blockEnd = line.match(/\/\*\s*deep-slop-enable\s*\//);
-    if (blockEnd) {
-      entries.push({
-        directiveLine: lineNum,
-        targetLine: lineNum,
-        rules: /* @__PURE__ */ new Set(),
-        type: "block-end"
-      });
-    }
-  }
-  return entries;
-}
-function parseRuleList(rulesStr) {
-  if (!rulesStr) return /* @__PURE__ */ new Set();
-  const rules = rulesStr.split(/[,\\s]+/).map((r) => r.trim()).filter(Boolean);
-  return new Set(rules);
-}
-function buildSuppressChecker(entries) {
-  const blockRanges = [];
-  let currentStart = null;
-  for (const entry of entries) {
-    if (entry.type === "block-start") {
-      currentStart = { line: entry.directiveLine, rules: entry.rules };
-    } else if (entry.type === "block-end" && currentStart) {
-      blockRanges.push({
-        startLine: currentStart.line,
-        endLine: entry.directiveLine,
-        rules: currentStart.rules
-      });
-      currentStart = null;
-    }
-  }
-  if (currentStart) {
-    blockRanges.push({
-      startLine: currentStart.line,
-      endLine: 999999,
-      rules: currentStart.rules
-    });
-  }
-  return (line, rule) => {
-    for (const entry of entries) {
-      if (entry.type === "next-line" || entry.type === "line") {
-        if (entry.targetLine === line) {
-          if (entry.rules.size === 0 || entry.rules.has(rule)) {
-            return true;
-          }
-        }
-      }
-    }
-    for (const range2 of blockRanges) {
-      if (line >= range2.startLine && line <= range2.endLine) {
-        if (range2.rules.size === 0 || range2.rules.has(rule)) {
-          return true;
-        }
-      }
-    }
-    return false;
-  };
-}
-function buildSuppressMap(content) {
-  const entries = parseSuppressDirectives(content);
-  const isSuppressed = buildSuppressChecker(entries);
-  return { entries, isSuppressed };
-}
-function loadIgnoreFile(rootDir) {
-  const ignorePath = join3(rootDir, ".deep-slop", ".deep-slop-ignore");
-  try {
-    const content = readFileSync2(ignorePath, "utf-8");
-    return content.split("\n").map((line) => line.split("#")[0].trim()).filter((line) => line && !line.startsWith("file:"));
-  } catch {
-    return [];
-  }
-}
-function applySuppressDirectives(diagnostics, fileContents, globallySuppressed = /* @__PURE__ */ new Set()) {
-  const suppressMaps = /* @__PURE__ */ new Map();
-  for (const [filePath, content] of fileContents) {
-    suppressMaps.set(filePath, buildSuppressMap(content));
-  }
-  const filtered = [];
-  let suppressedCount = 0;
-  for (const diag8 of diagnostics) {
-    if (globallySuppressed.has(diag8.rule)) {
-      suppressedCount++;
-      continue;
-    }
-    const map = suppressMaps.get(diag8.filePath);
-    if (map && map.isSuppressed(diag8.line, diag8.rule)) {
-      suppressedCount++;
-    } else {
-      filtered.push(diag8);
-    }
-  }
-  return { filtered, suppressedCount };
-}
-var init_suppress = __esm({
-  "src/utils/suppress.ts"() {
-    "use strict";
-  }
-});
-
-// src/utils/file-utils.ts
-import { readFile as readFile2 } from "node:fs/promises";
-async function readFileContent(filePath) {
-  const buffer = await readFile2(filePath);
-  let content = buffer.toString("utf-8");
-  if (content.charCodeAt(0) === 65279) {
-    content = content.slice(1);
-  }
-  return content;
-}
-function detectEncodingAnomalies(content) {
-  const hasBom = content.charCodeAt(0) === 65279;
-  const hasCrlf = content.includes("\r\n");
-  const hasZwnbsp = content.includes("\uFEFF");
-  const lfOnly = (content.match(/(?<!\r)\n/g) ?? []).length;
-  const crlfCount = (content.match(/\r\n/g) ?? []).length;
-  const lineEnding = crlfCount > 0 && lfOnly > crlfCount ? "mixed" : crlfCount > 0 ? "crlf" : "lf";
-  return { hasBom, hasCrlf, hasZwnbsp, lineEnding };
-}
-function toLines(content) {
-  return content.split("\n").map((text, i) => ({ num: i + 1, text }));
-}
-function extractImports(content, language) {
-  const imports = [];
-  const lines = toLines(content);
-  for (const { num, text } of lines) {
-    const trimmed = text.trim();
-    if (language === "typescript" || language === "javascript") {
-      const jsMatch = trimmed.match(
-        /^import\s+(?:type\s+)?(?:\{[^}]*\}|\*\s+as\s+\w+|\w+)\s+from\s+['"]([^'"]+)['"]/
-      );
-      if (jsMatch) {
-        imports.push({
-          line: num,
-          source: jsMatch[1],
-          raw: trimmed,
-          isTypeOnly: trimmed.includes("import type"),
-          isDefault: !trimmed.includes("{")
-        });
-      }
-      const dynMatch = trimmed.match(/import\s*\(\s*['"]([^'"]+)['"]\s*\)/);
-      if (dynMatch) {
-        imports.push({
-          line: num,
-          source: dynMatch[1],
-          raw: trimmed,
-          isTypeOnly: false,
-          isDynamic: true
-        });
-      }
-      const reqMatch = trimmed.match(/(?:const|let|var)\s+[^=]*=\s*require\s*\(\s*['"]([^'"]+)['"]\s*\)/);
-      if (reqMatch) {
-        imports.push({
-          line: num,
-          source: reqMatch[1],
-          raw: trimmed,
-          isTypeOnly: false,
-          isRequire: true
-        });
-      }
-    }
-    if (language === "python") {
-      const pyMatch = trimmed.match(/^from\s+([^\s]+)\s+import/);
-      if (pyMatch) {
-        imports.push({ line: num, source: pyMatch[1], raw: trimmed, isTypeOnly: false });
-      }
-      const pyImport = trimmed.match(/^import\s+([^\s]+)/);
-      if (pyImport) {
-        imports.push({ line: num, source: pyImport[1], raw: trimmed, isTypeOnly: false });
-      }
-    }
-    if (language === "go") {
-      const goMatch = trimmed.match(/"([^"]+)"/);
-      if (trimmed.startsWith("import") && goMatch) {
-        imports.push({ line: num, source: goMatch[1], raw: trimmed, isTypeOnly: false });
-      }
-    }
-  }
-  return imports;
-}
-var init_file_utils = __esm({
-  "src/utils/file-utils.ts"() {
-    "use strict";
-  }
-});
-
-// src/utils/tree-sitter.ts
-async function initParser() {
-  if (initDone) return initOk;
-  if (initPromise) return initPromise;
-  initPromise = (async () => {
-    try {
-      const wt = await import("web-tree-sitter");
-      const { dirname: dirname9 } = await import("node:path");
-      const wasmDir = dirname9(
-        __require.resolve("web-tree-sitter/tree-sitter.wasm")
-      );
-      await wt.Parser.init({
-        locateFile: (name) => `${wasmDir}/${name}`
-      });
-      const parser = new wt.Parser();
-      parserInstance = parser;
-      const tsWasm = __require.resolve(
-        "tree-sitter-typescript/tree-sitter-typescript.wasm"
-      );
-      tsLang = await wt.Language.load(tsWasm);
-      const tsxWasm = __require.resolve(
-        "tree-sitter-typescript/tree-sitter-tsx.wasm"
-      );
-      tsxLang = await wt.Language.load(tsxWasm);
-      initDone = true;
-      initOk = true;
-      return true;
-    } catch (err) {
-      initDone = true;
-      initOk = false;
-      return false;
-    }
-  })();
-  return initPromise;
-}
-async function initPythonParser() {
-  if (pyInitDone) return pyInitOk;
-  if (!initOk) {
-    const baseOk = await initParser();
-    if (!baseOk) {
-      pyInitDone = true;
-      pyInitOk = false;
-      return false;
-    }
-  }
-  try {
-    const pyWasm = __require.resolve(
-      "tree-sitter-python/python.wasm"
-    );
-    const wt = await import("web-tree-sitter");
-    pyLang = await wt.Language.load(pyWasm);
-    pyInitDone = true;
-    pyInitOk = true;
-    return true;
-  } catch {
-    pyInitDone = true;
-    pyInitOk = false;
-    return false;
-  }
-}
-async function initGoParser() {
-  if (goInitDone) return goInitOk;
-  if (!initOk) {
-    const baseOk = await initParser();
-    if (!baseOk) {
-      goInitDone = true;
-      goInitOk = false;
-      return false;
-    }
-  }
-  try {
-    const goWasm = __require.resolve(
-      "tree-sitter-go/go.wasm"
-    );
-    const wt = await import("web-tree-sitter");
-    goLang = await wt.Language.load(goWasm);
-    goInitDone = true;
-    goInitOk = true;
-    return true;
-  } catch {
-    goInitDone = true;
-    goInitOk = false;
-    return false;
-  }
-}
-async function initRustParser() {
-  if (rustInitDone) return rustInitOk;
-  if (!initOk) {
-    const baseOk = await initParser();
-    if (!baseOk) {
-      rustInitDone = true;
-      rustInitOk = false;
-      return false;
-    }
-  }
-  try {
-    const rustWasm = __require.resolve(
-      "tree-sitter-rust/rust.wasm"
-    );
-    const wt = await import("web-tree-sitter");
-    rustLang = await wt.Language.load(rustWasm);
-    rustInitDone = true;
-    rustInitOk = true;
-    return true;
-  } catch {
-    rustInitDone = true;
-    rustInitOk = false;
-    return false;
-  }
-}
-async function initPhpParser() {
-  if (phpInitDone) return phpInitOk;
-  if (!initOk) {
-    const baseOk = await initParser();
-    if (!baseOk) {
-      phpInitDone = true;
-      phpInitOk = false;
-      return false;
-    }
-  }
-  try {
-    const phpWasm = __require.resolve(
-      "tree-sitter-php/php.wasm"
-    );
-    const wt = await import("web-tree-sitter");
-    phpLang = await wt.Language.load(phpWasm);
-    phpInitDone = true;
-    phpInitOk = true;
-    return true;
-  } catch {
-    phpInitDone = true;
-    phpInitOk = false;
-    return false;
-  }
-}
-async function initCsharpParser() {
-  if (csharpInitDone) return csharpInitOk;
-  if (!initOk) {
-    const baseOk = await initParser();
-    if (!baseOk) {
-      csharpInitDone = true;
-      csharpInitOk = false;
-      return false;
-    }
-  }
-  try {
-    const csharpWasm = __require.resolve(
-      "tree-sitter-c-sharp/c_sharp.wasm"
-    );
-    const wt = await import("web-tree-sitter");
-    csharpLang = await wt.Language.load(csharpWasm);
-    csharpInitDone = true;
-    csharpInitOk = true;
-    return true;
-  } catch {
-    csharpInitDone = true;
-    csharpInitOk = false;
-    return false;
-  }
-}
-async function initSwiftParser() {
-  if (swiftInitDone) return swiftInitOk;
-  if (!initOk) {
-    const baseOk = await initParser();
-    if (!baseOk) {
-      swiftInitDone = true;
-      swiftInitOk = false;
-      return false;
-    }
-  }
-  try {
-    const swiftWasm = __require.resolve(
-      "tree-sitter-swift/swift.wasm"
-    );
-    const wt = await import("web-tree-sitter");
-    swiftLang = await wt.Language.load(swiftWasm);
-    swiftInitDone = true;
-    swiftInitOk = true;
-    return true;
-  } catch {
-    swiftInitDone = true;
-    swiftInitOk = false;
-    return false;
+    swiftInitDone = true;
+    swiftInitOk = false;
+    return false;
   }
 }
 function isAvailable() {
@@ -4538,14 +4094,19 @@ function isPythonAvailable() {
   return pyInitOk && pyLang !== null;
 }
 async function parseFile(content, isTsx = false, filePath) {
+  if (filePath) {
+    const cacheKey = `${filePath}:${isTsx ? "tsx" : "ts"}`;
+    const cached = parseCache.get(cacheKey);
+    if (cached !== void 0) return cached;
+  }
   if (filePath) {
     const ext2 = filePath.toLowerCase();
-    if (ext2.endsWith(".go")) return parseGoFile(content);
-    if (ext2.endsWith(".rs")) return parseRustFile(content);
-    if (ext2.endsWith(".php")) return parsePhpFile(content);
-    if (ext2.endsWith(".cs")) return parseCsharpFile(content);
-    if (ext2.endsWith(".swift")) return parseSwiftFile(content);
-    if (ext2.endsWith(".py")) return parsePython(content);
+    if (ext2.endsWith(".go")) return parseGoFile(content, filePath);
+    if (ext2.endsWith(".rs")) return parseRustFile(content, filePath);
+    if (ext2.endsWith(".php")) return parsePhpFile(content, filePath);
+    if (ext2.endsWith(".cs")) return parseCsharpFile(content, filePath);
+    if (ext2.endsWith(".swift")) return parseSwiftFile(content, filePath);
+    if (ext2.endsWith(".py")) return parsePython(content, filePath);
   }
   if (!parserInstance || !tsLang && !tsxLang) {
     const ok = await initParser();
@@ -4556,12 +4117,21 @@ async function parseFile(content, isTsx = false, filePath) {
     parserInstance.setLanguage(lang);
     const tree = parserInstance.parse(content);
     if (!tree) return null;
-    return convertNode(tree.rootNode, null);
+    const result = convertNode(tree.rootNode, null);
+    if (filePath) {
+      parseCache.set(`${filePath}:${isTsx ? "tsx" : "ts"}`, result);
+    }
+    return result;
   } catch {
+    if (filePath) parseCache.set(`${filePath}:${isTsx ? "tsx" : "ts"}`, null);
     return null;
   }
 }
-async function parsePython(content) {
+async function parsePython(content, filePath) {
+  if (filePath) {
+    const cached = parseCache.get(`py:${filePath}`);
+    if (cached !== void 0) return cached;
+  }
   if (!pyLang) {
     const ok = await initPythonParser();
     if (!ok) return null;
@@ -4573,13 +4143,23 @@ async function parsePython(content) {
   try {
     parserInstance.setLanguage(pyLang);
     const tree = parserInstance.parse(content);
-    if (!tree) return null;
-    return convertNode(tree.rootNode, null);
+    if (!tree) {
+      if (filePath) parseCache.set(`py:${filePath}`, null);
+      return null;
+    }
+    const result = convertNode(tree.rootNode, null);
+    if (filePath) parseCache.set(`py:${filePath}`, result);
+    return result;
   } catch {
+    if (filePath) parseCache.set(`py:${filePath}`, null);
     return null;
   }
 }
-async function parseGoFile(content) {
+async function parseGoFile(content, filePath) {
+  if (filePath) {
+    const cached = parseCache.get(`go:${filePath}`);
+    if (cached !== void 0) return cached;
+  }
   if (!goLang) {
     const ok = await initGoParser();
     if (!ok) return null;
@@ -4591,13 +4171,23 @@ async function parseGoFile(content) {
   try {
     parserInstance.setLanguage(goLang);
     const tree = parserInstance.parse(content);
-    if (!tree) return null;
-    return convertNode(tree.rootNode, null);
+    if (!tree) {
+      if (filePath) parseCache.set(`go:${filePath}`, null);
+      return null;
+    }
+    const result = convertNode(tree.rootNode, null);
+    if (filePath) parseCache.set(`go:${filePath}`, result);
+    return result;
   } catch {
+    if (filePath) parseCache.set(`go:${filePath}`, null);
     return null;
   }
 }
-async function parseRustFile(content) {
+async function parseRustFile(content, filePath) {
+  if (filePath) {
+    const cached = parseCache.get(`rs:${filePath}`);
+    if (cached !== void 0) return cached;
+  }
   if (!rustLang) {
     const ok = await initRustParser();
     if (!ok) return null;
@@ -4609,444 +4199,928 @@ async function parseRustFile(content) {
   try {
     parserInstance.setLanguage(rustLang);
     const tree = parserInstance.parse(content);
-    if (!tree) return null;
-    return convertNode(tree.rootNode, null);
+    if (!tree) {
+      if (filePath) parseCache.set(`rs:${filePath}`, null);
+      return null;
+    }
+    const result = convertNode(tree.rootNode, null);
+    if (filePath) parseCache.set(`rs:${filePath}`, result);
+    return result;
   } catch {
+    if (filePath) parseCache.set(`rs:${filePath}`, null);
     return null;
   }
 }
-async function parsePhpFile(content) {
+async function parsePhpFile(content, filePath) {
+  if (filePath) {
+    const cached = parseCache.get(`php:${filePath}`);
+    if (cached !== void 0) return cached;
+  }
   if (!phpLang) {
     const ok = await initPhpParser();
     if (!ok) return null;
   }
-  if (!parserInstance) {
-    const ok = await initParser();
-    if (!ok) return null;
+  if (!parserInstance) {
+    const ok = await initParser();
+    if (!ok) return null;
+  }
+  try {
+    parserInstance.setLanguage(phpLang);
+    const tree = parserInstance.parse(content);
+    if (!tree) {
+      if (filePath) parseCache.set(`php:${filePath}`, null);
+      return null;
+    }
+    const result = convertNode(tree.rootNode, null);
+    if (filePath) parseCache.set(`php:${filePath}`, result);
+    return result;
+  } catch {
+    if (filePath) parseCache.set(`php:${filePath}`, null);
+    return null;
+  }
+}
+async function parseCsharpFile(content, filePath) {
+  if (filePath) {
+    const cached = parseCache.get(`cs:${filePath}`);
+    if (cached !== void 0) return cached;
+  }
+  if (!csharpLang) {
+    const ok = await initCsharpParser();
+    if (!ok) return null;
+  }
+  if (!parserInstance) {
+    const ok = await initParser();
+    if (!ok) return null;
+  }
+  try {
+    parserInstance.setLanguage(csharpLang);
+    const tree = parserInstance.parse(content);
+    if (!tree) {
+      if (filePath) parseCache.set(`cs:${filePath}`, null);
+      return null;
+    }
+    const result = convertNode(tree.rootNode, null);
+    if (filePath) parseCache.set(`cs:${filePath}`, result);
+    return result;
+  } catch {
+    if (filePath) parseCache.set(`cs:${filePath}`, null);
+    return null;
+  }
+}
+async function parseSwiftFile(content, filePath) {
+  if (filePath) {
+    const cached = parseCache.get(`swift:${filePath}`);
+    if (cached !== void 0) return cached;
+  }
+  if (!swiftLang) {
+    const ok = await initSwiftParser();
+    if (!ok) return null;
+  }
+  if (!parserInstance) {
+    const ok = await initParser();
+    if (!ok) return null;
+  }
+  try {
+    parserInstance.setLanguage(swiftLang);
+    const tree = parserInstance.parse(content);
+    if (!tree) {
+      if (filePath) parseCache.set(`swift:${filePath}`, null);
+      return null;
+    }
+    const result = convertNode(tree.rootNode, null);
+    if (filePath) parseCache.set(`swift:${filePath}`, result);
+    return result;
+  } catch {
+    if (filePath) parseCache.set(`swift:${filePath}`, null);
+    return null;
+  }
+}
+function findNodesOfType(root, type) {
+  const results = [];
+  function walk(node) {
+    if (node.type === type) results.push(node);
+    for (const child of node.children) walk(child);
+  }
+  walk(root);
+  return results;
+}
+function findNodesOfTypes(root, types3) {
+  const typeSet = new Set(types3);
+  const results = [];
+  function walk(node) {
+    if (typeSet.has(node.type)) results.push(node);
+    for (const child of node.children) walk(child);
+  }
+  walk(root);
+  return results;
+}
+function walkAST(root, visitor) {
+  function walk(node) {
+    const result = visitor(node);
+    if (result !== false) {
+      for (const child of node.children) walk(child);
+    }
+  }
+  walk(root);
+}
+function findAncestor(node, predicate) {
+  let current = node.parent;
+  while (current) {
+    if (predicate(current)) return current;
+    current = current.parent;
+  }
+  return null;
+}
+function isInsideCatch(node) {
+  return findAncestor(node, (n) => n.type === "catch_clause") !== null;
+}
+function findAncestorOfType(node, type) {
+  return findAncestor(node, (n) => n.type === type);
+}
+function isCatchBodyEmpty(catchNode) {
+  if (catchNode.type !== "catch_clause") return false;
+  const body = catchNode.children.find(
+    (c) => c.type === "statement_block" || c.type === "block"
+  );
+  if (!body) return true;
+  const nonTrivial = body.children.filter(
+    (c) => c.type !== "comment" && c.type !== "//" && c.type !== "/*" && c.type !== "{" && c.type !== "}" && c.text.trim() !== ""
+  );
+  return nonTrivial.length === 0;
+}
+function getAsExpressionType(node) {
+  if (node.type !== "as_expression") return null;
+  const typeChild = node.children.find((c) => c.fieldName === "type");
+  return typeChild?.text ?? null;
+}
+function getAsExpressionContext(node) {
+  if (isInsideCatch(node)) return "catch";
+  const funcAncestor = findAncestor(
+    node,
+    (n) => ["function_declaration", "arrow_function", "method_definition"].includes(n.type)
+  );
+  if (funcAncestor) {
+    const text = funcAncestor.text.toLowerCase();
+    if (/prisma|drizzle|sequelize|mongoose|typeorm|knex|supabase/.test(text))
+      return "orm";
+    if (/json\.parse|parse\(/.test(text)) return "json";
+  }
+  return "unknown";
+}
+function extractImportFromNode(node) {
+  if (node.type !== "import_statement" && node.type !== "import_declaration")
+    return null;
+  const sourceNode = node.children.find(
+    (c) => c.type === "string" || c.fieldName === "source"
+  );
+  if (!sourceNode) return null;
+  const source = sourceNode.text.replace(/^['"]|['"]$/g, "");
+  const isTypeOnly = node.text.includes("import type ");
+  const symbols = [];
+  const namedImport = node.children.find(
+    (c) => c.type === "named_imports" || c.type === "import_clause"
+  );
+  if (namedImport) {
+    for (const child of namedImport.children) {
+      if (child.type === "identifier" || child.type === "type_identifier" || child.type === "import_specifier") {
+        symbols.push(child.text);
+      }
+    }
+  }
+  return { source, symbols, line: node.startRow + 1, isTypeOnly };
+}
+function findPythonFunctions(root) {
+  const funcNodes = findNodesOfTypes(root, [
+    "function_definition",
+    "decorated_definition"
+  ]);
+  const results = [];
+  for (const node of funcNodes) {
+    if (node.type === "decorated_definition") {
+      const inner = node.children.find(
+        (c) => c.type === "function_definition"
+      );
+      if (inner) {
+        results.push(extractPythonFunctionInfo(inner, node));
+      }
+    } else {
+      results.push(extractPythonFunctionInfo(node));
+    }
+  }
+  return results;
+}
+function findPythonClasses(root) {
+  const classNodes = findNodesOfTypes(root, [
+    "class_definition",
+    "decorated_definition"
+  ]);
+  const results = [];
+  for (const node of classNodes) {
+    if (node.type === "decorated_definition") {
+      const inner = node.children.find(
+        (c) => c.type === "class_definition"
+      );
+      if (inner) {
+        results.push(extractPythonClassInfo(inner, node));
+      }
+    } else {
+      results.push(extractPythonClassInfo(node));
+    }
+  }
+  return results;
+}
+function findPythonImports(root) {
+  const importNodes = findNodesOfTypes(root, [
+    "import_statement",
+    "import_from_statement"
+  ]);
+  return importNodes.map(extractPythonImportInfo);
+}
+function isPythonFunctionStub(funcInfo) {
+  const text = funcInfo.text;
+  const bodyLines = text.split("\n").slice(1).join("\n").trim();
+  if (/^(\s*(pass|\.\.\.)\s*)$/.test(bodyLines)) return true;
+  const docstringOnly = bodyLines.replace(/"""[\s\S]*?"""/g, "").replace(/'''[\s\S]*?'''/g, "").trim();
+  if (docstringOnly === "" || docstringOnly === "pass" || docstringOnly === "...") {
+    return true;
+  }
+  return false;
+}
+function detectPythonAIPatterns(root) {
+  const findings = [];
+  const functions = findPythonFunctions(root);
+  for (const fn of functions) {
+    if (isPythonFunctionStub(fn)) {
+      findings.push({
+        type: "python-stub-function",
+        message: `Function '${fn.name}' is a stub (only pass/ellipsis)`,
+        line: fn.line
+      });
+    }
+  }
+  const tryNodes = findNodesOfType(root, "try_statement");
+  for (const tryNode of tryNodes) {
+    const exceptNodes = tryNode.children.filter(
+      (c) => c.type === "except_clause"
+    );
+    for (const exceptNode of exceptNodes) {
+      const hasSpecificType = exceptNode.children.some(
+        (c) => c.type === "identifier" || c.type === "tuple"
+      );
+      if (!hasSpecificType) {
+        const bareExcept = exceptNode.children.find(
+          (c) => c.text && c.text.includes("except")
+        );
+        findings.push({
+          type: "python-bare-except",
+          message: "Bare except clause catches all exceptions",
+          line: exceptNode.startRow + 1
+        });
+      }
+    }
+  }
+  const commentNodes = findNodesOfType(root, "comment");
+  for (const comment of commentNodes) {
+    const text = comment.text.toLowerCase();
+    if (/todo|fixme|hack|xxx/.test(text)) {
+      findings.push({
+        type: "python-todo-stub",
+        message: `TODO/FIXME comment: ${comment.text.trim()}`,
+        line: comment.startRow + 1
+      });
+    }
   }
-  try {
-    parserInstance.setLanguage(phpLang);
-    const tree = parserInstance.parse(content);
-    if (!tree) return null;
-    return convertNode(tree.rootNode, null);
-  } catch {
-    return null;
+  const callNodes = findNodesOfType(root, "call");
+  for (const call of callNodes) {
+    const func = call.children[0];
+    if (func && func.text === "print") {
+      findings.push({
+        type: "python-print-leftover",
+        message: "print() statement \u2014 likely debug leftover",
+        line: call.startRow + 1
+      });
+    }
   }
+  return findings;
 }
-async function parseCsharpFile(content) {
-  if (!csharpLang) {
-    const ok = await initCsharpParser();
-    if (!ok) return null;
-  }
-  if (!parserInstance) {
-    const ok = await initParser();
-    if (!ok) return null;
-  }
-  try {
-    parserInstance.setLanguage(csharpLang);
-    const tree = parserInstance.parse(content);
-    if (!tree) return null;
-    return convertNode(tree.rootNode, null);
-  } catch {
-    return null;
+function extractPythonFunctionInfo(funcNode, decoratedParent) {
+  const nameNode = funcNode.children.find((c) => c.fieldName === "name") ?? funcNode.children.find((c) => c.type === "identifier");
+  const name = nameNode?.text ?? "(anonymous)";
+  const params = funcNode.children.find(
+    (c) => c.type === "parameters"
+  );
+  const parameters = params ? params.children.filter((c) => c.type === "identifier" || c.type === "typed_parameter" || c.type === "default_parameter").map((c) => c.children[0]?.text ?? c.text) : [];
+  const isAsync = funcNode.children.some(
+    (c) => c.type === "async"
+  );
+  const decorators = [];
+  if (decoratedParent) {
+    for (const child of decoratedParent.children) {
+      if (child.type === "decorator") {
+        decorators.push(child.text.replace("@", ""));
+      }
+    }
   }
+  return {
+    name,
+    decorators,
+    parameters,
+    isAsync,
+    line: funcNode.startRow + 1,
+    endLine: funcNode.endRow + 1,
+    text: funcNode.text
+  };
 }
-async function parseSwiftFile(content) {
-  if (!swiftLang) {
-    const ok = await initSwiftParser();
-    if (!ok) return null;
+function extractPythonClassInfo(classNode, decoratedParent) {
+  const nameNode = classNode.children.find((c) => c.fieldName === "name") ?? classNode.children.find((c) => c.type === "identifier");
+  const name = nameNode?.text ?? "(anonymous)";
+  const argList = classNode.children.find(
+    (c) => c.type === "argument_list"
+  );
+  const bases = argList ? argList.children.filter((c) => c.type === "identifier" || c.type === "attribute").map((c) => c.text) : [];
+  const decorators = [];
+  if (decoratedParent) {
+    for (const child of decoratedParent.children) {
+      if (child.type === "decorator") {
+        decorators.push(child.text.replace("@", ""));
+      }
+    }
   }
-  if (!parserInstance) {
-    const ok = await initParser();
-    if (!ok) return null;
+  const body = classNode.children.find(
+    (c) => c.type === "block"
+  );
+  const methods = [];
+  if (body) {
+    for (const child of body.children) {
+      if (child.type === "function_definition") {
+        methods.push(extractPythonFunctionInfo(child));
+      } else if (child.type === "decorated_definition") {
+        const inner = child.children.find(
+          (c) => c.type === "function_definition"
+        );
+        if (inner) {
+          methods.push(extractPythonFunctionInfo(inner, child));
+        }
+      }
+    }
   }
-  try {
-    parserInstance.setLanguage(swiftLang);
-    const tree = parserInstance.parse(content);
-    if (!tree) return null;
-    return convertNode(tree.rootNode, null);
-  } catch {
-    return null;
+  return {
+    name,
+    bases,
+    decorators,
+    methods,
+    line: classNode.startRow + 1,
+    endLine: classNode.endRow + 1,
+    text: classNode.text
+  };
+}
+function extractPythonImportInfo(importNode) {
+  const isFromImport = importNode.type === "import_from_statement";
+  let module = "";
+  const symbols = [];
+  if (isFromImport) {
+    const moduleNode = importNode.children.find(
+      (c) => c.fieldName === "module_name" || c.type === "dotted_name" && c.fieldName !== "name" || c.type === "identifier" && c.fieldName !== "name"
+    );
+    module = moduleNode?.text ?? "";
+    const nameList = importNode.children.find(
+      (c) => c.type === "dotted_name" && c !== moduleNode
+    );
+    const identifierChildren = importNode.children.filter(
+      (c) => c.type === "identifier" && c !== moduleNode
+    );
+    if (nameList) {
+      symbols.push(nameList.text);
+    }
+    for (const id of identifierChildren) {
+      if (id.text !== "from" && id.text !== "import" && id.text !== module) {
+        symbols.push(id.text);
+      }
+    }
+  } else {
+    const dottedNames = importNode.children.filter(
+      (c) => c.type === "dotted_name"
+    );
+    const identifiers = importNode.children.filter(
+      (c) => c.type === "identifier"
+    );
+    for (const dn of dottedNames) {
+      symbols.push(dn.text);
+    }
+    for (const id of identifiers) {
+      if (id.text !== "import") {
+        symbols.push(id.text);
+      }
+    }
+    module = symbols[0] ?? "";
   }
+  return {
+    module,
+    symbols,
+    isFromImport,
+    line: importNode.startRow + 1,
+    text: importNode.text
+  };
 }
-function findNodesOfType(root, type) {
-  const results = [];
-  function walk(node) {
-    if (node.type === type) results.push(node);
-    for (const child of node.children) walk(child);
+function convertNode(node, parent) {
+  const children = [];
+  const astNode = {
+    type: node.type,
+    text: node.text,
+    startRow: node.startPosition.row,
+    startCol: node.startPosition.column,
+    endRow: node.endPosition.row,
+    endCol: node.endPosition.column,
+    children,
+    parent,
+    fieldName: null
+  };
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (child) {
+      const converted = convertNode(child, astNode);
+      converted.fieldName = node.fieldNameForChild(i) ?? null;
+      children.push(converted);
+    }
   }
-  walk(root);
-  return results;
+  return astNode;
 }
-function findNodesOfTypes(root, types3) {
-  const typeSet = new Set(types3);
-  const results = [];
-  function walk(node) {
-    if (typeSet.has(node.type)) results.push(node);
-    for (const child of node.children) walk(child);
+var parseCache, parserInstance, tsLang, tsxLang, initPromise, initDone, initOk, pyLang, pyInitDone, pyInitOk, goLang, goInitDone, goInitOk, rustLang, rustInitDone, rustInitOk, phpLang, phpInitDone, phpInitOk, csharpLang, csharpInitDone, csharpInitOk, swiftLang, swiftInitDone, swiftInitOk;
+var init_tree_sitter = __esm({
+  "src/utils/tree-sitter.ts"() {
+    "use strict";
+    parseCache = /* @__PURE__ */ new Map();
+    parserInstance = null;
+    tsLang = null;
+    tsxLang = null;
+    initPromise = null;
+    initDone = false;
+    initOk = false;
+    pyLang = null;
+    pyInitDone = false;
+    pyInitOk = false;
+    goLang = null;
+    goInitDone = false;
+    goInitOk = false;
+    rustLang = null;
+    rustInitDone = false;
+    rustInitOk = false;
+    phpLang = null;
+    phpInitDone = false;
+    phpInitOk = false;
+    csharpLang = null;
+    csharpInitDone = false;
+    csharpInitOk = false;
+    swiftLang = null;
+    swiftInitDone = false;
+    swiftInitOk = false;
+  }
+});
+
+// src/plugins/loader.ts
+async function loadPlugin(pluginPath) {
+  try {
+    const mod = await import(pluginPath);
+    const engine = mod.default;
+    if (!engine || typeof engine !== "object") {
+      return null;
+    }
+    if (typeof engine.name === "string" && typeof engine.description === "string" && Array.isArray(engine.supportedLanguages) && typeof engine.run === "function") {
+      return engine;
+    }
+    return null;
+  } catch {
+    return null;
   }
-  walk(root);
-  return results;
 }
-function walkAST(root, visitor) {
-  function walk(node) {
-    const result = visitor(node);
-    if (result !== false) {
-      for (const child of node.children) walk(child);
+async function loadPlugins(paths) {
+  const results = await Promise.allSettled(
+    paths.map((p) => loadPlugin(p))
+  );
+  const engines = [];
+  for (const r of results) {
+    if (r.status === "fulfilled" && r.value !== null) {
+      engines.push(r.value);
     }
   }
-  walk(root);
+  return engines;
 }
-function findAncestor(node, predicate) {
-  let current = node.parent;
-  while (current) {
-    if (predicate(current)) return current;
-    current = current.parent;
+var init_loader = __esm({
+  "src/plugins/loader.ts"() {
+    "use strict";
   }
-  return null;
-}
-function isInsideCatch(node) {
-  return findAncestor(node, (n) => n.type === "catch_clause") !== null;
-}
-function findAncestorOfType(node, type) {
-  return findAncestor(node, (n) => n.type === type);
-}
-function isCatchBodyEmpty(catchNode) {
-  if (catchNode.type !== "catch_clause") return false;
-  const body = catchNode.children.find(
-    (c) => c.type === "statement_block" || c.type === "block"
-  );
-  if (!body) return true;
-  const nonTrivial = body.children.filter(
-    (c) => c.type !== "comment" && c.type !== "//" && c.type !== "/*" && c.type !== "{" && c.type !== "}" && c.text.trim() !== ""
-  );
-  return nonTrivial.length === 0;
-}
-function getAsExpressionType(node) {
-  if (node.type !== "as_expression") return null;
-  const typeChild = node.children.find((c) => c.fieldName === "type");
-  return typeChild?.text ?? null;
+});
+
+// src/plugins/registry.ts
+var registry_exports = {};
+__export(registry_exports, {
+  PLUGIN_DIR: () => PLUGIN_DIR,
+  discoverAndLoadPlugins: () => discoverAndLoadPlugins,
+  getPluginDir: () => getPluginDir,
+  pluginRegistry: () => pluginRegistry
+});
+import { join as join2 } from "node:path";
+import { readdir } from "node:fs/promises";
+import { existsSync as existsSync2 } from "node:fs";
+function getPluginDir(rootDir) {
+  return join2(rootDir, PLUGIN_DIR);
 }
-function getAsExpressionContext(node) {
-  if (isInsideCatch(node)) return "catch";
-  const funcAncestor = findAncestor(
-    node,
-    (n) => ["function_declaration", "arrow_function", "method_definition"].includes(n.type)
-  );
-  if (funcAncestor) {
-    const text = funcAncestor.text.toLowerCase();
-    if (/prisma|drizzle|sequelize|mongoose|typeorm|knex|supabase/.test(text))
-      return "orm";
-    if (/json\.parse|parse\(/.test(text)) return "json";
+async function discoverAndLoadPlugins(rootDir) {
+  if (pluginRegistry.isLoaded) {
+    return pluginRegistry.getEngines();
   }
-  return "unknown";
-}
-function extractImportFromNode(node) {
-  if (node.type !== "import_statement" && node.type !== "import_declaration")
-    return null;
-  const sourceNode = node.children.find(
-    (c) => c.type === "string" || c.fieldName === "source"
-  );
-  if (!sourceNode) return null;
-  const source = sourceNode.text.replace(/^['"]|['"]$/g, "");
-  const isTypeOnly = node.text.includes("import type ");
-  const symbols = [];
-  const namedImport = node.children.find(
-    (c) => c.type === "named_imports" || c.type === "import_clause"
-  );
-  if (namedImport) {
-    for (const child of namedImport.children) {
-      if (child.type === "identifier" || child.type === "type_identifier" || child.type === "import_specifier") {
-        symbols.push(child.text);
-      }
-    }
+  const pluginDir = getPluginDir(rootDir);
+  if (!existsSync2(pluginDir)) {
+    pluginRegistry.setLoaded(true);
+    return [];
   }
-  return { source, symbols, line: node.startRow + 1, isTypeOnly };
-}
-function findPythonFunctions(root) {
-  const funcNodes = findNodesOfTypes(root, [
-    "function_definition",
-    "decorated_definition"
-  ]);
-  const results = [];
-  for (const node of funcNodes) {
-    if (node.type === "decorated_definition") {
-      const inner = node.children.find(
-        (c) => c.type === "function_definition"
-      );
-      if (inner) {
-        results.push(extractPythonFunctionInfo(inner, node));
-      }
-    } else {
-      results.push(extractPythonFunctionInfo(node));
+  try {
+    const files = await readdir(pluginDir);
+    const pluginPaths = files.filter((f) => f.endsWith(".js") || f.endsWith(".mjs")).map((f) => join2(pluginDir, f));
+    const engines = await loadPlugins(pluginPaths);
+    for (let i = 0; i < engines.length; i++) {
+      const engine = engines[i];
+      pluginRegistry.register({
+        id: engine.name,
+        path: pluginPaths[i],
+        engine,
+        loaded: true
+      });
     }
-  }
-  return results;
-}
-function findPythonClasses(root) {
-  const classNodes = findNodesOfTypes(root, [
-    "class_definition",
-    "decorated_definition"
-  ]);
-  const results = [];
-  for (const node of classNodes) {
-    if (node.type === "decorated_definition") {
-      const inner = node.children.find(
-        (c) => c.type === "class_definition"
-      );
-      if (inner) {
-        results.push(extractPythonClassInfo(inner, node));
+    for (let i = 0; i < pluginPaths.length; i++) {
+      const path2 = pluginPaths[i];
+      const engine = engines.find((e) => {
+        const entry = pluginRegistry.getAll().find((ent) => ent.path === path2);
+        return entry?.engine;
+      });
+      if (!engine && !pluginRegistry.has(path2)) {
+        pluginRegistry.register({
+          id: `plugin-${i}`,
+          path: path2,
+          engine: null,
+          loaded: false,
+          error: "Failed to load plugin module"
+        });
       }
-    } else {
-      results.push(extractPythonClassInfo(node));
     }
+    pluginRegistry.setLoaded(true);
+    return engines;
+  } catch {
+    pluginRegistry.setLoaded(true);
+    return [];
   }
-  return results;
-}
-function findPythonImports(root) {
-  const importNodes = findNodesOfTypes(root, [
-    "import_statement",
-    "import_from_statement"
-  ]);
-  return importNodes.map(extractPythonImportInfo);
 }
-function isPythonFunctionStub(funcInfo) {
-  const text = funcInfo.text;
-  const bodyLines = text.split("\n").slice(1).join("\n").trim();
-  if (/^(\s*(pass|\.\.\.)\s*)$/.test(bodyLines)) return true;
-  const docstringOnly = bodyLines.replace(/"""[\s\S]*?"""/g, "").replace(/'''[\s\S]*?'''/g, "").trim();
-  if (docstringOnly === "" || docstringOnly === "pass" || docstringOnly === "...") {
-    return true;
+var PluginRegistry, pluginRegistry, PLUGIN_DIR;
+var init_registry = __esm({
+  "src/plugins/registry.ts"() {
+    "use strict";
+    init_loader();
+    PluginRegistry = class {
+      entries = /* @__PURE__ */ new Map();
+      loaded = false;
+      /** Get all registered plugins */
+      getAll() {
+        return [...this.entries.values()];
+      }
+      /** Get all successfully loaded engines */
+      getEngines() {
+        return [...this.entries.values()].filter((e) => e.loaded).map((e) => e.engine);
+      }
+      /** Get a specific plugin by id */
+      get(id) {
+        return this.entries.get(id);
+      }
+      /** Get a loaded engine by name */
+      getEngine(name) {
+        const entry = this.entries.get(name);
+        return entry?.loaded ? entry.engine : void 0;
+      }
+      /** Register a plugin entry */
+      register(entry) {
+        this.entries.set(entry.id, entry);
+      }
+      /** Remove a plugin by id */
+      remove(id) {
+        return this.entries.delete(id);
+      }
+      /** Check if a plugin is registered */
+      has(id) {
+        return this.entries.has(id);
+      }
+      /** Number of registered plugins */
+      get size() {
+        return this.entries.size;
+      }
+      /** Whether the registry has been loaded from disk */
+      get isLoaded() {
+        return this.loaded;
+      }
+      /** Mark the registry as loaded */
+      setLoaded(loaded) {
+        this.loaded = loaded;
+      }
+      /** Clear all entries */
+      clear() {
+        this.entries.clear();
+        this.loaded = false;
+      }
+    };
+    pluginRegistry = new PluginRegistry();
+    PLUGIN_DIR = ".deep-slop/plugins";
   }
-  return false;
-}
-function detectPythonAIPatterns(root) {
-  const findings = [];
-  const functions = findPythonFunctions(root);
-  for (const fn of functions) {
-    if (isPythonFunctionStub(fn)) {
-      findings.push({
-        type: "python-stub-function",
-        message: `Function '${fn.name}' is a stub (only pass/ellipsis)`,
-        line: fn.line
+});
+
+// src/utils/suppress.ts
+import { join as join3 } from "node:path";
+import { readFileSync as readFileSync2 } from "node:fs";
+function parseSuppressDirectives(content) {
+  const entries = [];
+  const lines = content.split("\n");
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i].trim();
+    const lineNum = i + 1;
+    const ignoreNextMatch = line.match(
+      /\/\/\s*deep-slop-ignore-next(?:\s+(.+))?$/
+    );
+    if (ignoreNextMatch) {
+      entries.push({
+        directiveLine: lineNum,
+        targetLine: lineNum + 1,
+        rules: parseRuleList(ignoreNextMatch[1]),
+        type: "next-line"
       });
+      continue;
     }
-  }
-  const tryNodes = findNodesOfType(root, "try_statement");
-  for (const tryNode of tryNodes) {
-    const exceptNodes = tryNode.children.filter(
-      (c) => c.type === "except_clause"
+    const ignoreLineMatch = line.match(
+      /\/\/\s*deep-slop-ignore-line(?:\s+(.+))?$/
     );
-    for (const exceptNode of exceptNodes) {
-      const hasSpecificType = exceptNode.children.some(
-        (c) => c.type === "identifier" || c.type === "tuple"
-      );
-      if (!hasSpecificType) {
-        const bareExcept = exceptNode.children.find(
-          (c) => c.text && c.text.includes("except")
-        );
-        findings.push({
-          type: "python-bare-except",
-          message: "Bare except clause catches all exceptions",
-          line: exceptNode.startRow + 1
+    if (ignoreLineMatch) {
+      entries.push({
+        directiveLine: lineNum,
+        targetLine: lineNum,
+        rules: parseRuleList(ignoreLineMatch[1]),
+        type: "line"
+      });
+      continue;
+    }
+    const ignoreRuleMatch = line.match(
+      /\/\/\s*deep-slop-ignore(?:\s+(.+))?$/
+    );
+    if (ignoreRuleMatch) {
+      const rulePart = ignoreRuleMatch[1];
+      if (rulePart !== "start" && rulePart !== "end") {
+        entries.push({
+          directiveLine: lineNum,
+          targetLine: lineNum + 1,
+          rules: parseRuleList(rulePart),
+          type: "next-line"
         });
+        continue;
       }
     }
-  }
-  const commentNodes = findNodesOfType(root, "comment");
-  for (const comment of commentNodes) {
-    const text = comment.text.toLowerCase();
-    if (/todo|fixme|hack|xxx/.test(text)) {
-      findings.push({
-        type: "python-todo-stub",
-        message: `TODO/FIXME comment: ${comment.text.trim()}`,
-        line: comment.startRow + 1
+    const ignoreStartMatch = line.match(
+      /\/\/\s*deep-slop-ignore-start(?:\s+(.+))?$/
+    );
+    if (ignoreStartMatch) {
+      entries.push({
+        directiveLine: lineNum,
+        targetLine: lineNum,
+        rules: parseRuleList(ignoreStartMatch[1]),
+        type: "block-start"
       });
+      continue;
     }
-  }
-  const callNodes = findNodesOfType(root, "call");
-  for (const call of callNodes) {
-    const func = call.children[0];
-    if (func && func.text === "print") {
-      findings.push({
-        type: "python-print-leftover",
-        message: "print() statement \u2014 likely debug leftover",
-        line: call.startRow + 1
+    const ignoreEndMatch = line.match(
+      /\/\/\s*deep-slop-ignore-end/
+    );
+    if (ignoreEndMatch) {
+      entries.push({
+        directiveLine: lineNum,
+        targetLine: lineNum,
+        rules: /* @__PURE__ */ new Set(),
+        type: "block-end"
+      });
+      continue;
+    }
+    const nextLineMatch = line.match(
+      /\/\/\s*deep-slop-disable-next-line(?:\s+(.+))?$/
+    );
+    if (nextLineMatch) {
+      entries.push({
+        directiveLine: lineNum,
+        targetLine: lineNum + 1,
+        rules: parseRuleList(nextLineMatch[1]),
+        type: "next-line"
+      });
+      continue;
+    }
+    const lineMatch = line.match(
+      /\/\/\s*deep-slop-disable-line(?:\s+(.+))?$/
+    );
+    if (lineMatch) {
+      entries.push({
+        directiveLine: lineNum,
+        targetLine: lineNum,
+        rules: parseRuleList(lineMatch[1]),
+        type: "line"
+      });
+      continue;
+    }
+    const blockStart = line.match(
+      /\/\*\s*deep-slop-disable(?:\s+(.+))?\s*\//
+    );
+    if (blockStart) {
+      entries.push({
+        directiveLine: lineNum,
+        targetLine: lineNum,
+        rules: parseRuleList(blockStart[1]),
+        type: "block-start"
+      });
+      continue;
+    }
+    const blockEnd = line.match(/\/\*\s*deep-slop-enable\s*\//);
+    if (blockEnd) {
+      entries.push({
+        directiveLine: lineNum,
+        targetLine: lineNum,
+        rules: /* @__PURE__ */ new Set(),
+        type: "block-end"
       });
     }
   }
-  return findings;
+  return entries;
 }
-function extractPythonFunctionInfo(funcNode, decoratedParent) {
-  const nameNode = funcNode.children.find((c) => c.fieldName === "name") ?? funcNode.children.find((c) => c.type === "identifier");
-  const name = nameNode?.text ?? "(anonymous)";
-  const params = funcNode.children.find(
-    (c) => c.type === "parameters"
-  );
-  const parameters = params ? params.children.filter((c) => c.type === "identifier" || c.type === "typed_parameter" || c.type === "default_parameter").map((c) => c.children[0]?.text ?? c.text) : [];
-  const isAsync = funcNode.children.some(
-    (c) => c.type === "async"
-  );
-  const decorators = [];
-  if (decoratedParent) {
-    for (const child of decoratedParent.children) {
-      if (child.type === "decorator") {
-        decorators.push(child.text.replace("@", ""));
-      }
+function parseRuleList(rulesStr) {
+  if (!rulesStr) return /* @__PURE__ */ new Set();
+  const rules = rulesStr.split(/[,\\s]+/).map((r) => r.trim()).filter(Boolean);
+  return new Set(rules);
+}
+function buildSuppressChecker(entries) {
+  const blockRanges = [];
+  let currentStart = null;
+  for (const entry of entries) {
+    if (entry.type === "block-start") {
+      currentStart = { line: entry.directiveLine, rules: entry.rules };
+    } else if (entry.type === "block-end" && currentStart) {
+      blockRanges.push({
+        startLine: currentStart.line,
+        endLine: entry.directiveLine,
+        rules: currentStart.rules
+      });
+      currentStart = null;
     }
   }
-  return {
-    name,
-    decorators,
-    parameters,
-    isAsync,
-    line: funcNode.startRow + 1,
-    endLine: funcNode.endRow + 1,
-    text: funcNode.text
+  if (currentStart) {
+    blockRanges.push({
+      startLine: currentStart.line,
+      endLine: 999999,
+      rules: currentStart.rules
+    });
+  }
+  return (line, rule) => {
+    for (const entry of entries) {
+      if (entry.type === "next-line" || entry.type === "line") {
+        if (entry.targetLine === line) {
+          if (entry.rules.size === 0 || entry.rules.has(rule)) {
+            return true;
+          }
+        }
+      }
+    }
+    for (const range2 of blockRanges) {
+      if (line >= range2.startLine && line <= range2.endLine) {
+        if (range2.rules.size === 0 || range2.rules.has(rule)) {
+          return true;
+        }
+      }
+    }
+    return false;
   };
 }
-function extractPythonClassInfo(classNode, decoratedParent) {
-  const nameNode = classNode.children.find((c) => c.fieldName === "name") ?? classNode.children.find((c) => c.type === "identifier");
-  const name = nameNode?.text ?? "(anonymous)";
-  const argList = classNode.children.find(
-    (c) => c.type === "argument_list"
-  );
-  const bases = argList ? argList.children.filter((c) => c.type === "identifier" || c.type === "attribute").map((c) => c.text) : [];
-  const decorators = [];
-  if (decoratedParent) {
-    for (const child of decoratedParent.children) {
-      if (child.type === "decorator") {
-        decorators.push(child.text.replace("@", ""));
-      }
+function buildSuppressMap(content) {
+  const entries = parseSuppressDirectives(content);
+  const isSuppressed = buildSuppressChecker(entries);
+  return { entries, isSuppressed };
+}
+function loadIgnoreFile(rootDir) {
+  const ignorePath = join3(rootDir, ".deep-slop", ".deep-slop-ignore");
+  try {
+    const content = readFileSync2(ignorePath, "utf-8");
+    return content.split("\n").map((line) => line.split("#")[0].trim()).filter((line) => line && !line.startsWith("file:"));
+  } catch {
+    return [];
+  }
+}
+function applySuppressDirectives(diagnostics, fileContents, globallySuppressed = /* @__PURE__ */ new Set()) {
+  const suppressMaps = /* @__PURE__ */ new Map();
+  for (const [filePath, content] of fileContents) {
+    suppressMaps.set(filePath, buildSuppressMap(content));
+  }
+  const filtered = [];
+  let suppressedCount = 0;
+  for (const diag8 of diagnostics) {
+    if (globallySuppressed.has(diag8.rule)) {
+      suppressedCount++;
+      continue;
+    }
+    const map = suppressMaps.get(diag8.filePath);
+    if (map && map.isSuppressed(diag8.line, diag8.rule)) {
+      suppressedCount++;
+    } else {
+      filtered.push(diag8);
     }
   }
-  const body = classNode.children.find(
-    (c) => c.type === "block"
-  );
-  const methods = [];
-  if (body) {
-    for (const child of body.children) {
-      if (child.type === "function_definition") {
-        methods.push(extractPythonFunctionInfo(child));
-      } else if (child.type === "decorated_definition") {
-        const inner = child.children.find(
-          (c) => c.type === "function_definition"
-        );
-        if (inner) {
-          methods.push(extractPythonFunctionInfo(inner, child));
-        }
-      }
-    }
+  return { filtered, suppressedCount };
+}
+var init_suppress = __esm({
+  "src/utils/suppress.ts"() {
+    "use strict";
   }
-  return {
-    name,
-    bases,
-    decorators,
-    methods,
-    line: classNode.startRow + 1,
-    endLine: classNode.endRow + 1,
-    text: classNode.text
-  };
+});
+
+// src/utils/file-utils.ts
+import { readFile as readFile2 } from "node:fs/promises";
+async function readFileContent(filePath) {
+  const buffer = await readFile2(filePath);
+  let content = buffer.toString("utf-8");
+  if (content.charCodeAt(0) === 65279) {
+    content = content.slice(1);
+  }
+  return content;
 }
-function extractPythonImportInfo(importNode) {
-  const isFromImport = importNode.type === "import_from_statement";
-  let module = "";
-  const symbols = [];
-  if (isFromImport) {
-    const moduleNode = importNode.children.find(
-      (c) => c.fieldName === "module_name" || c.type === "dotted_name" && c.fieldName !== "name" || c.type === "identifier" && c.fieldName !== "name"
-    );
-    module = moduleNode?.text ?? "";
-    const nameList = importNode.children.find(
-      (c) => c.type === "dotted_name" && c !== moduleNode
-    );
-    const identifierChildren = importNode.children.filter(
-      (c) => c.type === "identifier" && c !== moduleNode
-    );
-    if (nameList) {
-      symbols.push(nameList.text);
-    }
-    for (const id of identifierChildren) {
-      if (id.text !== "from" && id.text !== "import" && id.text !== module) {
-        symbols.push(id.text);
+function detectEncodingAnomalies(content) {
+  const hasBom = content.charCodeAt(0) === 65279;
+  const hasCrlf = content.includes("\r\n");
+  const hasZwnbsp = content.includes("\uFEFF");
+  const lfOnly = (content.match(/(?<!\r)\n/g) ?? []).length;
+  const crlfCount = (content.match(/\r\n/g) ?? []).length;
+  const lineEnding = crlfCount > 0 && lfOnly > crlfCount ? "mixed" : crlfCount > 0 ? "crlf" : "lf";
+  return { hasBom, hasCrlf, hasZwnbsp, lineEnding };
+}
+function toLines(content) {
+  return content.split("\n").map((text, i) => ({ num: i + 1, text }));
+}
+function extractImports(content, language) {
+  const imports = [];
+  const lines = toLines(content);
+  for (const { num, text } of lines) {
+    const trimmed = text.trim();
+    if (language === "typescript" || language === "javascript") {
+      const jsMatch = trimmed.match(
+        /^import\s+(?:type\s+)?(?:\{[^}]*\}|\*\s+as\s+\w+|\w+)\s+from\s+['"]([^'"]+)['"]/
+      );
+      if (jsMatch) {
+        imports.push({
+          line: num,
+          source: jsMatch[1],
+          raw: trimmed,
+          isTypeOnly: trimmed.includes("import type"),
+          isDefault: !trimmed.includes("{")
+        });
+      }
+      const dynMatch = trimmed.match(/import\s*\(\s*['"]([^'"]+)['"]\s*\)/);
+      if (dynMatch) {
+        imports.push({
+          line: num,
+          source: dynMatch[1],
+          raw: trimmed,
+          isTypeOnly: false,
+          isDynamic: true
+        });
+      }
+      const reqMatch = trimmed.match(/(?:const|let|var)\s+[^=]*=\s*require\s*\(\s*['"]([^'"]+)['"]\s*\)/);
+      if (reqMatch) {
+        imports.push({
+          line: num,
+          source: reqMatch[1],
+          raw: trimmed,
+          isTypeOnly: false,
+          isRequire: true
+        });
       }
     }
-  } else {
-    const dottedNames = importNode.children.filter(
-      (c) => c.type === "dotted_name"
-    );
-    const identifiers = importNode.children.filter(
-      (c) => c.type === "identifier"
-    );
-    for (const dn of dottedNames) {
-      symbols.push(dn.text);
-    }
-    for (const id of identifiers) {
-      if (id.text !== "import") {
-        symbols.push(id.text);
+    if (language === "python") {
+      const pyMatch = trimmed.match(/^from\s+([^\s]+)\s+import/);
+      if (pyMatch) {
+        imports.push({ line: num, source: pyMatch[1], raw: trimmed, isTypeOnly: false });
+      }
+      const pyImport = trimmed.match(/^import\s+([^\s]+)/);
+      if (pyImport) {
+        imports.push({ line: num, source: pyImport[1], raw: trimmed, isTypeOnly: false });
       }
     }
-    module = symbols[0] ?? "";
-  }
-  return {
-    module,
-    symbols,
-    isFromImport,
-    line: importNode.startRow + 1,
-    text: importNode.text
-  };
-}
-function convertNode(node, parent) {
-  const children = [];
-  const astNode = {
-    type: node.type,
-    text: node.text,
-    startRow: node.startPosition.row,
-    startCol: node.startPosition.column,
-    endRow: node.endPosition.row,
-    endCol: node.endPosition.column,
-    children,
-    parent,
-    fieldName: null
-  };
-  for (let i = 0; i < node.childCount; i++) {
-    const child = node.child(i);
-    if (child) {
-      const converted = convertNode(child, astNode);
-      converted.fieldName = node.fieldNameForChild(i) ?? null;
-      children.push(converted);
+    if (language === "go") {
+      const goMatch = trimmed.match(/"([^"]+)"/);
+      if (trimmed.startsWith("import") && goMatch) {
+        imports.push({ line: num, source: goMatch[1], raw: trimmed, isTypeOnly: false });
+      }
     }
   }
-  return astNode;
+  return imports;
 }
-var parserInstance, tsLang, tsxLang, initPromise, initDone, initOk, pyLang, pyInitDone, pyInitOk, goLang, goInitDone, goInitOk, rustLang, rustInitDone, rustInitOk, phpLang, phpInitDone, phpInitOk, csharpLang, csharpInitDone, csharpInitOk, swiftLang, swiftInitDone, swiftInitOk;
-var init_tree_sitter = __esm({
-  "src/utils/tree-sitter.ts"() {
+var init_file_utils = __esm({
+  "src/utils/file-utils.ts"() {
     "use strict";
-    parserInstance = null;
-    tsLang = null;
-    tsxLang = null;
-    initPromise = null;
-    initDone = false;
-    initOk = false;
-    pyLang = null;
-    pyInitDone = false;
-    pyInitOk = false;
-    goLang = null;
-    goInitDone = false;
-    goInitOk = false;
-    rustLang = null;
-    rustInitDone = false;
-    rustInitOk = false;
-    phpLang = null;
-    phpInitDone = false;
-    phpInitOk = false;
-    csharpLang = null;
-    csharpInitDone = false;
-    csharpInitOk = false;
-    swiftLang = null;
-    swiftInitDone = false;
-    swiftInitOk = false;
   }
 });
 
@@ -25862,6 +25936,7 @@ import { performance as performance3 } from "node:perf_hooks";
 async function runScan(context, callbacks) {
   const startTotal = performance3.now();
   clearFileCache();
+  clearParseCache();
   if (context.files?.length) {
     await preloadFiles(context.files);
   }
@@ -26039,6 +26114,7 @@ var init_orchestrator = __esm({
     init_rule_overrides();
     init_store();
     init_file_cache();
+    init_tree_sitter();
     init_registry();
     init_suppress();
     EXT_TO_LANG = {
@@ -29579,6 +29655,161 @@ var init_list = __esm({
   }
 });
 
+// src/config/json-schema.ts
+var json_schema_exports = {};
+__export(json_schema_exports, {
+  generateJsonSchema: () => generateJsonSchema
+});
+function generateJsonSchema() {
+  return {
+    $schema: "http://json-schema.org/draft-07/schema#",
+    title: "DeepSlopConfig",
+    description: "Configuration for deep-slop \u2014 deep AI slop detection with 18 AST-powered engines",
+    type: "object",
+    properties: {
+      engines: {
+        type: "object",
+        description: "Enable/disable individual analysis engines",
+        additionalProperties: { type: "boolean" },
+        properties: {
+          "ast-slop": { type: "boolean", description: "AI slop pattern detection" },
+          "import-intelligence": { type: "boolean", description: "Import optimization and barrel analysis" },
+          "dead-flow": { type: "boolean", description: "Dead code and unreachable branch detection" },
+          "type-safety": { type: "boolean", description: "TypeScript type safety analysis" },
+          "syntax-deep": { type: "boolean", description: "Syntax anomaly detection" },
+          "security-deep": { type: "boolean", description: "Security vulnerability scanning" },
+          "arch-constraints": { type: "boolean", description: "Architecture constraint analysis" },
+          "dup-detect": { type: "boolean", description: "Duplicate code detection" },
+          "perf-hints": { type: "boolean", description: "Performance hints" },
+          "i18n-lint": { type: "boolean", description: "Internationalization linting" },
+          "config-lint": { type: "boolean", description: "Configuration validation" },
+          "meta-quality": { type: "boolean", description: "Meta quality scoring and trend analysis" },
+          "lint-external": { type: "boolean", description: "External linter integration (ruff, golangci-lint, clippy)" },
+          "arch-rules": { type: "boolean", description: "User-defined architecture rules" },
+          knip: { type: "boolean", description: "Unused dependency/export detection" },
+          "format-lint": { type: "boolean", description: "Formatting consistency" },
+          "framework-lint": { type: "boolean", description: "Framework-specific rules (Next.js, Tailwind)" },
+          "markup-lint": { type: "boolean", description: "Markup & config quality (JSON, YAML, CSS, HTML, Markdown)" }
+        }
+      },
+      exclude: {
+        type: "array",
+        items: { type: "string" },
+        description: "Glob patterns to exclude from scanning",
+        default: ["node_modules", "dist", "coverage", ".git"]
+      },
+      quality: {
+        type: "object",
+        description: "Quality thresholds",
+        properties: {
+          maxFunctionLoc: { type: "number", default: 50, description: "Max lines per function" },
+          maxFileLoc: { type: "number", default: 300, description: "Max lines per file" },
+          maxNesting: { type: "number", default: 4, description: "Max nesting depth" },
+          maxParams: { type: "number", default: 5, description: "Max function parameters" },
+          maxCyclomatic: { type: "number", default: 10, description: "Max cyclomatic complexity" },
+          maxCoupling: { type: "number", default: 7, description: "Max coupling between modules" }
+        },
+        additionalProperties: true
+      },
+      security: {
+        type: "object",
+        description: "Security engine settings",
+        properties: {
+          audit: { type: "boolean", default: true, description: "Run npm audit" },
+          auditTimeout: { type: "number", default: 3e4, description: "Audit timeout in ms" },
+          owasp: { type: "boolean", default: true, description: "Enable OWASP checks" }
+        },
+        additionalProperties: true
+      },
+      imports: {
+        type: "object",
+        description: "Import intelligence settings",
+        properties: {
+          suggestAlternatives: { type: "boolean", default: true },
+          optimizeBarrels: { type: "boolean", default: true },
+          validateAliases: { type: "boolean", default: true },
+          buildGraph: { type: "boolean", default: true },
+          maxCircularDepth: { type: "number", default: 5 }
+        },
+        additionalProperties: true
+      },
+      types: {
+        type: "object",
+        description: "Type safety settings",
+        properties: {
+          flagAsAny: { type: "boolean", default: true },
+          suggestTypes: { type: "boolean", default: true },
+          flagDoubleAssertion: { type: "boolean", default: true }
+        },
+        additionalProperties: true
+      },
+      deadCode: {
+        type: "object",
+        description: "Dead code detection settings",
+        properties: {
+          unreachableBranches: { type: "boolean", default: true },
+          unusedExports: { type: "boolean", default: true },
+          unusedVariables: { type: "boolean", default: true }
+        },
+        additionalProperties: true
+      },
+      i18n: {
+        type: "object",
+        description: "Internationalization settings",
+        properties: {
+          hardcodedStrings: { type: "boolean", default: true },
+          validateKeys: { type: "boolean", default: true }
+        },
+        additionalProperties: true
+      },
+      scoring: {
+        type: "object",
+        description: "Scoring configuration",
+        properties: {
+          mode: { type: "string", enum: ["logarithmic", "linear"], default: "logarithmic" },
+          smoothing: { type: "number", default: 20 },
+          maxPerRule: { type: "number", default: 40 }
+        }
+      },
+      telemetry: {
+        type: "object",
+        description: "Telemetry settings",
+        properties: {
+          enabled: { type: "boolean", default: false }
+        }
+      },
+      ci: {
+        type: "object",
+        description: "CI quality gate settings",
+        properties: {
+          failBelow: { type: "number", default: 70, description: "Minimum score to pass CI" },
+          format: { type: "string", enum: ["json", "human", "sarif"], default: "json" },
+          failOnErrors: { type: "boolean", default: true }
+        }
+      },
+      rules: {
+        type: "object",
+        description: "Per-rule severity overrides (e.g. ast-slop/narrative-comment: off)",
+        additionalProperties: {
+          type: "string",
+          enum: ["off", "info", "suggestion", "warning", "error"]
+        }
+      },
+      extends: {
+        type: "string",
+        description: "Preset to extend (recommended, strict, minimal)",
+        enum: ["recommended", "strict", "minimal"]
+      }
+    },
+    additionalProperties: false
+  };
+}
+var init_json_schema = __esm({
+  "src/config/json-schema.ts"() {
+    "use strict";
+  }
+});
+
 // node_modules/.pnpm/commander@14.0.3/node_modules/commander/esm.mjs
 var import_index = __toESM(require_commander(), 1);
 var {
@@ -29676,7 +29907,7 @@ function computeExitCode(options) {
 init_formatter();
 
 // src/version.ts
-var APP_VERSION = "1.4.1";
+var APP_VERSION = "1.6.0";
 
 // src/output/sarif.ts
 function mapSeverity4(sev) {
@@ -32989,6 +33220,20 @@ program2.command("badge").description("Generate a shields.io badge for your deep
     console.log("");
   }
 });
+program2.command("schema").description("Output JSON Schema for .deep-slop/config.yml (for IDE autocomplete)").option("--output <path>", "Write schema to file instead of stdout").action(async (opts) => {
+  const { generateJsonSchema: generateJsonSchema2 } = await Promise.resolve().then(() => (init_json_schema(), json_schema_exports));
+  const schema = generateJsonSchema2();
+  if (opts.output) {
+    const { writeFileSync: writeFileSync11 } = await import("node:fs");
+    const { resolve: resolvePath } = await import("node:path");
+    const outPath = resolvePath(opts.output);
+    writeFileSync11(outPath, JSON.stringify(schema, null, 2) + "\n");
+    process.stderr.write(`  \u2714 Schema written to ${outPath}
+`);
+  } else {
+    console.log(JSON.stringify(schema, null, 2));
+  }
+});
 program2.command("discover").description("Analyze project: languages, frameworks, package manager, linters, tests, CI").argument("[path]", "project directory", ".").option("--json", "Output as JSON").action(async (path2, opts) => {
   const rootDir = resolve13(path2);
   process.stderr.write(`