@rigour-labs/core 6.12.2-rc.4 → 6.12.2-rc.6

package/dist/gates/runner.d.ts

@@ -1,5 +1,7 @@
 import { Gate } from './base.js';
 import { Failure, Config, Report, DeepOptions } from '../types/index.js';
+/** The gate a finding came from, for a finding this runner produced; else undefined. */
+export declare function gateOf(failure: Failure): string | undefined;
 export declare class GateRunner {
     private config;
     private gates;

package/dist/gates/runner.js

@@ -36,6 +36,12 @@ import { execa } from 'execa';
 import { Logger } from '../utils/logger.js';
 import { FileSystemCache } from '../services/filesystem-cache.js';
 import { onChangedLines, settledChecks } from '../review/settled-checks.js';
+/** The gate each finding of a run came from (a gate may give its findings other ids, such as `AST_COMPLEXITY`). */
+const GATE_OF = new WeakMap();
+/** The gate a finding came from, for a finding this runner produced; else undefined. */
+export function gateOf(failure) {
+    return GATE_OF.get(failure);
+}
 export class GateRunner {
     config;
     gates = [];
@@ -166,6 +172,8 @@ export class GateRunner {
                 let skipped;
                 const gateFailures = await gate.run({ cwd, record, ignore, patterns, fileCache, skip: reason => { skipped = reason; } });
                 if (gateFailures.length > 0) {
+                    for (const f of gateFailures)
+                        GATE_OF.set(f, gate.id);
                     failures.push(...gateFailures);
                     summary[gate.id] = 'FAIL';
                 }

package/dist/gates/test-quality-helpers.d.ts

@@ -0,0 +1,6 @@
+/** Names this test file can call that assert. `read` reads a module once per run (cached by the caller). */
+export declare function assertionHelpers(cwd: string, file: string, content: string, read: (abs: string) => Promise<string | undefined>): Promise<Set<string>>;
+/** A call to one of the names on this line; `member` also counts `self.name(` (a Python method). */
+export declare function callsHelper(line: string, helpers: Set<string>, member?: boolean): boolean;
+/** Python: names this test file can call that assert (see the file comment). */
+export declare function pythonAssertionHelpers(cwd: string, file: string, content: string, read: (abs: string) => Promise<string | undefined>): Promise<Set<string>>;

package/dist/gates/test-quality-helpers.js

@@ -0,0 +1,155 @@
+import path from 'path';
+const HELPER_NAME = /^(?:expect|assert|should)[A-Z0-9_$]/;
+const ASSERTS = /\bexpect\s*[(.]|\bassert\s*[.(]/;
+const IMPORT = /import\s+(?:type\s+)?([\w$]+\s*,?\s*)?(?:\{([^}]*)\})?\s*from\s*['"]([^'"]+)['"]/g;
+const EXTENSIONS = ['', '.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs', '/index.ts', '/index.js'];
+/** Names this test file can call that assert. `read` reads a module once per run (cached by the caller). */
+export async function assertionHelpers(cwd, file, content, read) {
+    const helpers = new Set(definedAsserting(content));
+    for (const m of content.matchAll(IMPORT)) {
+        const names = importedNames(m[1], m[2]);
+        for (const [local, exported] of names)
+            if (HELPER_NAME.test(local) || HELPER_NAME.test(exported))
+                helpers.add(local);
+        if (!m[3].startsWith('.'))
+            continue;
+        const source = await moduleSource(path.join(cwd, path.dirname(file), m[3]), read);
+        if (!source)
+            continue;
+        const asserting = new Set(definedAsserting(source));
+        for (const [local, exported] of names)
+            if (asserting.has(exported))
+                helpers.add(local);
+    }
+    return helpers;
+}
+/** A call to one of the names on this line; `member` also counts `self.name(` (a Python method). */
+export function callsHelper(line, helpers, member = false) {
+    const before = member ? '(?:^|[^\\w$.]|\\bself\\.)' : '(?:^|[^\\w$.])';
+    for (const name of helpers)
+        if (new RegExp(`${before}${name.replace(/\$/g, '\\$')}\\s*[(<]`).test(line))
+            return true;
+    return false;
+}
+/** `[local, exported]` pairs of an import's default and named bindings. */
+function importedNames(defaultName, named) {
+    const pairs = [];
+    const d = defaultName?.replace(/[\s,]/g, '');
+    if (d)
+        pairs.push([d, 'default']);
+    for (const part of (named ?? '').split(',')) {
+        const [exported, local] = part.replace(/^\s*type\s+/, '').trim().split(/\s+as\s+/);
+        if (exported)
+            pairs.push([(local ?? exported).trim(), exported.trim()]);
+    }
+    return pairs;
+}
+async function moduleSource(base, read) {
+    // An ESM import names the compiled file (`./helpers.js`); the source is `./helpers.ts`.
+    const stems = [...new Set([base, base.replace(/\.[cm]?js$/, '')])];
+    for (const stem of stems)
+        for (const ext of EXTENSIONS) {
+            const text = await read(stem + ext);
+            if (text !== undefined)
+                return text;
+        }
+    return undefined;
+}
+/** Functions defined in this source whose body calls expect or assert. */
+function definedAsserting(source) {
+    const names = [];
+    const DEF = /function\s*\*?\s*([\w$]+)\s*[<(]|(?:const|let|var)\s+([\w$]+)\s*(?::[^=]+)?=\s*(?:async\s+)?(?:function\b|\([^)]*\)\s*(?::[^=]+)?=>|[\w$]+\s*=>)/g;
+    for (const m of source.matchAll(DEF)) {
+        const from = m.index + m[0].length;
+        const body = m[1] || !m[0].endsWith('=>') ? blockAt(source, afterParams(source, m.index)) : arrowBodyAt(source, from);
+        if (ASSERTS.test(body))
+            names.push(m[1] ?? m[2]);
+    }
+    return names;
+}
+/** Just past a function's parameter list (which may hold `{ … }` types or defaults), from its `function` keyword. */
+function afterParams(source, from) {
+    const open = source.indexOf('(', from);
+    if (open < 0)
+        return from;
+    let depth = 0;
+    for (let i = open; i < source.length; i++) {
+        if (source[i] === '(')
+            depth++;
+        else if (source[i] === ')' && --depth === 0)
+            return i + 1;
+    }
+    return source.length;
+}
+/** The first braced block from `from`, braces balanced. */
+function blockAt(source, from) {
+    const open = source.indexOf('{', from);
+    if (open < 0)
+        return '';
+    let depth = 0;
+    for (let i = open; i < source.length; i++) {
+        if (source[i] === '{')
+            depth++;
+        else if (source[i] === '}' && --depth === 0)
+            return source.slice(open, i + 1);
+    }
+    return source.slice(open);
+}
+/** An arrow function's body: a block, else its expression up to the end of the statement. */
+function arrowBodyAt(source, from) {
+    const rest = source.slice(from);
+    if (rest.trimStart().startsWith('{'))
+        return blockAt(source, from);
+    const end = rest.search(/;|\n\s*\n/);
+    return end < 0 ? rest : rest.slice(0, end);
+}
+const PY_ASSERTS = /\bassert\b|\bself\.assert\w*\s*\(|\braise\s+AssertionError\b|\bpytest\.(?:raises|fail)\b|\.assert_\w+\s*\(/;
+const PY_FROM = /^\s*from\s+(\.*[\w.]*)\s+import\s+\(?([^)\n]*)/gm;
+/** Python: names this test file can call that assert (see the file comment). */
+export async function pythonAssertionHelpers(cwd, file, content, read) {
+    const helpers = new Set(pythonDefinedAsserting(content));
+    for (const m of content.matchAll(PY_FROM)) {
+        for (const part of m[2].split(',')) {
+            const [exported, local] = part.trim().split(/\s+as\s+/);
+            if (exported && HELPER_NAME_PY.test(exported))
+                helpers.add((local ?? exported).trim());
+        }
+        const source = await pythonModule(cwd, file, m[1], read);
+        for (const name of source ? pythonDefinedAsserting(source) : [])
+            helpers.add(name);
+    }
+    return helpers;
+}
+const HELPER_NAME_PY = /^(?:expect|assert|should)_?\w/;
+async function pythonModule(cwd, file, module, read) {
+    const dots = module.match(/^\.*/)[0].length;
+    const parts = module.slice(dots).split('.').filter(Boolean);
+    let base = cwd;
+    if (dots) {
+        base = path.join(cwd, path.dirname(file));
+        for (let i = 1; i < dots; i++)
+            base = path.dirname(base);
+    }
+    const stem = path.join(base, ...parts);
+    return await read(`${stem}.py`) ?? await read(path.join(stem, '__init__.py'));
+}
+/** Python functions and methods in this source whose body asserts. */
+function pythonDefinedAsserting(source) {
+    const names = [];
+    const lines = source.split('\n');
+    lines.forEach((line, i) => {
+        const def = line.match(/^(\s*)(?:async\s+)?def\s+(\w+)\s*\(/);
+        if (!def || def[2].startsWith('test_'))
+            return;
+        for (let j = i + 1; j < lines.length; j++) {
+            const next = lines[j];
+            if (next.trim() && next.search(/\S/) <= def[1].length && !/^\s*[)\]]/.test(next))
+                break;
+            if (PY_ASSERTS.test(next)) {
+                names.push(def[2]);
+                break;
+            }
+        }
+    });
+    return names;
+}

package/dist/gates/test-quality.js

@@ -25,6 +25,7 @@ import { FileScanner } from '../utils/scanner.js';
 import { Logger } from '../utils/logger.js';
 import { languageAdapters } from './language-adapters/index.js';
 import { checkGoTestQuality, checkJavaKotlinTestQuality } from './test-quality-lang.js';
+import { assertionHelpers, callsHelper, pythonAssertionHelpers } from './test-quality-helpers.js';
 import { JS_TEST_START_PATTERN, JS_ASSERTION_PATTERNS, JS_MOCK_PATTERNS, JS_TAUTOLOGICAL_PATTERNS, JS_VAR_TAUTOLOGY_PATTERN, PYTHON_TEST_FUNC_PATTERN, PYTHON_ASSERTION_PATTERNS, PYTHON_MOCK_PATTERNS, PYTHON_TAUTOLOGICAL_PATTERNS, PYTHON_FIXTURE_PATTERN, PYTHON_CONFTEST_NAME, } from './test-quality-matchers.js';
 import fs from 'fs-extra';
 import path from 'path';
@@ -66,6 +67,13 @@ export class TestQualityGate extends Gate {
                 '**/target/**', '**/.gradle/**', '**/out/**'],
         });
         Logger.info(`Test Quality: Scanning ${files.length} test files`);
+        // Helper modules several test files import are read once per run.
+        const modules = new Map();
+        const read = (abs) => {
+            if (!modules.has(abs))
+                modules.set(abs, Promise.resolve().then(() => fs.readFile(abs, 'utf-8')).catch(() => undefined));
+            return modules.get(abs);
+        };
         const CONCURRENCY = 16;
         for (let i = 0; i < files.length; i += CONCURRENCY) {
             const batch = files.slice(i, i + CONCURRENCY);
@@ -79,10 +87,10 @@ export class TestQualityGate extends Gate {
                 const localIssues = [];
                 switch (adapter.id) {
                     case 'js':
-                        this.checkJSTestQuality(content, file, localIssues);
+                        this.checkJSTestQuality(content, file, localIssues, await assertionHelpers(context.cwd, file, content, read));
                         break;
                     case 'python':
-                        this.checkPythonTestQuality(content, file, localIssues);
+                        this.checkPythonTestQuality(content, file, localIssues, await pythonAssertionHelpers(context.cwd, file, content, read));
                         break;
                     case 'go':
                         checkGoTestQuality(content, file, localIssues, {
@@ -121,7 +129,7 @@ export class TestQualityGate extends Gate {
         }
         return failures;
     }
-    checkJSTestQuality(content, file, issues) {
+    checkJSTestQuality(content, file, issues, helpers = new Set()) {
         const lines = content.split('\n');
         // Track test blocks for analysis
         let inTestBlock = false;
@@ -170,7 +178,7 @@ export class TestQualityGate extends Gate {
                         braceDepth--;
                 }
                 // Check for assertions
-                if (JS_ASSERTION_PATTERNS.some(p => p.test(line))) {
+                if (JS_ASSERTION_PATTERNS.some(p => p.test(line)) || callsHelper(line, helpers)) {
                     hasAssertion = true;
                 }
                 // Check for mocks
@@ -244,7 +252,7 @@ export class TestQualityGate extends Gate {
             });
         }
     }
-    checkPythonTestQuality(content, file, issues) {
+    checkPythonTestQuality(content, file, issues, helpers = new Set()) {
         const lines = content.split('\n');
         const basename = path.basename(file);
         // Skip conftest.py entirely — these contain fixtures, not tests
@@ -309,7 +317,7 @@ export class TestQualityGate extends Gate {
                 }
                 testContent += line + '\n';
                 // Check for assertions
-                if (PYTHON_ASSERTION_PATTERNS.some(p => p.test(trimmed))) {
+                if (PYTHON_ASSERTION_PATTERNS.some(p => p.test(trimmed)) || callsHelper(trimmed, helpers, true)) {
                     hasAssertion = true;
                 }
                 // Check for mocks

package/dist/review/review.d.ts

@@ -38,6 +38,8 @@ export interface ReviewResult {
     excludedOutsideChangedLines: number;
     /** Findings the base already had: counted, not reported (baseline.ts). */
     preexisting: number;
+    /** The same, by check. A check whose findings were all the base's reads PASS in the report's summary. */
+    preexistingByCheck: Record<string, number>;
     /** A diff given with no base whose change HEAD already holds (committed work): nothing was compared, so nothing was dropped as the base's. */
     baseUnknown?: boolean;
     changedLines: Record<string, Set<number>>;

package/dist/review/review.js

@@ -8,7 +8,7 @@
  * and so does a proven gate that crashed (a heuristic one is only listed).
  */
 import { spawnSync } from 'child_process';
-import { GateRunner } from '../gates/runner.js';
+import { GateRunner, gateOf } from '../gates/runner.js';
 import { changedLinesByFile, parseDiff, removedByFile } from '../utils/diff.js';
 import { normalizeScopePatterns } from '../utils/scope.js';
 import { deepAnalysisError } from '../utils/deep-status.js';
@@ -39,14 +39,14 @@ export async function reviewChange(input) {
     const changedLines = withoutGenerated(input.cwd, parseDiff(diff));
     const targets = input.files?.length ? input.files : Object.keys(changedLines);
     if (targets.length === 0) {
-        return { status: 'PASS', findings: [], fileFindings: [], contextFindings: [], advisory: [], muted: 0, dismissed: 0, dismissedByGate: {}, unlocated: 0, excludedOutsideChangedLines: 0, preexisting: 0, changedLines, report: null, gateErrors: [], controlFilesChanged: controlFiles(diff), hints: [], covered: [] };
+        return { status: 'PASS', findings: [], fileFindings: [], contextFindings: [], advisory: [], muted: 0, dismissed: 0, dismissedByGate: {}, unlocated: 0, excludedOutsideChangedLines: 0, preexisting: 0, preexistingByCheck: {}, changedLines, report: null, gateErrors: [], controlFilesChanged: controlFiles(diff), hints: [], covered: [] };
     }
     // The team's compiled checks run before the deep review, so it is told what they found and which lessons they covered.
     const compiled = compiledChecksOn(input.cwd, changedLines, input.config);
     const deep = input.deep ? { ...input.deep, focusLines: changedLinesByFile(changedLines), removedLines: removedByFile(diff), diff, settled: settledChecks(compiled.failures), covered: compiled.covered } : undefined;
     // The team's `commands:` run at push (toolchain.ts), where a failure blocks; here they would only cost time.
     const report = await new GateRunner({ ...input.config, commands: {} }).run(input.cwd, await normalizeScopePatterns(input.cwd, targets), deep);
-    const { preexisting, baseUnknown } = await dropPreexisting(input, report, targets);
+    const { preexisting, byCheck: preexistingByCheck = {}, baseUnknown } = await dropPreexisting(input, report, targets);
     if (input.diffTests && deep)
         report.failures.push(...await diffTestFailures(input.cwd, input.source, deep));
     // The review's own checks, each recorded in the summary beside the gates, so a report says everything that ran.
@@ -96,6 +96,7 @@ export async function reviewChange(input) {
         unlocated: split.unlocated,
         excludedOutsideChangedLines: split.outside,
         preexisting,
+        preexistingByCheck,
         ...(baseUnknown ? { baseUnknown } : {}),
         changedLines,
         report,
@@ -108,6 +109,21 @@ export async function reviewChange(input) {
         ...(checkedGoal ? { goal: checkedGoal } : {}),
     };
 }
+/**
+ * A check that failed only on what the base already had passes for this change: its summary reads PASS, and the
+ * count, by check, says what it left out. A check with a finding the change introduced keeps FAIL.
+ */
+function passOnlyPreexisting(report, preexisting) {
+    const byCheck = {};
+    const check = (f) => gateOf(f) ?? f.id;
+    for (const f of preexisting)
+        byCheck[check(f)] = (byCheck[check(f)] ?? 0) + 1;
+    const remaining = new Set(report.failures.map(check));
+    for (const id of Object.keys(byCheck))
+        if (report.summary[id] === 'FAIL' && !remaining.has(id))
+            report.summary[id] = 'PASS';
+    return byCheck;
+}
 /**
  * Drop the rules' findings the base already had; returns how many. Model findings stay: the model reviews only the change.
  * A diff given with no `--base` is compared with HEAD, which is right for uncommitted work. When HEAD already holds the
@@ -127,7 +143,7 @@ async function dropPreexisting(input, report, targets) {
         const { preexisting } = splitIntroduced(rules, await baseFindings(input.cwd, input.config, commit, targets));
         const old = new Set(preexisting);
         report.failures = report.failures.filter(f => !old.has(f));
-        return { preexisting: old.size };
+        return { preexisting: old.size, byCheck: passOnlyPreexisting(report, preexisting) };
     }
     catch {
         return { preexisting: 0 }; // the comparison is a courtesy; it never fails a review

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rigour-labs/core",
-  "version": "6.12.2-rc.4",
+  "version": "6.12.2-rc.6",
   "description": "Rigour's review engine: deterministic gates on changed lines, rules and lessons learned from your team's fixes, and per-check precision from what you fix versus dismiss, across TypeScript, JavaScript, Python, Go, Ruby and C#.",
   "engines": {
     "node": ">=22.13"
@@ -75,11 +75,11 @@
     "@anthropic-ai/sdk": "^0.132.1",
     "pg": "^8.16.3",
     "openai": "^5.23.2",
-    "@rigour-labs/brain-darwin-arm64": "6.12.2-rc.4",
-    "@rigour-labs/brain-linux-x64": "6.12.2-rc.4",
-    "@rigour-labs/brain-linux-arm64": "6.12.2-rc.4",
-    "@rigour-labs/brain-win-x64": "6.12.2-rc.4",
-    "@rigour-labs/brain-darwin-x64": "6.12.2-rc.4"
+    "@rigour-labs/brain-darwin-arm64": "6.12.2-rc.6",
+    "@rigour-labs/brain-darwin-x64": "6.12.2-rc.6",
+    "@rigour-labs/brain-linux-arm64": "6.12.2-rc.6",
+    "@rigour-labs/brain-linux-x64": "6.12.2-rc.6",
+    "@rigour-labs/brain-win-x64": "6.12.2-rc.6"
   },
   "devDependencies": {
     "@types/fs-extra": "^11.0.4",