slopbrick 0.18.2 → 0.18.3

package/dist/index.js

@@ -35275,10 +35275,10 @@ function parseSvelte(source) {
   const ast = parseScriptContent(script.content, isTypeScriptScript(script.openTag));
   return { ast, source };
 }
-function cacheEnabled() {
+function legacyCacheEnabled() {
   return process.env.SLOP_AUDIT_CACHE === "1" || process.env.SLOP_AUDIT_CACHE === "true";
 }
-function cacheRoot() {
+function legacyCacheRoot() {
   const override = process.env.SLOP_AUDIT_CACHE_ROOT;
   if (override) return override;
   return join10(process.cwd(), ".slopbrick", "cache", "ast");
@@ -35286,11 +35286,11 @@ function cacheRoot() {
 function hashContent(content) {
   return createHash("md5").update(content, "utf-8").digest("hex");
 }
-function cachePath2(content) {
-  return join10(cacheRoot(), `${hashContent(content)}.json`);
+function cachePathWithRoot(content, root) {
+  return join10(root, `${hashContent(content)}.json`);
 }
-async function readCache2(filePath, content) {
-  const path = cachePath2(content);
+async function readCacheWithRoot(filePath, content, root) {
+  const path = cachePathWithRoot(content, root);
   try {
     await access(path);
     const raw = await readFile(path, "utf8");
@@ -35303,8 +35303,8 @@ async function readCache2(filePath, content) {
   }
   return void 0;
 }
-async function writeCache(content, result) {
-  const path = cachePath2(content);
+async function writeCacheWithRoot(content, result, root) {
+  const path = cachePathWithRoot(content, root);
   await mkdir(dirname6(path), { recursive: true });
   await writeFile(path, JSON.stringify(result), "utf8");
 }
@@ -35335,15 +35335,17 @@ function parseSource(source, filePath) {
       return parseWithSwc(source, filePath);
   }
 }
-async function parseFile(filePath) {
+async function parseFile(filePath, opts) {
   const source = await readFile(filePath, "utf-8");
-  if (cacheEnabled()) {
-    const cached = await readCache2(filePath, source);
+  const useCache = opts?.cache?.enabled ?? legacyCacheEnabled();
+  const cacheDir = opts?.cache?.root ?? legacyCacheRoot();
+  if (useCache) {
+    const cached = await readCacheWithRoot(filePath, source, cacheDir);
     if (cached) return cached;
   }
   const result = parseSource(source, filePath);
-  if (cacheEnabled()) {
-    await writeCache(source, result);
+  if (useCache) {
+    await writeCacheWithRoot(source, result, cacheDir);
   }
   return result;
 }
@@ -45773,8 +45775,8 @@ var init_git = __esm({
 import { createHash as createHash5 } from "crypto";
 import { existsSync as existsSync12, readFileSync as readFileSync13, writeFileSync as writeFileSync3, renameSync as renameSync2, mkdirSync as mkdirSync2, unlinkSync } from "fs";
 import { dirname as dirname8, isAbsolute, resolve as resolve8 } from "path";
-function loadCache(cachePath4) {
-  const abs = isAbsolute(cachePath4) ? cachePath4 : resolve8(process.cwd(), cachePath4);
+function loadCache(cachePath3) {
+  const abs = isAbsolute(cachePath3) ? cachePath3 : resolve8(process.cwd(), cachePath3);
   if (!existsSync12(abs)) return void 0;
   try {
     const raw = readFileSync13(abs, "utf-8");
@@ -45785,8 +45787,8 @@ function loadCache(cachePath4) {
     return void 0;
   }
 }
-function saveCache(cachePath4, cache) {
-  const abs = isAbsolute(cachePath4) ? cachePath4 : resolve8(process.cwd(), cachePath4);
+function saveCache(cachePath3, cache) {
+  const abs = isAbsolute(cachePath3) ? cachePath3 : resolve8(process.cwd(), cachePath3);
   mkdirSync2(dirname8(abs), { recursive: true });
   const tmp = abs + ".tmp";
   if (existsSync12(tmp)) {
@@ -47128,6 +47130,13 @@ var init_signal_strength2 = __esm({
 // src/engine/worker.ts
 import { isMainThread, parentPort, workerData } from "worker_threads";
 import { extname as extname6 } from "path";
+import { join as join13 } from "path";
+function buildParserCacheConfig(cwd) {
+  const envVal = process.env.SLOP_AUDIT_CACHE;
+  const enabled = envVal === "1" || envVal === "true";
+  const root = process.env.SLOP_AUDIT_CACHE_ROOT ?? join13(cwd, ".slopbrick", "cache", "ast");
+  return { enabled, root };
+}
 function applyRuleOverrides(issues, rules) {
   const result = [];
   for (const issue of issues) {
@@ -47142,6 +47151,7 @@ function applyRuleOverrides(issues, rules) {
   return result;
 }
 async function scanFile(filePath, config, registry, cwd = process.cwd()) {
+  const cache = buildParserCacheConfig(cwd);
   const ext = extname6(filePath).toLowerCase();
   const UNSUPPORTED_LANGS = /* @__PURE__ */ new Set([
     ".swift",
@@ -47172,7 +47182,7 @@ async function scanFile(filePath, config, registry, cwd = process.cwd()) {
     };
   }
   try {
-    const { ast, source } = await parseFile(filePath);
+    const { ast, source } = await parseFile(filePath, { cache });
     const facts = extractFacts(filePath, ast, source, config.supportsRsc ?? true, config.framework ?? "react", config);
     const activeRegistry = registry ?? new RuleRegistry();
     if (!registry) {
@@ -47281,7 +47291,7 @@ var init_worker = __esm({
 // src/engine/flywheel.ts
 import { createHash as createHash6 } from "crypto";
 import { existsSync as existsSync14, mkdirSync as mkdirSync3, readFileSync as readFileSync14, writeFileSync as writeFileSync4 } from "fs";
-import { join as join13 } from "path";
+import { join as join14 } from "path";
 function severityBump(severity) {
   const order = ["low", "medium", "high"];
   const idx = order.indexOf(severity);
@@ -47382,7 +47392,7 @@ function migrateFlywheelState(state) {
   };
 }
 function loadFlywheelState(cwd) {
-  const path = join13(cwd, FLYWHEEL_DIR, STATE_FILE);
+  const path = join14(cwd, FLYWHEEL_DIR, STATE_FILE);
   if (!existsSync14(path)) {
     return migrateFlywheelState({});
   }
@@ -47394,9 +47404,9 @@ function loadFlywheelState(cwd) {
   }
 }
 function loadResearchMetricsFromDisk(cwd) {
-  const flywheelDir = join13(cwd, FLYWHEEL_DIR);
-  const analysisPath = join13(flywheelDir, "analysis.json");
-  const candidatesPath = join13(flywheelDir, "rule-candidates.json");
+  const flywheelDir = join14(cwd, FLYWHEEL_DIR);
+  const analysisPath = join14(flywheelDir, "analysis.json");
+  const candidatesPath = join14(flywheelDir, "rule-candidates.json");
   const hasAnalysis = existsSync14(analysisPath);
   const hasCandidates = existsSync14(candidatesPath);
   if (!hasAnalysis && !hasCandidates) return void 0;
@@ -47426,9 +47436,9 @@ function loadResearchMetricsFromDisk(cwd) {
   };
 }
 function saveFlywheelState(cwd, state) {
-  const dir = join13(cwd, FLYWHEEL_DIR);
+  const dir = join14(cwd, FLYWHEEL_DIR);
   if (!existsSync14(dir)) mkdirSync3(dir, { recursive: true });
-  writeFileSync4(join13(dir, STATE_FILE), JSON.stringify(state, null, 2));
+  writeFileSync4(join14(dir, STATE_FILE), JSON.stringify(state, null, 2));
 }
 function hashFile(filePath) {
   return createHash6("sha256").update(filePath).digest("hex").slice(0, 16);
@@ -47784,7 +47794,7 @@ var init_metrics = __esm({
 // src/engine/cache.ts
 import { createHash as createHash7 } from "crypto";
 import { existsSync as existsSync15, mkdirSync as mkdirSync4, readFileSync as readFileSync15, writeFileSync as writeFileSync5 } from "fs";
-import { join as join14 } from "path";
+import { join as join15 } from "path";
 function parseVersion(version) {
   const parts = version.split(".").map((part) => parseInt(part, 10));
   return [parts[0] ?? 0, parts[1] ?? 0, parts[2] ?? 0];
@@ -47859,7 +47869,7 @@ function hashConfig(config) {
   return createHash7("sha256").update(JSON.stringify(sanitizeForHash(pickBaselineConfig(config)))).digest("hex");
 }
 function baselinePath(projectPath) {
-  return join14(projectPath, ".slopbrick", "cache", "baseline.json");
+  return join15(projectPath, ".slopbrick", "cache", "baseline.json");
 }
 function isBaselineCache(value) {
   if (!value || typeof value !== "object") return false;
@@ -47902,7 +47912,7 @@ function loadBaseline(projectPath) {
 }
 function saveBaseline(projectPath, cache) {
   const path = baselinePath(projectPath);
-  mkdirSync4(join14(projectPath, ".slopbrick", "cache"), { recursive: true });
+  mkdirSync4(join15(projectPath, ".slopbrick", "cache"), { recursive: true });
   writeFileSync5(path, JSON.stringify(cache, null, 2));
 }
 function tightenBaseline(cache) {
@@ -49816,9 +49826,9 @@ import {
   statSync as statSync6
 } from "fs";
 import { createHash as createHash8 } from "crypto";
-import { dirname as dirname11, join as join16, relative as relative8 } from "path";
+import { dirname as dirname11, join as join17, relative as relative8 } from "path";
 function telemetryPath2(cwd) {
-  return join16(cwd, TELEMETRY_DIR, TELEMETRY_FILE2);
+  return join17(cwd, TELEMETRY_DIR, TELEMETRY_FILE2);
 }
 function hashString(input) {
   return createHash8("sha256").update(input).digest("hex").slice(0, 16);
@@ -49880,21 +49890,21 @@ function rotateTelemetry(cwd) {
   }
   const dir = dirname11(path);
   const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-  renameSync3(path, join16(dir, `scans-${timestamp}.jsonl`));
-  const rotated = readdirSync6(dir).filter(isTelemetryFile).map((name) => ({ name, mtime: statSync6(join16(dir, name)).mtimeMs })).sort((a, b) => a.mtime - b.mtime);
+  renameSync3(path, join17(dir, `scans-${timestamp}.jsonl`));
+  const rotated = readdirSync6(dir).filter(isTelemetryFile).map((name) => ({ name, mtime: statSync6(join17(dir, name)).mtimeMs })).sort((a, b) => a.mtime - b.mtime);
   while (rotated.length > MAX_ROTATED_FILES) {
     const oldest = rotated.shift();
     if (oldest) {
-      rmSync(join16(dir, oldest.name), { force: true });
+      rmSync(join17(dir, oldest.name), { force: true });
     }
   }
 }
 function readTelemetry(cwd) {
-  const dir = join16(cwd, TELEMETRY_DIR);
+  const dir = join17(cwd, TELEMETRY_DIR);
   if (!existsSync16(dir)) {
     return [];
   }
-  const files = readdirSync6(dir).filter(isTelemetryFile).sort().map((name) => join16(dir, name));
+  const files = readdirSync6(dir).filter(isTelemetryFile).sort().map((name) => join17(dir, name));
   const payloads = [];
   for (const file of files) {
     const raw = readFileSync19(file, "utf-8");
@@ -49945,7 +49955,7 @@ var TELEMETRY_DIR, TELEMETRY_FILE2, MAX_TELEMETRY_BYTES, MAX_ROTATED_FILES;
 var init_telemetry = __esm({
   "src/engine/telemetry.ts"() {
     "use strict";
-    TELEMETRY_DIR = join16(".slopbrick", "flywheel");
+    TELEMETRY_DIR = join17(".slopbrick", "flywheel");
     TELEMETRY_FILE2 = "scans.jsonl";
     MAX_TELEMETRY_BYTES = 10 * 1024 * 1024;
     MAX_ROTATED_FILES = 5;
@@ -49960,7 +49970,7 @@ __export(structure_md_exports, {
   writeStructureMarkdown: () => writeStructureMarkdown
 });
 import { existsSync as existsSync17, mkdirSync as mkdirSync6, readFileSync as readFileSync20, writeFileSync as writeFileSync6 } from "fs";
-import { dirname as dirname12, join as join17 } from "path";
+import { dirname as dirname12, join as join18 } from "path";
 function formatDuration(ms) {
   if (!Number.isFinite(ms) || ms < 0) return "unknown";
   if (ms < 1e3) return `${Math.round(ms)}ms`;
@@ -50103,7 +50113,7 @@ function renderStructureMarkdown(inventory, constitution) {
 async function writeStructureMarkdown(workspaceDir, md) {
   await new Promise((resolve42, reject) => {
     try {
-      const path = join17(workspaceDir, STRUCTURE_MD_FILE);
+      const path = join18(workspaceDir, STRUCTURE_MD_FILE);
       mkdirSync6(dirname12(path), { recursive: true });
       writeFileSync6(path, md, "utf-8");
       resolve42();
@@ -50115,7 +50125,7 @@ async function writeStructureMarkdown(workspaceDir, md) {
 async function readStructureMarkdown(workspaceDir) {
   return new Promise((resolve42) => {
     try {
-      const path = join17(workspaceDir, STRUCTURE_MD_FILE);
+      const path = join18(workspaceDir, STRUCTURE_MD_FILE);
       if (!existsSync17(path)) {
         resolve42(null);
         return;
@@ -50131,7 +50141,7 @@ var STRUCTURE_MD_FILE, CATEGORY_LABELS, CATEGORY_ORDER, DECLARED_FIELDS;
 var init_structure_md = __esm({
   "src/engine/structure-md.ts"() {
     "use strict";
-    STRUCTURE_MD_FILE = join17(".slopbrick", "structure.md");
+    STRUCTURE_MD_FILE = join18(".slopbrick", "structure.md");
     CATEGORY_LABELS = {
       stateManagement: "State management",
       dataFetching: "Data fetching",
@@ -50173,7 +50183,7 @@ var init_structure_md = __esm({
 
 // src/cli/report/persistRun.ts
 import { existsSync as existsSync18, writeFileSync as writeFileSync7, mkdirSync as mkdirSync7 } from "fs";
-import { join as join18, relative as relative9 } from "path";
+import { join as join19, relative as relative9 } from "path";
 async function persistRun(input) {
   const {
     cwd,
@@ -50207,8 +50217,8 @@ async function persistRun(input) {
     );
   }
   if (options.incremental) {
-    const cachePath4 = options.cachePath ?? ".slopbrick-cache.json";
-    const existing = loadCache(cachePath4) ?? emptyCache();
+    const cachePath3 = options.cachePath ?? ".slopbrick-cache.json";
+    const existing = loadCache(cachePath3) ?? emptyCache();
     const next = { ...existing, generatedAt: (/* @__PURE__ */ new Date()).toISOString() };
     for (const result of results) {
       try {
@@ -50222,7 +50232,7 @@ async function persistRun(input) {
       } catch {
       }
     }
-    saveCache(cachePath4, next);
+    saveCache(cachePath3, next);
     if (incrementalSummary && !options.quiet) {
       logger.info(
         `Incremental: re-scanned ${incrementalSummary.rescanned}, skipped ${incrementalSummary.skipped} (unchanged).`
@@ -50254,10 +50264,10 @@ async function persistRun(input) {
       report.research = state.research;
     }
     if (flywheelOutput.suggestions.length > 0) {
-      const suggestionsDir = join18(cwd, ".slopbrick", "flywheel");
+      const suggestionsDir = join19(cwd, ".slopbrick", "flywheel");
       if (!existsSync18(suggestionsDir)) mkdirSync7(suggestionsDir, { recursive: true });
       writeFileSync7(
-        join18(suggestionsDir, "rule-suggestions.json"),
+        join19(suggestionsDir, "rule-suggestions.json"),
         JSON.stringify(flywheelOutput.suggestions, null, 2)
       );
     }
@@ -52467,8 +52477,8 @@ async function runScan(options, explicitPaths) {
   }
   let incrementalSummary;
   if (options.incremental) {
-    const cachePath4 = options.cachePath ?? ".slopbrick-cache.json";
-    const existing = loadCache(cachePath4);
+    const cachePath3 = options.cachePath ?? ".slopbrick-cache.json";
+    const existing = loadCache(cachePath3);
     const { toScan, unchanged } = partitionByCache(files, existing);
     files = toScan;
     incrementalSummary = { skipped: unchanged.length, rescanned: toScan.length };
@@ -53273,12 +53283,12 @@ init_git();
 init_cache();
 init_logger();
 import { writeFileSync as writeFileSync11, mkdirSync as mkdirSync9, rmSync as rmSync2 } from "fs";
-import { join as join20, dirname as dirname14 } from "path";
+import { join as join21, dirname as dirname14 } from "path";
 import { createInterface } from "readline";
 
 // src/rules/registry-loader.ts
 import { existsSync as existsSync21, mkdirSync as mkdirSync8, readFileSync as readFileSync24, writeFileSync as writeFileSync10 } from "fs";
-import { dirname as dirname13, join as join19 } from "path";
+import { dirname as dirname13, join as join20 } from "path";
 
 // src/data/shadcn-registry.json
 var shadcn_registry_default = {
@@ -53411,11 +53421,11 @@ var shadcn_registry_default = {
 // src/rules/registry-loader.ts
 var REGISTRY_URL = "https://ui.shadcn.com/registry.json";
 var BUNDLED_REGISTRY_VERSION = shadcn_registry_default.version;
-function cachePath3(cwd) {
-  return join19(cwd, ".slopbrick", "cache", "registry-snapshot.json");
+function cachePath2(cwd) {
+  return join20(cwd, ".slopbrick", "cache", "registry-snapshot.json");
 }
 function ensureCacheDir(cwd) {
-  const dir = dirname13(cachePath3(cwd));
+  const dir = dirname13(cachePath2(cwd));
   if (!existsSync21(dir)) {
     mkdirSync8(dir, { recursive: true });
   }
@@ -53428,7 +53438,7 @@ function isValidSnapshot(value) {
   return true;
 }
 function isRegistryFresh(cwd) {
-  const cached = cachePath3(cwd);
+  const cached = cachePath2(cwd);
   if (!existsSync21(cached)) return false;
   try {
     const parsed = JSON.parse(readFileSync24(cached, "utf8"));
@@ -53465,7 +53475,7 @@ async function refreshRegistrySnapshot(cwd, url = REGISTRY_URL, timeoutMs = 5e3)
     };
   }
   ensureCacheDir(cwd);
-  writeFileSync10(cachePath3(cwd), JSON.stringify(fetched, null, 2));
+  writeFileSync10(cachePath2(cwd), JSON.stringify(fetched, null, 2));
   const fresh = fetched.version === BUNDLED_REGISTRY_VERSION;
   return {
     ok: true,
@@ -53475,7 +53485,7 @@ async function refreshRegistrySnapshot(cwd, url = REGISTRY_URL, timeoutMs = 5e3)
 }
 function copyBundledSnapshotToCache(cwd) {
   ensureCacheDir(cwd);
-  writeFileSync10(cachePath3(cwd), JSON.stringify(shadcn_registry_default, null, 2));
+  writeFileSync10(cachePath2(cwd), JSON.stringify(shadcn_registry_default, null, 2));
 }
 
 // src/cli/init.ts
@@ -53664,7 +53674,7 @@ async function runDoctor(cwd) {
   }
   try {
     const { parseFile: tryParse } = await Promise.resolve().then(() => (init_dist2(), dist_exports2));
-    const testFile = join20(cwd, ".slopbrick", ".doctor-test.ts");
+    const testFile = join21(cwd, ".slopbrick", ".doctor-test.ts");
     mkdirSync9(dirname14(testFile), { recursive: true });
     writeFileSync11(testFile, "export const x = 1;\n");
     await tryParse(testFile);
@@ -53997,7 +54007,7 @@ import {
   readFileSync as readFileSync26,
   writeFileSync as writeFileSync12
 } from "fs";
-import { dirname as dirname15, join as join21 } from "path";
+import { dirname as dirname15, join as join23 } from "path";
 var BEGIN_SENTINEL = "# slopbrick-hook-begin";
 var END_SENTINEL = "# slopbrick-hook-end";
 var SENTINEL_BLOCK = `${BEGIN_SENTINEL}
@@ -54005,11 +54015,11 @@ npx slopbrick --staged
 ${END_SENTINEL}
 `;
 function hookPath(gitRoot) {
-  const huskyDir = join21(gitRoot, ".husky");
+  const huskyDir = join23(gitRoot, ".husky");
   if (existsSync23(huskyDir)) {
-    return join21(huskyDir, "pre-commit");
+    return join23(huskyDir, "pre-commit");
   }
-  return join21(gitRoot, ".git", "hooks", "pre-commit");
+  return join23(gitRoot, ".git", "hooks", "pre-commit");
 }
 function readHookContent(path) {
   return readFileSync26(path, "utf8");
@@ -54427,41 +54437,41 @@ import { resolve as resolve22 } from "path";
 // src/cli/migrate.ts
 init_logger();
 import { existsSync as existsSync24, readFileSync as readFileSync28, renameSync as renameSync4, writeFileSync as writeFileSync13 } from "fs";
-import { join as join23 } from "path";
+import { join as join24 } from "path";
 function planMigration(workspaceDir) {
   const moves = [];
   const rewrites = [];
   const gitignoreEdits = [];
-  const oldDir = join23(workspaceDir, ".slop-audit");
-  const newDir = join23(workspaceDir, ".slopbrick");
+  const oldDir = join24(workspaceDir, ".slop-audit");
+  const newDir = join24(workspaceDir, ".slopbrick");
   if (existsSync24(oldDir)) {
     moves.push({ from: oldDir, to: newDir, kind: "dir" });
     rewrites.push({
-      path: join23(newDir, "inventory.json"),
+      path: join24(newDir, "inventory.json"),
       field: "version",
       from: '"1"',
       to: '"2"'
     });
     rewrites.push({
-      path: join23(newDir, "constitution.json"),
+      path: join24(newDir, "constitution.json"),
       field: "version",
       from: '"1"',
       to: '"2"'
     });
   }
-  const oldCache = join23(workspaceDir, ".slop-audit-cache.json");
-  const newCache = join23(workspaceDir, ".slopbrick-cache.json");
+  const oldCache = join24(workspaceDir, ".slop-audit-cache.json");
+  const newCache = join24(workspaceDir, ".slopbrick-cache.json");
   if (existsSync24(oldCache)) {
     moves.push({ from: oldCache, to: newCache, kind: "file" });
   }
   for (const ext of ["mjs", "cjs", "js"]) {
-    const oldCfg = join23(workspaceDir, `slop-audit.config.${ext}`);
-    const newCfg = join23(workspaceDir, `slopbrick.config.${ext}`);
+    const oldCfg = join24(workspaceDir, `slop-audit.config.${ext}`);
+    const newCfg = join24(workspaceDir, `slopbrick.config.${ext}`);
     if (existsSync24(oldCfg)) {
       moves.push({ from: oldCfg, to: newCfg, kind: "config" });
     }
   }
-  const gi = join23(workspaceDir, ".gitignore");
+  const gi = join24(workspaceDir, ".gitignore");
   if (existsSync24(gi)) {
     const content = readFileSync28(gi, "utf-8");
     if (content.includes(".slop-audit/")) {
@@ -54482,7 +54492,7 @@ function planMigration(workspaceDir) {
   return { moves, rewrites, gitignoreEdits };
 }
 function isAlreadyMigrated(workspaceDir) {
-  return existsSync24(join23(workspaceDir, ".slopbrick")) && !existsSync24(join23(workspaceDir, ".slop-audit"));
+  return existsSync24(join24(workspaceDir, ".slopbrick")) && !existsSync24(join24(workspaceDir, ".slop-audit"));
 }
 function applyMigration(plan, options = {}) {
   if (options.dryRun) return;
@@ -54513,8 +54523,8 @@ function runMigrate(options) {
     };
   }
   const alreadyMigrated = isAlreadyMigrated(workspace);
-  const newDir = join23(workspace, ".slopbrick");
-  const oldDir = join23(workspace, ".slop-audit");
+  const newDir = join24(workspace, ".slopbrick");
+  const oldDir = join24(workspace, ".slop-audit");
   if (existsSync24(newDir) && existsSync24(oldDir) && !force) {
     return {
       ok: false,
@@ -54985,7 +54995,7 @@ function createProvider(config) {
 
 // src/research/generator.ts
 import { mkdirSync as mkdirSync11, writeFileSync as writeFileSync14 } from "fs";
-import { join as join24 } from "path";
+import { join as join25 } from "path";
 
 // src/research/prompts.ts
 var DEFAULT_PROMPT_TEMPLATES = [
@@ -55048,13 +55058,13 @@ async function generateSamples(options) {
   }
   const samples = [];
   const ext = extForFramework(framework);
-  const dir = join24(outputDir, framework, componentType);
+  const dir = join25(outputDir, framework, componentType);
   mkdirSync11(dir, { recursive: true });
   for (let i = 1; i <= count; i += 1) {
     const raw = await provider.generateSample(renderPrompt(template), { temperature });
     const code = extractCodeFromMarkdown(raw);
     const fileName = `sample-${i}${ext}`;
-    const filePath = join24(dir, fileName);
+    const filePath = join25(dir, fileName);
     writeFileSync14(filePath, code, "utf8");
     const sample = {
       filePath,
@@ -55066,7 +55076,7 @@ async function generateSamples(options) {
     };
     samples.push(sample);
   }
-  const metadataPath = join24(dir, "metadata.json");
+  const metadataPath = join25(dir, "metadata.json");
   writeFileSync14(metadataPath, JSON.stringify(samples, null, 2), "utf8");
   return samples;
 }
@@ -55274,20 +55284,20 @@ function slugify(value) {
 // src/research/calibrator.ts
 import { execFileSync as execFileSync2 } from "child_process";
 import { existsSync as existsSync26, readFileSync as readFileSync29, writeFileSync as writeFileSync15, mkdirSync as mkdirSync12 } from "fs";
-import { join as join26, resolve as resolve24 } from "path";
+import { join as join27, resolve as resolve24 } from "path";
 
 // src/corpus-paths.ts
-import { join as join25 } from "path";
+import { join as join26 } from "path";
 var CORPUS_ROOT = process.env["SLOPBRICK_CORPUS_DIR"] ?? "/Users/cheng/corpus-expansion";
-var POSITIVE_DIR = join25(CORPUS_ROOT, "positive");
-var NEGATIVE_DIR = join25(CORPUS_ROOT, "negative");
-var FILELISTS_DIR = join25(CORPUS_ROOT, "filelists");
+var POSITIVE_DIR = join26(CORPUS_ROOT, "positive");
+var NEGATIVE_DIR = join26(CORPUS_ROOT, "negative");
+var FILELISTS_DIR = join26(CORPUS_ROOT, "filelists");
 
 // src/research/calibrator.ts
 var DEFAULT_POSITIVE = POSITIVE_DIR;
 var DEFAULT_NEGATIVE = NEGATIVE_DIR;
 function buildFileList(dir, extensions) {
-  const tmpList = join26("/tmp", `cal-build-${Date.now()}-${Math.random().toString(36).slice(2)}.txt`);
+  const tmpList = join27("/tmp", `cal-build-${Date.now()}-${Math.random().toString(36).slice(2)}.txt`);
   const expr = extensions.map((e) => `-name '*.${e}'`).join(" -o ");
   execFileSync2("bash", ["-c", `find ${dir} -maxdepth 8 -type f \\( ${expr} \\) -print0 | xargs -0 realpath > ${tmpList}`]);
   const out = readFileSync29(tmpList, "utf8");
@@ -55300,13 +55310,13 @@ function runScan2(fileListPath) {
   const ruleFires = /* @__PURE__ */ new Map();
   const uniqueFilesPerRule = /* @__PURE__ */ new Map();
   let fileCount = 0;
-  const tmpOut = join26("/tmp", `calibrate-${Date.now()}-${Math.random().toString(36).slice(2)}.json`);
+  const tmpOut = join27("/tmp", `calibrate-${Date.now()}-${Math.random().toString(36).slice(2)}.json`);
   for (let i = 0; i < files.length; i += CHUNK) {
     const chunk = files.slice(i, i + CHUNK);
     try {
       execFileSync2(
         "node",
-        [join26(process.cwd(), "bin", "slopbrick.js"), "scan", ...chunk, "--json", tmpOut, "--no-telemetry", "--quiet"],
+        [join27(process.cwd(), "bin", "slopbrick.js"), "scan", ...chunk, "--json", tmpOut, "--no-telemetry", "--quiet"],
         { encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] }
       );
     } catch {
@@ -55346,8 +55356,8 @@ async function calibrate(cwd, options = {}) {
   const negativeFiles = buildFileList(negativeDir, ["tsx", "ts"]);
   const posSample = options.positiveLimit ? positiveFiles.slice(0, options.positiveLimit) : positiveFiles;
   const negSample = options.negativeLimit ? negativeFiles.slice(0, options.negativeLimit) : negativeFiles;
-  const posListPath = join26("/tmp", `cal-pos-${Date.now()}.txt`);
-  const negListPath = join26("/tmp", `cal-neg-${Date.now()}.txt`);
+  const posListPath = join27("/tmp", `cal-pos-${Date.now()}.txt`);
+  const negListPath = join27("/tmp", `cal-neg-${Date.now()}.txt`);
   writeFileSync15(posListPath, posSample.join("\n"));
   writeFileSync15(negListPath, negSample.join("\n"));
   const builtins = await Promise.resolve().then(() => (init_builtins(), builtins_exports));
@@ -57250,7 +57260,7 @@ function registerResearch(program) {
 init_logger();
 init_builtins();
 import { existsSync as existsSync28, mkdirSync as mkdirSync15, readFileSync as readFileSync35, writeFileSync as writeFileSync18 } from "fs";
-import { dirname as dirname19, join as join28, resolve as resolve39 } from "path";
+import { dirname as dirname19, join as join29, resolve as resolve39 } from "path";
 init_scan();
 init_config();
 init_threshold();
@@ -57258,7 +57268,7 @@ init_git();
 init_cache();
 
 // src/snippet/targets.ts
-import { join as join27 } from "path";
+import { join as join28 } from "path";
 
 // src/snippet/render.ts
 function aiSpecificRules(rules) {
@@ -57489,7 +57499,7 @@ var SNIPPET_TARGETS = [
   }
 ];
 function resolveTargetPath(target) {
-  return target.isFolder ? join27(target.path, target.filename) : target.path;
+  return target.isFolder ? join28(target.path, target.filename) : target.path;
 }
 function renderMatrix() {
   const lines = [];
@@ -57512,7 +57522,7 @@ function registerInit(program) {
       process.exit(0);
     }
     const cwd = resolve39(options.workspace ?? process.cwd());
-    const configPath = join28(cwd, "slopbrick.config.mjs");
+    const configPath = join29(cwd, "slopbrick.config.mjs");
     const detected = detectStack(cwd);
     const fallbackConfig = { ...DEFAULT_CONFIG, ...detected };
     const proposed = serializeConfig(fallbackConfig);
@@ -57568,7 +57578,7 @@ function registerInit(program) {
       return Boolean(opts[t.flag]);
     });
     for (const target of targetsToWrite) {
-      const snippetPath = join28(cwd, resolveTargetPath(target));
+      const snippetPath = join29(cwd, resolveTargetPath(target));
       mkdirSync15(dirname19(snippetPath), { recursive: true });
       const generated = target.generator(builtinRules);
       if (!target.isFolder && existsSync28(snippetPath)) {
@@ -57615,7 +57625,7 @@ import { dirname as dirname20, resolve as resolve40 } from "path";
 
 // src/report/flywheel.ts
 import { existsSync as existsSync29, readFileSync as readFileSync36 } from "fs";
-import { join as join29 } from "path";
+import { join as join30 } from "path";
 function average(values) {
   if (values.length === 0) return 0;
   return values.reduce((a, b) => a + b, 0) / values.length;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "slopbrick",
-  "version": "0.18.2",
+  "version": "0.18.3",
   "description": "Discovered, modeled, and governed repository structure. SlopBrick scans source code, classifies it against 95 rules in 15 categories, computes 4 scores (aiQuality, engineeringHygiene, security, repositoryHealth), and persists the structure for AI agents and CI.",
   "type": "module",
   "bin": {