@rigour-labs/core 6.6.4 → 6.6.6

package/dist/review/code-patterns.test.js

@@ -7,6 +7,9 @@ import { ConfigSchema } from '../types/index.js';
 import { parseDiff } from '../utils/diff.js';
 import { diffFromGit } from './git-diff.js';
 import { duplicateFunctionFailures } from './duplicate-functions.js';
+import { loopCopyFailures } from './loop-copies.js';
+import { partialFixFailures } from './partial-fixes.js';
+import { partialWiringFailures } from './partial-wiring.js';
 import { optionalParamFailures } from './optional-params.js';
 import { queryPatternFailures } from './query-patterns.js';
 let repo;
@@ -82,3 +85,58 @@ describe('duplicate functions', () => {
         expect(duplicateFunctionFailures(repo, changed(), config)).toEqual([]);
     });
 });
+describe('quadratic copies', () => {
+    it('reports an accumulator spread into a new copy on every step, not a push', () => {
+        write('src/group.ts', [
+            'export function group(items: { day: string }[]) {',
+            '  const groups = new Map<string, { day: string }[]>();',
+            '  for (const item of items) groups.set(item.day, [...(groups.get(item.day) ?? []), item]);',
+            '  const ids = items.reduce((acc: string[], item) => [...acc, item.day], []);',
+            '  const fast = new Map<string, string[]>();',
+            '  for (const item of items) (fast.get(item.day) ?? fast.set(item.day, []).get(item.day)!).push(item.day);',
+            '  return { groups, ids, fast };',
+            '}',
+        ].join('\n'));
+        expect(loopCopyFailures(repo, changed(), config).map(f => f.line)).toEqual([3, 4]);
+    });
+});
+describe('partial fixes', () => {
+    it('names the places that still test the narrower condition a new predicate widened', () => {
+        write('src/routes/session/page.server.ts', 'export function load(snapshot: any) {\n  if (snapshot.answeredCount > 0) return 1;\n  return 0;\n}\n');
+        write('src/routes/session/page.svelte', '<script lang="ts">\n  const show = data.snapshot.answeredCount > 0;\n</script>\n');
+        git('add', '-A');
+        git('commit', '-qm', 'before');
+        write('src/routes/session/page.server.ts', 'export function load(snapshot: any) {\n  if (snapshot.answeredCount > 0) return 1;\n  return 0;\n}\nexport const resume = (snapshot: any) => {\n  const hasSaved = snapshot.answers.length > 0 || snapshot.answeredCount > 0;\n  return hasSaved;\n};\n');
+        const found = partialFixFailures(repo, changed(), config);
+        expect(found.map(f => [f.id, f.line])).toEqual([['partial-fix', 6]]);
+        expect(found[0].details).toContain('page.server.ts:2');
+        expect(found[0].details).toContain('page.svelte:2');
+    });
+});
+describe('partial wiring', () => {
+    const mount = (extra) => `<script lang="ts">\n  import Player from '$lib/Player.svelte';\n</script>\n<Player\n  mode="quiz"\n  {questions}${extra}\n/>\n`;
+    it('reports a callback added to most same-kind mounts of a local component but not one', () => {
+        write('src/lib/Player.svelte', '<script lang="ts">let { onResume } = $props();</script>\n');
+        for (const route of ['a', 'b', 'c'])
+            write(`src/routes/${route}/+page.svelte`, mount(''));
+        write('src/routes/d/+page.svelte', mount('').replace('mode="quiz"', 'mode="exam"'));
+        git('add', '-A');
+        git('commit', '-qm', 'mounts');
+        write('src/routes/a/+page.svelte', mount('\n  {onResume}'));
+        write('src/routes/b/+page.svelte', mount('\n  {onResume}'));
+        const found = partialWiringFailures(repo, changed(), config);
+        expect(found).toHaveLength(1);
+        expect(found[0].details).toContain('src/routes/c/+page.svelte');
+        expect(found[0].details).not.toContain('routes/d'); // another kind of mount
+    });
+    it('ignores styling props and components from packages', () => {
+        const icon = (extra) => `<script lang="ts">\n  import { Star } from 'lucide-svelte';\n</script>\n<Star class="h-4"${extra} />\n`;
+        for (const route of ['a', 'b', 'c'])
+            write(`src/routes/${route}/+page.svelte`, icon(''));
+        git('add', '-A');
+        git('commit', '-qm', 'icons');
+        write('src/routes/a/+page.svelte', icon(' onHover={go}'));
+        write('src/routes/b/+page.svelte', icon(' onHover={go}'));
+        expect(partialWiringFailures(repo, changed(), config)).toEqual([]);
+    });
+});

