opencode-anti-slop 0.1.1 → 0.1.4

package/scripts/anti-slop/generate-component-index.mjs

@@ -1,133 +1,162 @@
-#!/usr/bin/env node
-/**
- * generate-component-index.mjs
- *
- * Scans a source tree and (re)generates docs/COMPONENT_INDEX.md — the
- * inventory that the `reuse-before-create` skill treats as the source of
- * truth for existing layouts, components, hooks, and utilities.
- *
- * Zero dependencies (plain Node >= 18, ESM). Classification is heuristic
- * (paths + export names + file extension); it is a discovery aid, not a parser.
- *
- * Usage:
- *   node scripts/anti-slop/generate-component-index.mjs [--src src] [--out docs/COMPONENT_INDEX.md] [--root .]
- *
- * A "## Manual Notes" section at the end of an existing index is preserved.
- */
-
-import {
-  readdirSync,
-  readFileSync,
-  writeFileSync,
-  existsSync,
-  mkdirSync,
-} from 'node:fs';
-import path from 'node:path';
-import { walk, extractExports } from './lib.mjs';
-
-// --- args -------------------------------------------------------------------
-function parseArgs(argv) {
-  const args = { src: 'src', out: 'docs/COMPONENT_INDEX.md', root: '.' };
-  for (let i = 2; i < argv.length; i++) {
-    const a = argv[i];
-    if (a === '--src') args.src = argv[++i];
-    else if (a === '--out') args.out = argv[++i];
-    else if (a === '--root') args.root = argv[++i];
-    else if (a === '-h' || a === '--help') {
-      console.log('Usage: node generate-component-index.mjs [--src src] [--out docs/COMPONENT_INDEX.md] [--root .]');
-      process.exit(0);
-    } else {
-      console.error(`Unknown argument: ${a}`);
-      process.exit(1);
-    }
-  }
-  return args;
-}
-
-const args = parseArgs(process.argv);
-
-const SRC_DIR = path.resolve(args.root, args.src);
-const OUT_FILE = path.resolve(args.root, args.out);
-
-if (!existsSync(SRC_DIR)) {
-  console.error(`Source directory not found: ${SRC_DIR}`);
-  process.exit(1);
-}
-
-// --- classification ---------------------------------------------------------
-function classify(relPath, exports) {
-  const base = path.basename(relPath);
-  const dir = path.dirname(relPath).toLowerCase();
-  const baseName = path.basename(base, path.extname(base));
-  const isTsx = /\.(tsx|jsx)$/.test(base);
-
-  const hasJsxLike = exports.length > 0 && isTsx;
-
-  if (/^use[A-Z0-9]/.test(baseName) || /(^|\/)hooks?\//.test(dir)) return 'Hook';
-  if (/(^|\/)layouts?(\/|$)/.test(dir) || /layout/i.test(baseName)) return 'Layout';
-  if (hasJsxLike && exports.some((e) => /^[A-Z]/.test(e.name))) return 'Component';
-  if (/(^|\/)(services?|adapters?)(\/|$)/.test(dir)) return 'Service';
-  if (/(^|\/)(utils?|lib|helpers?)(\/|$)/.test(dir)) return 'Util';
-  if (exports.some((e) => e.kind === 'type')) return 'Types';
-  return 'Module';
-}
-
-// --- build ------------------------------------------------------------------
-const files = walk(SRC_DIR, SRC_DIR);
-const index = new Map(); // kind -> [{rel, name, kind, desc, lines}]
-let missingDocs = 0;
-
-for (const file of files) {
-  const source = readFileSync(file.full, 'utf8');
-  const exports = extractExports(source);
-  if (exports.length === 0) continue;
-  const kind = classify(file.rel, exports);
-  const lines = source.split('\n').length;
-  const list = index.get(kind) ?? [];
-  for (const exp of exports) {
-    if (!exp.desc) missingDocs++;
-    list.push({ rel: file.rel, name: exp.name, kind: exp.kind, desc: exp.desc, lines });
-  }
-  index.set(kind, list);
-}
-
-// --- preserve manual notes --------------------------------------------------
-let manualNotes = '';
-if (existsSync(OUT_FILE)) {
-  const existing = readFileSync(OUT_FILE, 'utf8');
-  const marker = existing.indexOf('## Manual Notes');
-  if (marker !== -1) manualNotes = existing.slice(marker);
-}
-
-// --- render -----------------------------------------------------------------
-const KIND_ORDER = ['Layout', 'Component', 'Hook', 'Service', 'Util', 'Types', 'Module'];
-const totalExports = KIND_ORDER.reduce((n, k) => n + (index.get(k)?.length ?? 0), 0);
-
-let md = `# Component Index\n\n`;
-md += `<!-- generated: run \`node scripts/anti-slop/generate-component-index.mjs\` to regenerate -->\n\n`;
-md += `Inventory of shared layouts, components, hooks, services, and utilities under \`${args.src}/\`. `;
-md += `Generated ${new Date().toISOString().slice(0, 10)}, ${files.length} files, ${totalExports} exports.\n\n`;
-md += `> Rule of use: before creating any new component, hook, or utility, check this file first (see the \`reuse-before-create\` skill). When you add a shared abstraction, rerun the generator and fill in the "When to use" column.\n\n`;
-
-for (const kind of KIND_ORDER) {
-  const list = index.get(kind);
-  if (!list || list.length === 0) continue;
-  md += `## ${kind}s (${list.length})\n\n`;
-  md += `| File | Export | When to use |\n|---|---|---|\n`;
-  for (const e of list) {
-    const doc = e.desc ? e.desc.replace(/\|/g, '\\|') : '';
-    md += `| \`${e.rel}\` | \`${e.name}\`${e.kind === 'type' ? ' *(type)*' : ''} | ${doc || '-'} |\n`;
-  }
-  md += `\n`;
-}
-
-md += manualNotes ? `${manualNotes}\n` : `## Manual Notes\n\n(Add notes here; they are preserved when the index is regenerated.)\n`;
-
-mkdirSync(path.dirname(OUT_FILE), { recursive: true });
-writeFileSync(OUT_FILE, md);
-
-console.log(`Wrote ${OUT_FILE}`);
-console.log(`  ${files.length} source files, ${totalExports} exports across ${KIND_ORDER.filter((k) => index.has(k)).length} categories.`);
-if (missingDocs > 0) {
-  console.log(`  [doc] ${missingDocs} export(s) have no JSDoc description. Shared components/hooks/utils must carry a one-line "/** When to use ... */" above the export.`);
-}
+#!/usr/bin/env node
+/**
+ * generate-component-index.mjs
+ *
+ * Scans a source tree and (re)generates docs/COMPONENT_INDEX.md — the
+ * inventory that the `reuse-before-create` skill treats as the source of
+ * truth for existing layouts, components, hooks, and utilities.
+ *
+ * Zero dependencies (plain Node >= 18, ESM). Classification is heuristic
+ * (paths + export names + file extension); it is a discovery aid, not a parser.
+ *
+ * Usage:
+ *   node scripts/anti-slop/generate-component-index.mjs [--src src] [--out docs/COMPONENT_INDEX.md] [--root .]
+ *
+ * A "## Manual Notes" section at the end of an existing index is preserved.
+ */
+
+import {
+  readFileSync,
+  writeFileSync,
+  existsSync,
+  mkdirSync,
+} from 'node:fs';
+import path from 'node:path';
+import { walk, extractExports } from './lib.mjs';
+import { loadConfig, applyIgnorePaths } from './cli.mjs';
+
+// --- args -------------------------------------------------------------------
+function parseArgs(argv) {
+  const args = { src: 'src', out: 'docs/COMPONENT_INDEX.md', root: '.', check: false };
+  for (let i = 2; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === '--src') args.src = argv[++i];
+    else if (a === '--out') args.out = argv[++i];
+    else if (a === '--root') args.root = argv[++i];
+    else if (a === '--check') args.check = true;
+    else if (a === '-h' || a === '--help') {
+      console.log('Usage: node generate-component-index.mjs [--src src] [--out docs/COMPONENT_INDEX.md] [--root .] [--check]');
+      console.log('  --check  compare against the file on disk; exit 1 when stale (CI mode, writes nothing)');
+      process.exit(0);
+    } else {
+      console.error(`Unknown argument: ${a}`);
+      process.exit(1);
+    }
+  }
+  return args;
+}
+
+const args = parseArgs(process.argv);
+
+const SRC_DIR = path.resolve(args.root, args.src);
+const OUT_FILE = path.resolve(args.root, args.out);
+
+if (!existsSync(SRC_DIR)) {
+  console.error(`Source directory not found: ${SRC_DIR}`);
+  process.exit(1);
+}
+
+// --- classification ---------------------------------------------------------
+function classify(relPath, exports) {
+  const base = path.basename(relPath);
+  const dir = path.dirname(relPath).toLowerCase();
+  const baseName = path.basename(base, path.extname(base));
+  const isTsx = /\.(tsx|jsx)$/.test(base);
+
+  const hasJsxLike = exports.length > 0 && isTsx;
+
+  if (/^use[A-Z0-9]/.test(baseName) || /(^|\/)hooks?\//.test(dir)) return 'Hook';
+  if (/(^|\/)layouts?(\/|$)/.test(dir) || /layout/i.test(baseName)) return 'Layout';
+  if (hasJsxLike && exports.some((e) => /^[A-Z]/.test(e.name))) return 'Component';
+  if (/(^|\/)(services?|adapters?)(\/|$)/.test(dir)) return 'Service';
+  if (/(^|\/)(utils?|lib|helpers?)(\/|$)/.test(dir)) return 'Util';
+  if (exports.some((e) => e.kind === 'type')) return 'Types';
+  return 'Module';
+}
+
+// --- build ------------------------------------------------------------------
+const files = walk(SRC_DIR, SRC_DIR);
+// The generator and the docs gate must agree on what exists: docs.ignorePaths
+// excludes framework-owned or declarative files from both the listing and the
+// undocumented count, so the two never report different totals.
+const ignorePaths = Array.isArray(loadConfig().docs?.ignorePaths)
+  ? loadConfig().docs.ignorePaths
+  : [];
+const filtered = applyIgnorePaths(files, ignorePaths, { label: 'docs.ignorePaths', src: args.src });
+const index = new Map(); // kind -> [{rel, name, kind, desc, lines}]
+let missingDocs = 0;
+
+for (const file of filtered) {
+  const source = readFileSync(file.full, 'utf8');
+  const exports = extractExports(source);
+  if (exports.length === 0) continue;
+  const kind = classify(file.rel, exports);
+  const lines = source.split('\n').length;
+  const list = index.get(kind) ?? [];
+  for (const exp of exports) {
+    // The docs gate exempts default exports (route entry points etc.); the
+    // generator's count must agree, or the two report different totals.
+    if (!exp.desc && exp.kind !== 'default') missingDocs++;
+    list.push({ rel: file.rel, name: exp.name, kind: exp.kind, desc: exp.desc, lines });
+  }
+  index.set(kind, list);
+}
+
+// --- preserve manual notes --------------------------------------------------
+let manualNotes = '';
+if (existsSync(OUT_FILE)) {
+  const existing = readFileSync(OUT_FILE, 'utf8');
+  const marker = existing.indexOf('## Manual Notes');
+  if (marker !== -1) manualNotes = existing.slice(marker);
+}
+
+// --- render -----------------------------------------------------------------
+const KIND_ORDER = ['Layout', 'Component', 'Hook', 'Service', 'Util', 'Types', 'Module'];
+// Categories already plural keep their name; everything else takes a plain 's'.
+const PLURAL = { Types: 'Types' };
+const heading = (kind) => PLURAL[kind] ?? `${kind}s`;
+const totalExports = KIND_ORDER.reduce((n, k) => n + (index.get(k)?.length ?? 0), 0);
+
+let md = `# Component Index\n\n`;
+md += `<!-- generated: run \`node scripts/anti-slop/generate-component-index.mjs\` to regenerate -->\n\n`;
+md += `Inventory of shared layouts, components, hooks, services, and utilities under \`${args.src}/\`. `;
+md += `${filtered.length} files, ${totalExports} exports.\n\n`;
+md += `> Rule of use: before creating any new component, hook, or utility, check this file first (see the \`reuse-before-create\` skill). When you add a shared abstraction, rerun the generator and fill in the "When to use" column.\n\n`;
+
+for (const kind of KIND_ORDER) {
+  const list = index.get(kind);
+  if (!list || list.length === 0) continue;
+  md += `## ${heading(kind)} (${list.length})\n\n`;
+  md += `| File | Export | When to use |\n|---|---|---|\n`;
+  for (const e of list) {
+    const doc = e.desc ? e.desc.replace(/\|/g, '\\|') : '';
+    md += `| \`${e.rel}\` | \`${e.name}\`${e.kind === 'type' ? ' *(type)*' : ''} | ${doc || '-'} |\n`;
+  }
+  md += `\n`;
+}
+
+md += manualNotes ? `${manualNotes.trimEnd()}\n` : `## Manual Notes\n\n(Add notes here; they are preserved when the index is regenerated.)\n`;
+md = md.replace(/\n+$/, '\n');
+
+if (args.check) {
+  if (!existsSync(OUT_FILE)) {
+    console.error(`[x] Index check FAILED: ${OUT_FILE} does not exist. Run the generator without --check and commit the result.`);
+    process.exit(1);
+  }
+  const onDisk = readFileSync(OUT_FILE, 'utf8').replace(/\n+$/, '\n');
+  if (onDisk === md) {
+    console.log(`[ok] Component index is up to date (${OUT_FILE}).`);
+    process.exit(0);
+  }
+  console.error(`[x] Index check FAILED: ${OUT_FILE} is stale. Run \`node scripts/anti-slop/generate-component-index.mjs\` and commit the result.`);
+  process.exit(1);
+}
+
+mkdirSync(path.dirname(OUT_FILE), { recursive: true });
+writeFileSync(OUT_FILE, md);
+
+console.log(`Wrote ${OUT_FILE}`);
+console.log(`  ${filtered.length} source files, ${totalExports} exports across ${KIND_ORDER.filter((k) => index.has(k)).length} categories.`);
+if (missingDocs > 0) {
+  console.log(`  [doc] ${missingDocs} export(s) have no JSDoc description. Shared components/hooks/utils must carry a one-line "/** When to use ... */" above the export.`);
+}

package/scripts/anti-slop/install-hooks.mjs

@@ -12,7 +12,7 @@
  * Existing hooks are never overwritten without --force.
  */
 
-import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs';
+import { existsSync, writeFileSync, mkdirSync } from 'node:fs';
 import path from 'node:path';
 
 const force = process.argv.includes('--force');
@@ -52,8 +52,8 @@ node scripts/anti-slop/check-docs.mjs $staged || exit 1
 echo "[anti-slop] import-boundary report (non-blocking; cycles are tree-wide)..."
 node scripts/anti-slop/check-imports.mjs --report-only || true
 
-echo "[anti-slop] duplicate-code report (non-blocking):"
-node scripts/anti-slop/check-duplicates.mjs --min-tokens 20 --threshold 0 || true
+echo "[anti-slop] duplicate-code report (non-blocking; sensitivity from anti-slop.config.json):"
+node scripts/anti-slop/check-duplicates.mjs --threshold 0 --summary || true
 
 exit 0
 `;
@@ -66,10 +66,8 @@ node scripts/anti-slop/check-duplicates.mjs || exit 1
 echo "[anti-slop] import-boundary gate..."
 node scripts/anti-slop/check-imports.mjs || exit 1
 
-echo "[anti-slop] project checks (--if-present)..."
-npm run lint --if-present || exit 1
-npm run typecheck --if-present || exit 1
-npm test --if-present || exit 1
+echo "[anti-slop] project checks (lint/typecheck/test; skips are printed, not hidden)..."
+node scripts/anti-slop/run-project-checks.mjs || exit 1
 
 exit 0
 `;

package/scripts/anti-slop/lib.mjs

@@ -44,11 +44,11 @@ export function walk(dir, base) {
 }
 
 /**
- * Remove comments and string contents so brace/regex analysis is reliable.
- * Newlines (including those inside strings) are preserved, so line numbers
- * computed on the output match the original source.
+ * Comment/string handling shared by both strippers below. Newlines (including
+ * those inside strings) are preserved, so line numbers computed on the output
+ * match the original source.
  */
-export function stripNoise(src) {
+function stripSource(src, blankStrings) {
   let out = '';
   let i = 0;
   const n = src.length;
@@ -67,13 +67,28 @@ export function stripNoise(src) {
     } else if (c === '"' || c === "'" || c === '`') {
       const quote = c;
       i++;
-      while (i < n && src[i] !== quote) {
-        if (src[i] === '\\') i++;
-        if (src[i] === '\n') out += '\n';
-        i++;
+      if (blankStrings) {
+        while (i < n && src[i] !== quote) {
+          if (src[i] === '\\') i++;
+          if (src[i] === '\n') out += '\n';
+          i++;
+        }
+        i++; // closing quote
+        out += '""';
+      } else {
+        out += quote;
+        while (i < n && src[i] !== quote) {
+          if (src[i] === '\\' && i + 1 < n) {
+            out += src[i] + src[i + 1];
+            i += 2;
+            continue;
+          }
+          out += src[i];
+          i++;
+        }
+        out += quote;
+        i++; // closing quote
       }
-      i++; // closing quote
-      out += '""';
     } else {
       out += c;
       i++;
@@ -83,32 +98,21 @@ export function stripNoise(src) {
 }
 
 /**
- * Remove comments while KEEPING string contents, preserving newlines. Used
- * where the text inside strings matters (import specifier parsing) but
- * comment noise must not create false edges.
+ * Remove comments and blank string contents so brace/regex analysis is
+ * reliable. Newlines are preserved, so line numbers computed on the output
+ * match the original source.
+ */
+export function stripNoise(src) {
+  return stripSource(src, true);
+}
+
+/**
+ * Remove comments while KEEPING string contents verbatim — used where the
+ * text inside strings matters (import specifier parsing) but comment noise
+ * must not create false edges.
  */
 export function stripComments(src) {
-  let out = '';
-  let i = 0;
-  const n = src.length;
-  while (i < n) {
-    const c = src[i];
-    const next = src[i + 1];
-    if (c === '/' && next === '/') {
-      while (i < n && src[i] !== '\n') i++;
-    } else if (c === '/' && next === '*') {
-      i += 2;
-      while (i < n && !(src[i] === '*' && src[i + 1] === '/')) {
-        if (src[i] === '\n') out += '\n';
-        i++;
-      }
-      i += 2;
-    } else {
-      out += c;
-      i++;
-    }
-  }
-  return out;
+  return stripSource(src, false);
 }
 
 const TOKEN_RE =
@@ -181,24 +185,26 @@ export function jsdocBefore(source, idx) {
  */
 export function extractExports(source) {
   const found = [];
-  const add = (name, kind, index) => {
-    if (name && !found.some((e) => e.name === name)) found.push({ name, kind, index });
+  const add = (name, kind, index, isDefault) => {
+    if (name && !found.some((e) => e.name === name)) {
+      found.push({ name, kind, index, isDefault: Boolean(isDefault) });
+    }
   };
 
   for (const m of source.matchAll(/export\s+(?:default\s+)?(?:async\s+)?function\s*\*?\s*([A-Za-z0-9_$]+)/g)) {
-    add(m[1], 'function', m.index);
+    add(m[1], 'function', m.index, m[0].startsWith('export default'));
   }
   for (const m of source.matchAll(/export\s+(?:default\s+)?const\s+([A-Za-z0-9_$]+)/g)) {
-    add(m[1], /=>/.test(source.slice(m.index, m.index + 200)) ? 'function' : 'value', m.index);
+    add(m[1], /=>/.test(source.slice(m.index, m.index + 200)) ? 'function' : 'value', m.index, m[0].startsWith('export default'));
   }
   for (const m of source.matchAll(/export\s+(?:abstract\s+)?class\s+([A-Za-z0-9_$]+)/g)) {
-    add(m[1], 'class', m.index);
+    add(m[1], 'class', m.index, m[0].startsWith('export default'));
   }
   for (const m of source.matchAll(/export\s+(?:type|interface)\s+([A-Za-z0-9_$]+)/g)) {
-    add(m[1], 'type', m.index);
+    add(m[1], 'type', m.index, false);
   }
   if (/export\s+default\s+(?!function|class|const)/.test(source)) {
-    add('default', 'default', source.length);
+    add('default', 'default', source.length, true);
   }
   return found.map((e) => ({ ...e, desc: jsdocBefore(source, e.index) }));
 }

package/scripts/anti-slop/run-project-checks.mjs

@@ -0,0 +1,73 @@
+#!/usr/bin/env node
+/**
+ * run-project-checks.mjs — pre-push project checks, without silent skips.
+ *
+ * Runs the repo's own lint/typecheck/test scripts with the package manager
+ * detected from the lockfile, and:
+ *   - prints every check as present or skipped, so "nothing ran" is visible;
+ *   - falls back to `tsc --noEmit` when there is no typecheck script but a
+ *     tsconfig.json exists (a TypeScript repo must not pass untypechecked);
+ *   - works with npm, pnpm, yarn and bun.
+ *
+ * Zero dependencies. Exits non-zero on the first failing check.
+ */
+
+import { readFileSync, existsSync } from 'node:fs';
+import path from 'node:path';
+import { spawnSync } from 'node:child_process';
+
+const cwd = process.cwd();
+const pkg = JSON.parse(readFileSync(path.join(cwd, 'package.json'), 'utf8'));
+const scripts = pkg.scripts ?? {};
+
+function detectPackageManager() {
+  if (existsSync(path.join(cwd, 'pnpm-lock.yaml'))) return 'pnpm';
+  if (existsSync(path.join(cwd, 'yarn.lock'))) return 'yarn';
+  if (existsSync(path.join(cwd, 'bun.lockb')) || existsSync(path.join(cwd, 'bun.lock'))) return 'bun';
+  return 'npm';
+}
+
+const pm = detectPackageManager();
+const run = (cmd, args) => spawnSync(cmd, args, { stdio: 'inherit', shell: process.platform === 'win32' });
+
+/** Run `<pm> run <script>` when it exists. Returns 'ran' | 'skipped'. */
+function runScript(name) {
+  if (!scripts[name]) {
+    console.log(`[skip] ${name}: no "${name}" script in package.json`);
+    return 'skipped';
+  }
+  console.log(`[run] ${name} (${pm} run ${name})`);
+  const res = run(pm, ['run', name]);
+  if (res.status !== 0) {
+    console.error(`\n[x] "${name}" failed (exit ${res.status ?? 'signal'}).`);
+    process.exit(res.status ?? 1);
+  }
+  return 'ran';
+}
+
+/** tsc --noEmit fallback for TypeScript repos without a typecheck script. */
+function runTypecheck() {
+  if (scripts.typecheck) return runScript('typecheck');
+
+  const hasTs = existsSync(path.join(cwd, 'tsconfig.json')) ||
+    scripts.typescript !== undefined ||
+    (pkg.devDependencies && pkg.devDependencies.typescript);
+  if (!hasTs) {
+    console.log('[skip] typecheck: no typecheck script and no TypeScript setup detected');
+    return 'skipped';
+  }
+  console.log('[run] typecheck (fallback: tsc --noEmit — no "typecheck" script was found)');
+  const exec = pm === 'bun' ? 'bunx' : pm === 'npm' ? 'npx' : pm;
+  const res = run(exec, ['--no-install', 'tsc', '--noEmit']);
+  if (res.status !== 0) {
+    console.error(`\n[x] typecheck failed (exit ${res.status ?? 'signal'}).`);
+    process.exit(res.status ?? 1);
+  }
+  return 'ran';
+}
+
+console.log(`[anti-slop] project checks via ${pm}`);
+runScript('lint');
+runTypecheck();
+runScript('test');
+console.log('[ok] project checks done.');

package/templates/anti-slop-ci.yml

@@ -19,4 +19,4 @@ jobs:
       - run: node scripts/anti-slop/check-imports.mjs
       - run: node scripts/anti-slop/check-docs.mjs
       - run: node scripts/anti-slop/check-duplicates.mjs
-      - run: node scripts/anti-slop/generate-component-index.mjs
+      - run: node scripts/anti-slop/generate-component-index.mjs --check