opencode-anti-slop 0.1.1 → 0.1.4

package/scripts/anti-slop/check-modularity.mjs

@@ -21,22 +21,28 @@
  * --report-only prints findings but always exits 0.
  */
 
-import { readFileSync, existsSync } from 'node:fs';
+import { readFileSync } from 'node:fs';
 import path from 'node:path';
 import {
-  walk, stripNoise, lineOf,
+  stripNoise, lineOf,
 } from './lib.mjs';
-import { loadConfig, bootstrapGate, collectPathFiles, resolveScanTarget } from './cli.mjs';
+import {
+  loadConfig, gateArgs, collectPathFiles, resolveScanTarget, applyIgnorePaths,
+} from './cli.mjs';
+import { baselineGate } from './baseline.mjs';
 
 // Defaults < anti-slop.config.json < CLI flags.
 const cfgMod = ((loadConfig().modularity) ?? {});
-const { args, positionals } = bootstrapGate(process.argv.slice(2), {
-  usage: 'Usage: node check-modularity.mjs [paths...] [--src src] [--max-file-lines 300] [--max-function-lines 80] [--max-class-methods 10] [--report-only]\n' +
+const { args, positionals } = gateArgs({
+  argv: process.argv.slice(2),
+  usage: 'Usage: node check-modularity.mjs [paths...] [--src src] [--max-file-lines 300] [--max-function-lines 80] [--max-class-methods 10] [--report-only] [--baseline file] [--update-baseline]\n' +
          'Config: anti-slop.config.json "modularity" section (src, maxFileLines, maxFunctionLines, maxClassMethods).\n' +
-         'With path arguments, checks exactly those files (git-hook staged mode).',
+         'With path arguments, checks exactly those files (git-hook staged mode).\n' +
+         'With a baseline file (default anti-slop.baseline.json) the gate fails only on NEW violations.',
   spec: {
     '--src': 'string', '--max-file-lines': 'number', '--max-function-lines': 'number',
     '--max-class-methods': 'number', '--report-only': 'flag',
+    '--baseline': 'string', '--update-baseline': 'flag',
   },
   defaults: {
     src: cfgMod.src ?? 'src',
@@ -44,9 +50,35 @@ const { args, positionals } = bootstrapGate(process.argv.slice(2), {
     maxFunctionLines: cfgMod.maxFunctionLines ?? 80,
     maxClassMethods: cfgMod.maxClassMethods ?? 10,
   },
+  allowPositionals: true,
 });
 const paths = positionals;
 
+const CONTROL_KEYWORDS = new Set(['if', 'for', 'while', 'switch', 'catch']);
+
+/** True when the `{` at openBraceIdx opens a control-flow block (if/for/while/
+ * switch/catch): the `{` is preceded by a `)` whose matching `(` follows one of
+ * the control keywords. `foo(x) {` (method shorthand) is NOT control flow. */
+function isControlFlow(stripped, openBraceIdx) {
+  let j = openBraceIdx - 1;
+  let depth = 0;
+  while (j >= 0) {
+    const ch = stripped[j];
+    if (ch === ')') depth++;
+    else if (ch === '(') {
+      depth--;
+      if (depth === 0) break;
+    }
+    j--;
+  }
+  if (j < 0) return false;
+  let k = j - 1;
+  while (k >= 0 && /\s/.test(stripped[k])) k--;
+  const end = k;
+  while (k >= 0 && /[\w$]/.test(stripped[k])) k--;
+  return CONTROL_KEYWORDS.has(stripped.slice(k + 1, end + 1));
+}
+
 function analyze(source, limits) {
   const findings = [];
   const stripped = stripNoise(source);
@@ -74,7 +106,10 @@ function analyze(source, limits) {
       // detect `class X ... {`
       const head = stripped.slice(Math.max(0, i - 200), i);
       const cm = /(?:^|[\s;}])class\s+([A-Za-z0-9_$]+)[^{}]*$/.exec(head);
-      const isFn = prev === ')' || head.trimEnd().endsWith('=>');
+      // `if (x) {`, `for (...) {` etc. end in `)` like a function body but are
+      // control flow — excluded by the keyword before their opening paren.
+      let isFn = head.trimEnd().endsWith('=>');
+      if (!isFn && prev === ')') isFn = !isControlFlow(stripped, i);
       if (cm && classStart === null) {
         classStart = { name: cm[1], declIdx: i, braceDepth: depth, methods: 0 };
       } else if (classStart && classStart.braceDepth !== null && depth === classStart.braceDepth + 1 && prev === ')') {
@@ -117,7 +152,14 @@ function analyze(source, limits) {
 }
 
 // --- run ---------------------------------------------------------------------
-const files = positionals.length > 0 ? collectPathFiles(positionals) : resolveScanTarget(args.src);
+// modularity.ignorePaths exempts declarative/framework files from size
+// budgets, matching the drift principle (shape, not logic).
+const modIgnore = Array.isArray(cfgMod.ignorePaths) ? cfgMod.ignorePaths : [];
+const files = applyIgnorePaths(
+  positionals.length > 0 ? collectPathFiles(positionals) : resolveScanTarget(args.src),
+  modIgnore,
+  { label: 'modularity.ignorePaths', src: args.src },
+);
 
 const limits = {
   maxFileLines: args.maxFileLines,
@@ -126,14 +168,20 @@ const limits = {
 };
 
 let violations = 0;
+const perFileKinds = {};
+const fileLines = {};
 for (const file of files) {
   const { findings, totalLines } = analyze(readFileSync(file.full, 'utf8'), limits);
+  fileLines[file.rel] = totalLines;
   if (findings.length === 0) continue;
   console.log(`${file.rel} (${totalLines} lines):`);
+  const kinds = {};
   for (const f of findings) {
     console.log(`  [${f.kind}] line ${f.line}: ${f.detail}`);
+    kinds[f.kind] = (kinds[f.kind] ?? 0) + 1;
     violations++;
   }
+  perFileKinds[file.rel] = kinds;
 }
 
 if (violations === 0) {
@@ -141,10 +189,25 @@ if (violations === 0) {
   process.exit(0);
 }
 
+// --- baseline (ratchet) mode ---------------------------------------------------
+const decision = baselineGate({
+  args,
+  section: 'modularity',
+  current: perFileKinds,
+  kindCounts: true,
+  unit: 'violation(s)',
+  showKind: true,
+  fixLine: 'Fix: split by responsibility (see the modular-architecture skill).',
+});
+if (decision === 'ok') process.exit(0);
+if (decision === 'fail') process.exit(1);
+
 console.log(`\n${violations} size-budget violation(s) in ${files.length} file(s).`);
 console.error(
   '[x] Modularity check FAILED.\n' +
   '    Fix: split by responsibility (see the modular-architecture skill) — transport/service/domain/data,\n' +
-  '    smaller functions, smaller public surfaces. Do NOT compress code, raise budgets, or disable the check.'
+  '    smaller functions, smaller public surfaces. Do NOT compress code, raise budgets, or disable the check.\n' +
+  '    Adopting a repo with legacy violations? Snapshot them once:\n' +
+  '    node scripts/anti-slop/check-modularity.mjs --update-baseline — the gate then fails only on NEW ones.'
 );
 process.exit(args.reportOnly ? 0 : 1);

package/scripts/anti-slop/cli.mjs

@@ -1,128 +1,202 @@
-/**
- * cli.mjs — shared CLI/config plumbing for the anti-slop gate scripts.
- *
- * Zero dependencies (Node >= 18, ESM). Source-scanning helpers live in lib.mjs;
- * this module handles flag parsing, per-repo config loading, and path-to-file
- * resolution. Keep it free of scanning logic.
- */
+/**
+ * cli.mjs — shared CLI/config plumbing for the anti-slop gate scripts.
+ *
+ * Zero dependencies (Node >= 18, ESM). Source-scanning helpers live in lib.mjs;
+ * this module handles flag parsing, per-repo config loading, and path-to-file
+ * resolution. Keep it free of scanning logic.
+ */
+
+import { existsSync, readFileSync, statSync } from 'node:fs';
+import path from 'node:path';
+import { walk, SOURCE_EXT, IGNORE_FILE } from './lib.mjs';
+
+// --- CLI parsing ---------------------------------------------------------------
+
+/**
+ * Parse CLI flags uniformly across gate scripts.
+ *
+ * spec maps flag -> type: 'string' | 'number' | 'flag' (boolean, no value).
+ * argv starts after the script path. Unknown flags and bare positional words
+ * land in `positionals`; each script decides whether positionals are an error
+ * or file paths.
+ *
+ * Returns { values: Record<flag, string|number|true>, positionals: string[] }.
+ */
+export function parseFlags(argv, spec) {
+  const values = {};
+  const positionals = [];
+  for (let i = 0; i < argv.length; i++) {
+    const s = argv[i];
+    const type = spec[s];
+    if (!type) {
+      positionals.push(s);
+      continue;
+    }
+    if (type === 'flag') {
+      values[s] = true;
+      continue;
+    }
+    const raw = argv[++i];
+    if (raw === undefined) {
+      throw new Error(`Missing value for ${s}`);
+    }
+    const v = type === 'number' ? Number(raw) : raw;
+    if (type === 'number' && Number.isNaN(v)) {
+      throw new Error(`${s} expects a number, got: ${raw}`);
+    }
+    values[s] = v;
+  }
+  return { values, positionals };
+}
+
+/**
+ * Common gate bootstrap: handle -h/--help with `usage`, parse flags per `spec`,
+ * and merge flag values over `defaults` (config-supplied). Flag names are
+ * camelCased into arg keys: --min-tokens -> args.minTokens, --report-only ->
+ * args.reportOnly (flags become true/false).
+ *
+ * Returns { args, positionals }. Never returns on -h (exits 0) or a parse
+ * error (exits 1).
+ */
+export function bootstrapGate(argv, { usage, spec, defaults }) {
+  if (argv.includes('-h') || argv.includes('--help')) {
+    console.log(usage);
+    process.exit(0);
+  }
+  let parsed;
+  try {
+    parsed = parseFlags(argv, spec);
+  } catch (err) {
+    console.error(err.message);
+    process.exit(1);
+  }
+  const args = { ...defaults };
+  for (const [flag, type] of Object.entries(spec)) {
+    const key = flag.slice(2).replace(/-([a-z])/g, (_, c) => c.toUpperCase());
+    args[key] = type === 'flag'
+      ? parsed.values[flag] === true
+      : (parsed.values[flag] ?? defaults[key]);
+  }
+  return { args, positionals: parsed.positionals };
+}
+
+/**
+ * Resolve explicit path arguments (files or directories) into { full, rel }
+ * source entries, applying the same filters as walk(). Exits 1 on a missing
+ * path. Used by gate scripts in git-hook staged-file mode.
+ */
+export function collectPathFiles(paths) {
+  const files = [];
+  for (const p of paths) {
+    const abs = path.resolve(p);
+    if (!existsSync(abs)) {
+      console.error(`Path not found: ${p}`);
+      process.exit(1);
+    }
+    if (statSync(abs).isDirectory()) {
+      files.push(...walk(abs, abs));
+    } else if (SOURCE_EXT.has(path.extname(abs)) && !IGNORE_FILE.test(abs)) {
+      files.push({ full: abs, rel: path.relative(process.cwd(), abs).split(path.sep).join('/') });
+    }
+  }
+  return files;
+}
+
+/**
+ * Resolve the scan root given to a gate (--src): accepts a directory (walked)
+ * or a single file. Exits 1 when the path does not exist.
+ */
+export function resolveScanTarget(src) {
+  const abs = path.resolve(src);
+  if (!existsSync(abs)) {
+    console.error(`Source directory not found: ${abs}`);
+    process.exit(1);
+  }
+  if (statSync(abs).isFile()) {
+    return collectPathFiles([src]);
+  }
+  return walk(abs, abs);
+}
+
+/**
+ * bootstrapGate plus the standard positional validation most gates share.
+ * Pass allowPositionals: true for gates that accept file-path arguments
+ * (git-hook staged mode).
+ */
+export function gateArgs({ argv, usage, spec, defaults, allowPositionals = false }) {
+  const { args, positionals } = bootstrapGate(argv, { usage, spec, defaults });
+  if (!allowPositionals && positionals.length > 0) {
+    console.error(`Unexpected arguments: ${positionals.join(' ')} (this script takes flags only)`);
+    process.exit(1);
+  }
+  return { args, positionals };
+}
 
-import { readFileSync, existsSync, statSync } from 'node:fs';
-import path from 'node:path';
-import { walk, SOURCE_EXT, IGNORE_FILE } from './lib.mjs';
-
-// --- CLI parsing ---------------------------------------------------------------
+// --- per-repo config ----------------------------------------------------------
 
 /**
- * Parse CLI flags uniformly across gate scripts.
- *
- * spec maps flag -> type: 'string' | 'number' | 'flag' (boolean, no value).
- * argv starts after the script path. Unknown flags and bare positional words
- * land in `positionals`; each script decides whether positionals are an error
- * or file paths.
- *
- * Returns { values: Record<flag, string|number|true>, positionals: string[] }.
+ * Filter resolved files by a docs/duplicates-style ignore-path config:
+ * globs are matched against THREE path candidates so every mode and both
+ * glob conventions work — the provided rel, repo-relative, and (when `src`
+ * is given) scan-root-relative. Tree-wide walks produce scan-root-relative
+ * rels; git-hook staged mode produces repo-relative ones; configs may use
+ * either convention. Returns the kept files and prints an exclusion notice
+ * when any glob is configured and something matched.
  */
-export function parseFlags(argv, spec) {
-  const values = {};
-  const positionals = [];
-  for (let i = 0; i < argv.length; i++) {
-    const s = argv[i];
-    const type = spec[s];
-    if (!type) {
-      positionals.push(s);
-      continue;
-    }
-    if (type === 'flag') {
-      values[s] = true;
-      continue;
-    }
-    const raw = argv[++i];
-    if (raw === undefined) {
-      throw new Error(`Missing value for ${s}`);
-    }
-    const v = type === 'number' ? Number(raw) : raw;
-    if (type === 'number' && Number.isNaN(v)) {
-      throw new Error(`${s} expects a number, got: ${raw}`);
-    }
-    values[s] = v;
+export function applyIgnorePaths(files, globs, { label = 'ignorePaths', src } = {}) {
+  if (!Array.isArray(globs) || globs.length === 0) return files;
+  const srcDir = src ? path.resolve(src) : null;
+  const kept = files.filter((f) => {
+    const repoRel = path.relative(process.cwd(), f.full).split(path.sep).join('/');
+    const scanRel = srcDir ? path.relative(srcDir, f.full).split(path.sep).join('/') : null;
+    const candidates = scanRel ? [f.rel, repoRel, scanRel] : [f.rel, repoRel];
+    return !candidates.some((p) => matchesAnyGlob(p, globs));
+  });
+  const excluded = files.length - kept.length;
+  if (excluded > 0) {
+    console.log(`Ignoring ${excluded} file(s) matching ${label} (${globs.join(', ')}).`);
   }
-  return { values, positionals };
+  return kept;
 }
 
-/**
- * Common gate bootstrap: handle -h/--help with `usage`, parse flags per `spec`,
- * and merge flag values over `defaults` (config-supplied). Flag names are
- * camelCased into arg keys: --min-tokens -> args.minTokens, --report-only ->
- * args.reportOnly (flags become true/false).
- *
- * Returns { args, positionals }. Never returns on -h (exits 0) or a parse
- * error (exits 1).
- */
-export function bootstrapGate(argv, { usage, spec, defaults }) {
-  if (argv.includes('-h') || argv.includes('--help')) {
-    console.log(usage);
-    process.exit(0);
-  }
-  let parsed;
-  try {
-    parsed = parseFlags(argv, spec);
-  } catch (err) {
-    console.error(err.message);
-    process.exit(1);
-  }
-  const args = { ...defaults };
-  for (const [flag, type] of Object.entries(spec)) {
-    const key = flag.slice(2).replace(/-([a-z])/g, (_, c) => c.toUpperCase());
-    args[key] = type === 'flag'
-      ? parsed.values[flag] === true
-      : (parsed.values[flag] ?? defaults[key]);
-  }
-  return { args, positionals: parsed.positionals };
-}
+const KNOWN_SECTIONS = new Set(['duplicates', 'modularity', 'docs', 'imports', '$schema', '_comment']);
 
-/**
- * Resolve explicit path arguments (files or directories) into { full, rel }
- * source entries, applying the same filters as walk(). Exits 1 on a missing
- * path. Used by gate scripts in git-hook staged-file mode.
- */
-export function collectPathFiles(paths) {
-  const files = [];
-  for (const p of paths) {
-    const abs = path.resolve(p);
-    if (!existsSync(abs)) {
-      console.error(`Path not found: ${p}`);
-      process.exit(1);
-    }
-    if (statSync(abs).isDirectory()) {
-      files.push(...walk(abs, abs));
-    } else if (SOURCE_EXT.has(path.extname(abs)) && !IGNORE_FILE.test(abs)) {
-      files.push({ full: abs, rel: path.relative(process.cwd(), abs).split(path.sep).join('/') });
-    }
+/** Light validation: unknown keys and wrong types warn instead of silently
+ * disabling the tuning (a typo like "duplicate" would otherwise run the gates
+ * on defaults with no signal why). */
+function validateConfig(parsed) {
+  const warns = [];
+  for (const key of Object.keys(parsed)) {
+    if (!KNOWN_SECTIONS.has(key)) warns.push(`unknown key "${key}" (ignored)`);
   }
-  return files;
-}
-
-/**
- * Resolve the scan root given to a gate (--src): accepts a directory (walked)
- * or a single file. Exits 1 when the path does not exist.
- */
-export function resolveScanTarget(src) {
-  const abs = path.resolve(src);
-  if (!existsSync(abs)) {
-    console.error(`Source directory not found: ${abs}`);
-    process.exit(1);
+  const num = (section, key) => {
+    const v = parsed[section]?.[key];
+    if (v !== undefined && (typeof v !== 'number' || Number.isNaN(v))) warns.push(`${section}.${key} must be a number`);
+  };
+  const arr = (section, key) => {
+    const v = parsed[section]?.[key];
+    if (v !== undefined && !Array.isArray(v)) warns.push(`${section}.${key} must be an array of globs/names`);
+  };
+  num('duplicates', 'minTokens');
+  num('duplicates', 'threshold');
+  arr('duplicates', 'ignore');
+  num('modularity', 'maxFileLines');
+  num('modularity', 'maxFunctionLines');
+  num('modularity', 'maxClassMethods');
+  arr('modularity', 'ignorePaths');
+  arr('docs', 'ignorePaths');
+  arr('docs', 'ignoreExports');
+  if (parsed.imports?.deny !== undefined && !Array.isArray(parsed.imports.deny)) {
+    warns.push('imports.deny must be an array of { from, forbid } rules');
   }
-  if (statSync(abs).isFile()) {
-    return collectPathFiles([src]);
+  if (warns.length > 0) {
+    console.error(`[warn] anti-slop.config.json: ${warns.join('; ')}.`);
   }
-  return walk(abs, abs);
 }
 
-// --- per-repo config ----------------------------------------------------------
-
 /**
  * Reads `anti-slop.config.json` from process.cwd() (repo root), returning the
- * parsed object or {} when absent/invalid (with a warning on invalid).
+ * parsed object or {} when absent (warn+{} when unparsable).
  * Scripts merge: defaults < config file < CLI flags.
  *
  * Shape:
@@ -131,21 +205,31 @@ export function resolveScanTarget(src) {
  *                   "ignore": ["collections/**"] },
  *   "modularity": { "src": "src", "maxFileLines": 300, "maxFunctionLines": 80,
  *                   "maxClassMethods": 10 },
- *   "docs":       { "src": "src" }
+ *   "docs":       { "src": "src", "ignorePaths": ["app/(payload)/**"],
+ *                   "ignoreExports": ["metadata", "dynamic"] },
+ *   "imports":    { "src": "src", "deny": [{ "from": "src/domain/**",
+ *                   "forbid": "src/infra/**" }] }
  * }
  *
- * `ignore` (duplicates only) excludes framework-idiomatic declarative files
- * (collection configs, generated tables) whose repetition is shape, not logic.
+ * `ignore` (duplicates) and `ignorePaths` (docs) exclude framework-idiomatic
+ * declarative files whose repetition is shape, not logic.
  */
 export function loadConfig() {
   const file = path.join(process.cwd(), 'anti-slop.config.json');
   if (!existsSync(file)) return {};
+  let parsed;
   try {
-    return JSON.parse(readFileSync(file, 'utf8'));
+    parsed = JSON.parse(readFileSync(file, 'utf8'));
   } catch (err) {
     console.error(`[warn] Could not parse anti-slop.config.json (${err.message}); using defaults.`);
     return {};
   }
+  if (!parsed || typeof parsed !== 'object') {
+    console.error('[warn] anti-slop.config.json is not an object; using defaults.');
+    return {};
+  }
+  validateConfig(parsed);
+  return parsed;
 }
 
 /** Convert a glob (`**`, `*`, `?`) into a RegExp tested against '/'-separated rel paths. */
@@ -172,4 +256,4 @@ export function globToRegex(glob) {
 /** True when relPath matches any ignore glob. */
 export function matchesAnyGlob(relPath, globs) {
   return globs.length > 0 && globs.some((g) => globToRegex(g).test(relPath));
-}
+}

package/scripts/anti-slop/cli.test.mjs

@@ -7,11 +7,16 @@
 
 import test from 'node:test';
 import assert from 'node:assert/strict';
-import { mkdtempSync, writeFileSync, rmSync } from 'node:fs';
+import { mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import path from 'node:path';
 
-import { bootstrapGate, globToRegex, matchesAnyGlob, parseFlags } from './cli.mjs';
+import {
+  bootstrapGate, globToRegex, matchesAnyGlob, parseFlags, gateArgs, applyIgnorePaths,
+} from './cli.mjs';
+import {
+  compareCounts, compareKindCounts, compareSets, loadBaseline, saveBaseline,
+} from './baseline.mjs';
 
 // --- parseFlags ----------------------------------------------------------------
 
@@ -104,3 +109,94 @@ test('matchesAnyGlob: empty list never matches', () => {
 test('matchesAnyGlob: any of several globs', () => {
   assert.ok(matchesAnyGlob('x/y.ts', ['nothing/**', 'x/**']));
 });
+
+// --- applyIgnorePaths -----------------------------------------------------------
+
+test('applyIgnorePaths: scan-root-relative globs match repo-relative staged files', async () => {
+  // Regression for #18: git-hook staged mode passes repo-relative paths
+  // (src/app/...); a config glob written scan-root-relative (app/...) must
+  // still match, because tree-wide mode matches it that way.
+  const dir = mkdtempSync(path.join(tmpdir(), 'antislop-ignore-'));
+  try {
+    const repo = path.join(dir, 'repo');
+    const nested = path.join(repo, 'src', 'app', '(payload)');
+    mkdirSync(nested, { recursive: true });
+    const full = path.join(nested, 'importMap.js');
+    writeFileSync(full, 'export default 1;');
+    const files = [{ full, rel: 'src/app/payload/importMap.js' }];
+    const kept = applyIgnorePaths(files, ['app/(payload)/**'], { src: path.join(repo, 'src') });
+    assert.equal(kept.length, 0);
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test('applyIgnorePaths: repo-relative globs match scan-root-relative rels', () => {
+  // full path under the repo's src/, rel produced by a tree-wide walk
+  const files = [{ full: 'src/collections/Users.ts', rel: 'collections/Users.ts' }];
+  const kept = applyIgnorePaths(files, ['src/collections/**'], { src: 'src' });
+  assert.equal(kept.length, 0);
+});
+
+test('applyIgnorePaths: no globs keeps everything silently', () => {
+  const files = [{ full: 'a.ts', rel: 'a.ts' }];
+  assert.equal(applyIgnorePaths(files, []).length, 1);
+});
+
+// --- baseline ratchet ------------------------------------------------------------
+
+test('compareCounts: unseen file with duplication is new debt', () => {
+  const { newDebt, improved } = compareCounts({ 'a.ts': 5 }, { 'b.ts': 3 });
+  assert.deepEqual(newDebt, [{ rel: 'a.ts', count: 5, accepted: 0 }]);
+  assert.deepEqual(improved, []);
+});
+
+test('compareCounts: growth beyond accepted is new; shrink is improvement', () => {
+  const { newDebt, improved } = compareCounts(
+    { 'a.ts': 8, 'b.ts': 1 },
+    { 'a.ts': 5, 'b.ts': 3 },
+  );
+  assert.deepEqual(newDebt, [{ rel: 'a.ts', count: 8, accepted: 5 }]);
+  assert.deepEqual(improved, [{ rel: 'b.ts', count: 1, accepted: 3 }]);
+});
+
+test('compareCounts: equal counts are neither', () => {
+  const { newDebt, improved } = compareCounts({ 'a.ts': 5 }, { 'a.ts': 5 });
+  assert.deepEqual(newDebt, []);
+  assert.deepEqual(improved, []);
+});
+
+test('compareKindCounts: new kind on a baselined file is new debt', () => {
+  const { newDebt } = compareKindCounts(
+    { 'big.ts': { file: 1, function: 2 } },
+    { 'big.ts': { file: 1, function: 0 } },
+  );
+  assert.deepEqual(newDebt, [{ rel: 'big.ts', kind: 'function', count: 2, accepted: 0 }]);
+});
+
+test('compareKindCounts: unseen file with any violation is new debt', () => {
+  const { newDebt } = compareKindCounts({ 'new.ts': { file: 1 } }, {});
+  assert.deepEqual(newDebt, [{ rel: 'new.ts', kind: 'file', count: 1, accepted: 0 }]);
+});
+
+test('compareSets: added and removed', () => {
+  const { added, removed } = compareSets(['a~b', 'c~d'], ['a~b', 'e~f']);
+  assert.deepEqual(added, ['c~d']);
+  assert.deepEqual(removed, ['e~f']);
+});
+
+test('saveBaseline/loadBaseline: roundtrip with sorted keys', () => {
+  const dir = mkdtempSync(path.join(tmpdir(), 'antislop-baseline-'));
+  try {
+    const file = path.join(dir, 'baseline.json');
+    saveBaseline(file, { duplicates: { files: { 'b.ts': 2, 'a.ts': 1 }, totalDuplicatedLines: 3 } });
+    const loaded = loadBaseline(file);
+    assert.equal(loaded.duplicates.totalDuplicatedLines, 3);
+    assert.deepEqual(Object.keys(loaded.duplicates.files), ['a.ts', 'b.ts']);
+    const raw = readFileSync(file, 'utf8');
+    assert.ok(raw.includes('_comment'));
+    assert.ok(raw.includes('Ratchet baseline'));
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});