package/dist/review/dead-code.test.js

@@ -35,6 +35,14 @@ describe('unused exports', () => {
         expect(failures.map(f => [f.files?.[0], f.line, f.id])).toEqual([['src/app.ts', 4, 'unused-export']]);
         expect(failures[0].details).toContain('`lonely`');
     });
+    it('does not count a test as a consumer: an export only its tests import is dead in production', () => {
+        write('src/app.ts', 'export function start() {}\n\nexport function onlyTested() { return 1; }\nexport function used() { return 2; }\n');
+        write('src/app.test.ts', "import { onlyTested, used } from './app';\nonlyTested();\nused();\n");
+        write('tests/helpers.ts', "import { onlyTested } from '../src/app';\nonlyTested();\n");
+        write('src/use.ts', "import { used } from './app';\nused();\n");
+        const names = unusedExportFailures(repo, diffFromGit(repo), config()).map(f => f.details.match(/`([^`]+)`/)[1]);
+        expect(names).toEqual(['onlyTested']);
+    });
     it('reports a re-export nothing imports, without counting the module it comes from as a use', () => {
         write('src/types.ts', 'export type Row = { id: string };\nexport type Used = { n: number };\n');
         write('src/index.ts', "import { start } from './app';\nstart();\nexport type { Row, Used } from './types';\n");

package/dist/review/duplicate-functions.js

@@ -21,8 +21,13 @@ export function duplicateFunctionFailures(cwd, changedLines, config) {
         bodies.push(...bodiesIn(cwd, file, lines));
     }
     const byKey = new Map();
-    for (const body of bodies)
-        byKey.set(body.key, [...(byKey.get(body.key) ?? []), body]);
+    for (const body of bodies) {
+        const same = byKey.get(body.key);
+        if (same)
+            same.push(body);
+        else
+            byKey.set(body.key, [body]);
+    }
     const failures = [];
     for (const same of byKey.values()) {
         if (same.length < 2)

package/dist/review/lint-overlay.d.ts

@@ -0,0 +1,21 @@
+export interface OverlayMessage {
+    file: string;
+    line: number;
+    column: number;
+    rule: string;
+    message: string;
+}
+/** Why the overlay cannot run here, or undefined when it can. */
+export declare function overlayUnavailable(cwd: string): string | undefined;
+/**
+ * Writes the overlay config to a scratch directory and returns its path. It is an ES module that
+ * imports the repository's config by absolute path, so it is never written into the repository.
+ */
+export declare function writeOverlayConfig(cwd: string): string;
+/** ESLint's JSON report, kept to messages on changed lines; the rest is counted. */
+export declare function onChangedLines(json: string, cwd: string, changedLines: Record<string, Set<number>>): {
+    blocking: OverlayMessage[];
+    preexisting: number;
+} | {
+    error: string;
+};

package/dist/review/lint-overlay.js

@@ -0,0 +1,89 @@
+/**
+ * Type-checked lint rules the repository does not enable yet, on changed lines only. They are the
+ * mechanical dead-code classes a person keeps finding after lint is green: a condition that can
+ * never be true once the types say so, a `?.` on a member every host supplies, a redundant
+ * comparison, a promise nobody awaits. The overlay loads the repository's own flat config first,
+ * so nothing it enforces is lost, and uses its own `typescript-eslint` (never a download). A
+ * message on a line the change did not touch is the team's backlog: counted, not blocking.
+ */
+import fs from 'fs';
+import { createRequire } from 'module';
+import os from 'os';
+import path from 'path';
+import { pathToFileURL } from 'url';
+const CONFIG_FILES = ['eslint.config.js', 'eslint.config.mjs', 'eslint.config.cjs', 'eslint.config.ts', 'eslint.config.mts'];
+const TYPED_RULES = {
+    '@typescript-eslint/no-unnecessary-condition': 'error',
+    '@typescript-eslint/no-unnecessary-boolean-literal-compare': 'error',
+    '@typescript-eslint/no-unnecessary-type-assertion': 'error',
+    '@typescript-eslint/no-redundant-type-constituents': 'error',
+    '@typescript-eslint/prefer-optional-chain': 'error',
+    '@typescript-eslint/switch-exhaustiveness-check': 'error',
+    '@typescript-eslint/no-floating-promises': 'error',
+    '@typescript-eslint/no-misused-promises': 'error',
+};
+/** Why the overlay cannot run here, or undefined when it can. */
+export function overlayUnavailable(cwd) {
+    if (!CONFIG_FILES.some(name => fs.existsSync(path.join(cwd, name))))
+        return 'no eslint.config.* in this repository';
+    try {
+        createRequire(path.join(cwd, 'package.json')).resolve('typescript-eslint');
+    }
+    catch {
+        return 'typescript-eslint is not installed';
+    }
+    return undefined;
+}
+/**
+ * Writes the overlay config to a scratch directory and returns its path. It is an ES module that
+ * imports the repository's config by absolute path, so it is never written into the repository.
+ */
+export function writeOverlayConfig(cwd) {
+    const base = CONFIG_FILES.find(name => fs.existsSync(path.join(cwd, name)));
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'rigour-lint-overlay-'));
+    const file = path.join(dir, 'eslint.overlay.config.mjs');
+    fs.writeFileSync(file, `import path from 'node:path';
+import { createRequire } from 'node:module';
+const repo = ${JSON.stringify(cwd)};
+const require = createRequire(path.join(repo, 'package.json'));
+const base = (await import(${JSON.stringify(pathToFileURL(path.join(cwd, base)).href)})).default;
+const ts = require('typescript-eslint');
+const typed = ${JSON.stringify(TYPED_RULES, null, 4)};
+export default [
+    ...base,
+    {
+        files: ['**/*.ts', '**/*.mts', '**/*.cts', '**/*.js', '**/*.mjs', '**/*.svelte.ts', '**/*.svelte.js'],
+        ignores: ['**/*.d.ts'],
+        languageOptions: { parser: ts.parser, parserOptions: { projectService: { allowDefaultProject: ['*.mjs', 'scripts/*.mjs'] }, tsconfigRootDir: repo } },
+        rules: typed,
+    },
+    { files: ['**/*.svelte'], rules: typed },
+    // A test fake deliberately covers cases the types call impossible.
+    { files: ['**/*.test.ts', '**/*.spec.ts', '**/*.svelte.test.ts', 'tests/**', 'test/**', '**/__tests__/**'], rules: { '@typescript-eslint/no-unnecessary-condition': 'off', '@typescript-eslint/no-floating-promises': 'off' } },
+];
+`);
+    return file;
+}
+/** ESLint's JSON report, kept to messages on changed lines; the rest is counted. */
+export function onChangedLines(json, cwd, changedLines) {
+    let results;
+    try {
+        results = JSON.parse(json);
+    }
+    catch {
+        return { error: `eslint printed no JSON: ${json.trim().slice(0, 200)}` };
+    }
+    const blocking = [];
+    let preexisting = 0;
+    for (const result of results) {
+        const file = path.relative(cwd, result.filePath).split(path.sep).join('/');
+        const lines = changedLines[file];
+        for (const message of result.messages) {
+            if (lines?.has(message.line))
+                blocking.push({ file, line: message.line, column: message.column, rule: message.ruleId ?? 'error', message: message.message });
+            else
+                preexisting++;
+        }
+    }
+    return { blocking, preexisting };
+}

package/dist/review/loop-copies.d.ts

@@ -0,0 +1,2 @@
+import type { Config, Failure } from '../types/index.js';
+export declare function loopCopyFailures(cwd: string, changedLines: Record<string, Set<number>>, config: Config): Failure[];

package/dist/review/loop-copies.js

@@ -0,0 +1,116 @@
+/**
+ * Quadratic copy: an accumulator copied whole on every step of a loop.
+ * `groups.set(k, [...(groups.get(k) ?? []), item])`, `acc = [...acc, item]`, or a reduce that
+ * returns `[...acc, item]` / `{ ...acc, [k]: v }` copies everything gathered so far each time, so
+ * n items cost O(n²). Pushing into the existing array (or assigning the key) is linear.
+ * Reported only on lines a change adds, from the syntax tree.
+ */
+import fs from 'fs';
+import path from 'path';
+import ts from 'typescript';
+const CODE = /\.(ts|tsx|js|jsx|mjs|cjs)$/;
+const BUILD_OUTPUT = /(^|\/)(dist|build|out|coverage|\.next|[\w-]+-dist)\//;
+export function loopCopyFailures(cwd, changedLines, config) {
+    if (!config.gates.change_sweep?.enabled)
+        return [];
+    const failures = [];
+    for (const [file, lines] of Object.entries(changedLines)) {
+        if (!CODE.test(file) || BUILD_OUTPUT.test(file) || lines.size === 0)
+            continue;
+        let source;
+        try {
+            const text = fs.readFileSync(path.join(cwd, file), 'utf8');
+            if (!text.includes('...'))
+                continue;
+            source = ts.createSourceFile(file, text, ts.ScriptTarget.Latest, true);
+        }
+        catch {
+            continue;
+        }
+        const visit = (node) => {
+            const copied = copiedAccumulator(node, source);
+            if (copied) {
+                const line = source.getLineAndCharacterOfPosition(node.getStart(source)).line + 1;
+                if (lines.has(line))
+                    failures.push(quadratic(file, line, copied));
+            }
+            ts.forEachChild(node, visit);
+        };
+        visit(source);
+    }
+    return failures;
+}
+/** The accumulator a node copies whole, inside a loop or a reduce, or undefined. */
+function copiedAccumulator(node, source) {
+    // m.set(k, [...(m.get(k) ?? []), v]) in a loop
+    if (ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression) && node.expression.name.text === 'set' && node.arguments.length === 2) {
+        const map = node.expression.expression.getText(source);
+        const value = node.arguments[1];
+        if (ts.isArrayLiteralExpression(value) && value.elements.some(e => ts.isSpreadElement(e) && e.expression.getText(source).replace(/\s+/g, '').startsWith(`(${map}.get(`))) {
+            return insideLoop(node) ? `${map}'s list` : undefined;
+        }
+    }
+    // acc = [...acc, v] / acc = { ...acc, k: v } in a loop
+    if (ts.isBinaryExpression(node) && node.operatorToken.kind === ts.SyntaxKind.EqualsToken && ts.isIdentifier(node.left)) {
+        const name = node.left.text;
+        if (spreadsItself(node.right, name, source) && insideLoop(node))
+            return name;
+    }
+    // reduce((acc, v) => [...acc, v]) or { ...acc, [k]: v }
+    if (ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression) && node.expression.name.text === 'reduce') {
+        const reducer = node.arguments[0];
+        if (reducer && (ts.isArrowFunction(reducer) || ts.isFunctionExpression(reducer)) && reducer.parameters[0] && ts.isIdentifier(reducer.parameters[0].name)) {
+            const acc = reducer.parameters[0].name.text;
+            const results = ts.isBlock(reducer.body)
+                ? collectReturns(reducer.body)
+                : [ts.isParenthesizedExpression(reducer.body) ? reducer.body.expression : reducer.body];
+            if (results.some(r => spreadsItself(r, acc, source)))
+                return acc;
+        }
+    }
+    return undefined;
+}
+function spreadsItself(expr, name, source) {
+    const unwrapped = ts.isParenthesizedExpression(expr) ? expr.expression : expr;
+    if (ts.isArrayLiteralExpression(unwrapped))
+        return unwrapped.elements.some(e => ts.isSpreadElement(e) && e.expression.getText(source) === name);
+    if (ts.isObjectLiteralExpression(unwrapped))
+        return unwrapped.properties.some(p => ts.isSpreadAssignment(p) && p.expression.getText(source) === name);
+    return false;
+}
+function collectReturns(body) {
+    const found = [];
+    const walk = (node) => {
+        if (ts.isFunctionLike(node))
+            return;
+        if (ts.isReturnStatement(node) && node.expression)
+            found.push(node.expression);
+        ts.forEachChild(node, walk);
+    };
+    body.statements.forEach(walk);
+    return found;
+}
+/** A loop (or an array callback that runs per item) between the node and its function. */
+function insideLoop(node) {
+    for (let current = node.parent; current; current = current.parent) {
+        if (ts.isForStatement(current) || ts.isForOfStatement(current) || ts.isForInStatement(current) || ts.isWhileStatement(current) || ts.isDoStatement(current))
+            return true;
+        if (ts.isFunctionLike(current)) {
+            const call = current.parent;
+            return !!call && ts.isCallExpression(call) && ts.isPropertyAccessExpression(call.expression) && /^(forEach|map|flatMap)$/.test(call.expression.name.text);
+        }
+    }
+    return false;
+}
+function quadratic(file, line, accumulator) {
+    return {
+        id: 'quadratic-copy',
+        title: 'Accumulator copied on every step',
+        details: `${accumulator} is copied whole on every step (spread into a new array or object), so n items cost O(n²) work and allocations.`,
+        severity: 'medium',
+        provenance: 'traditional',
+        files: [file],
+        line,
+        hint: 'Mutate the accumulator you already own: push onto the existing list (`(m.get(k) ?? m.set(k, []).get(k)!).push(v)`), or assign the key.',
+    };
+}

package/dist/review/migration-order.js

@@ -24,7 +24,11 @@ export function migrationOrderFailures(cwd, diff, source, config) {
         const directory = path.posix.dirname(file);
         if (!file.endsWith('.sql') || !micromatch.isMatch(directory, settings.dirs))
             continue;
-        byDirectory.set(directory, [...(byDirectory.get(directory) ?? []), file]);
+        const files = byDirectory.get(directory);
+        if (files)
+            files.push(file);
+        else
+            byDirectory.set(directory, [file]);
     }
     const failures = [];
     for (const [directory, added] of byDirectory) {

package/dist/review/orphan-files.js

@@ -53,7 +53,11 @@ function referrersOf(cwd, added, files) {
     const underFolder = new Map();
     for (const file of added) {
         for (let dir = path.posix.dirname(file); dir !== '.' && dir !== '/'; dir = path.posix.dirname(dir)) {
-            underFolder.set(dir, [...(underFolder.get(dir) ?? []), file]);
+            const files = underFolder.get(dir);
+            if (files)
+                files.push(file);
+            else
+                underFolder.set(dir, [file]);
         }
     }
     const referrers = new Map(added.map(file => [file, new Set()]));

package/dist/review/partial-fixes.d.ts

@@ -0,0 +1,2 @@
+import type { Config, Failure } from '../types/index.js';
+export declare function partialFixFailures(cwd: string, changedLines: Record<string, Set<number>>, config: Config): Failure[];

package/dist/review/partial-fixes.js

@@ -0,0 +1,138 @@
+/**
+ * Partial fix: a change names a broader condition (`const hasSaved = a.length > 0 || count > 0`)
+ * and uses it at some call sites, while the narrower condition it replaces (`count > 0`) is still
+ * tested on its own elsewhere in the same folder (the same route's other file, a sibling page).
+ * "Fixed" means every case, so the places still using the old form are named. Reported on the
+ * line that adds the named condition, since the leftovers are, by definition, lines it did not touch.
+ */
+import fs from 'fs';
+import path from 'path';
+import ts from 'typescript';
+const CODE = /\.(ts|tsx|js|jsx|mjs|cjs|svelte)$/;
+const SKIPPED = /\.(test|spec)\.|\.d\.ts$/;
+export function partialFixFailures(cwd, changedLines, config) {
+    if (!config.gates.change_sweep?.enabled)
+        return [];
+    const failures = [];
+    for (const [file, lines] of Object.entries(changedLines)) {
+        if (!/\.(ts|tsx|js|jsx|mjs|cjs)$/.test(file) || SKIPPED.test(file) || lines.size === 0)
+            continue;
+        const source = parse(cwd, file);
+        if (!source)
+            continue;
+        const visit = (node) => {
+            if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name) && node.initializer && isOr(node.initializer)) {
+                const line = source.getLineAndCharacterOfPosition(node.getStart(source)).line + 1;
+                if (lines.has(line)) {
+                    const leftovers = narrowerElsewhere(cwd, file, line, parts(node.initializer, source), changedLines);
+                    if (leftovers.length)
+                        failures.push(partial(file, line, node.name.text, leftovers));
+                }
+            }
+            ts.forEachChild(node, visit);
+        };
+        visit(source);
+    }
+    return failures;
+}
+function isOr(expr) {
+    const e = ts.isParenthesizedExpression(expr) ? expr.expression : expr;
+    return ts.isBinaryExpression(e) && e.operatorToken.kind === ts.SyntaxKind.BarBarToken;
+}
+/**
+ * The comparisons a broader condition ORs together. A comparison on a property (`x.count > 0`)
+ * matches the same property, operator and value on any receiver (`data.x.count > 0`).
+ */
+function parts(expr, source) {
+    const found = [];
+    const walk = (e) => {
+        const inner = ts.isParenthesizedExpression(e) ? e.expression : e;
+        if (ts.isBinaryExpression(inner) && inner.operatorToken.kind === ts.SyntaxKind.BarBarToken) {
+            walk(inner.left);
+            walk(inner.right);
+            return;
+        }
+        if (ts.isBinaryExpression(inner) && isComparison(inner.operatorToken.kind) && ts.isPropertyAccessExpression(inner.left) && isLiteral(inner.right)) {
+            // The receiver's last name and the property (`answers.length`, `snapshot.answeredCount`): specific
+            // enough that an unrelated `.length > 0` never matches, loose enough for `data.snapshot.answeredCount`.
+            const receiver = inner.left.expression;
+            const owner = ts.isIdentifier(receiver) ? receiver.text : ts.isPropertyAccessExpression(receiver) ? receiver.name.text : undefined;
+            if (!owner)
+                return;
+            const tail = `${owner}.${inner.left.name.text}`;
+            const operator = inner.operatorToken.getText(source);
+            const value = inner.right.getText(source);
+            found.push({
+                text: inner.getText(source),
+                pattern: new RegExp(`(?<![\\w$])${escape(tail)}\\s*${escape(operator)}\\s*${escape(value)}(?![\\w.])`),
+            });
+        }
+    };
+    walk(expr);
+    return found;
+}
+function isComparison(kind) {
+    return [ts.SyntaxKind.GreaterThanToken, ts.SyntaxKind.GreaterThanEqualsToken, ts.SyntaxKind.LessThanToken, ts.SyntaxKind.LessThanEqualsToken,
+        ts.SyntaxKind.EqualsEqualsEqualsToken, ts.SyntaxKind.ExclamationEqualsEqualsToken].includes(kind);
+}
+function isLiteral(e) {
+    return ts.isNumericLiteral(e) || ts.isStringLiteral(e) || e.kind === ts.SyntaxKind.NullKeyword || e.kind === ts.SyntaxKind.TrueKeyword || e.kind === ts.SyntaxKind.FalseKeyword;
+}
+/** `file:line` of each remaining standalone use of a part, in the same folder, outside the broader condition. */
+function narrowerElsewhere(cwd, file, declLine, found, changed) {
+    if (found.length < 2)
+        return [];
+    const dir = path.posix.dirname(file);
+    let siblings;
+    try {
+        siblings = fs.readdirSync(path.join(cwd, dir)).filter(name => CODE.test(name) && !SKIPPED.test(name)).map(name => path.posix.join(dir, name));
+    }
+    catch {
+        return [];
+    }
+    const leftovers = [];
+    for (const sibling of siblings) {
+        let text;
+        try {
+            text = fs.readFileSync(path.join(cwd, sibling), 'utf8');
+        }
+        catch {
+            continue;
+        }
+        text.split('\n').forEach((content, index) => {
+            const line = index + 1;
+            if (sibling === file && line === declLine)
+                return;
+            // A line the change itself added is the author's current intent, not a leftover.
+            if (changed[sibling]?.has(line) && sibling === file)
+                return;
+            if (found.some(part => part.pattern.test(content)) && !found.every(part => part.pattern.test(content)))
+                leftovers.push(`${sibling}:${line}`);
+        });
+    }
+    return leftovers;
+}
+function parse(cwd, file) {
+    try {
+        return ts.createSourceFile(file, fs.readFileSync(path.join(cwd, file), 'utf8'), ts.ScriptTarget.Latest, true);
+    }
+    catch {
+        return undefined;
+    }
+}
+function escape(text) {
+    return text.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+function partial(file, line, name, leftovers) {
+    const listed = leftovers.slice(0, 5).map(l => `\`${l}\``).join(', ');
+    return {
+        id: 'partial-fix',
+        title: 'Partial fix',
+        details: `\`${name}\` widens a condition, but the narrower form is still tested on its own at ${listed}${leftovers.length > 5 ? ` and ${leftovers.length - 5} more` : ''}.`,
+        severity: 'medium',
+        provenance: 'traditional',
+        files: [file],
+        line,
+        hint: `Use \`${name}\` (or the same condition) at each of those places too, or say in a comment why the narrower test is right there.`,
+    };
+}

package/dist/review/partial-wiring.d.ts

@@ -0,0 +1,2 @@
+import type { Config, Failure } from '../types/index.js';
+export declare function partialWiringFailures(cwd: string, changedLines: Record<string, Set<number>>, config: Config): Failure[];