@rigour-labs/core 6.12.2-rc.3 → 6.12.2-rc.5

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/typed/redundancy.js

@@ -284,24 +284,51 @@ function redundancyFailures(typed, changedLines, config) {
         }
         return [];
     };
+    // The parts of `target` that receive T's values inside `value`, found by walking both the same way: arrays, union
+    // members of the value, and same-named properties (`R[]` receiving `{ …, p: T }[]` gives the type of `R.p`).
+    const receiving = (t, value, target, depth = 0) => {
+        const to = checker.getNonNullableType(target);
+        if (value.symbol === t.sym || value.aliasSymbol === t.sym)
+            return mentionsType(t, to) ? [] : [to];
+        if (depth > MENTION_DEPTH)
+            return [];
+        if (value.isUnion())
+            return value.types.flatMap(v => receiving(t, v, target, depth + 1));
+        if (checker.isArrayType(value))
+            return checker.isArrayType(to) ? receiving(t, checker.getTypeArguments(value)[0], checker.getTypeArguments(to)[0], depth + 1) : [];
+        if (!(value.flags & ts.TypeFlags.Object))
+            return [];
+        return checker.getPropertiesOfType(value).flatMap(p => {
+            const into = checker.getPropertyOfType(to, p.name);
+            return into ? receiving(t, checker.getTypeOfSymbol(p), checker.getTypeOfSymbol(into), depth + 1) : [];
+        });
+    };
+    // Where T's values go: the declared types they travel as (`into`), and the types of the places that receive them
+    // (`receivers`: a same-shape inline type, a parameter's type), whose members are T's members under another type.
     const flowMemo = new Map();
-    const flowsInto = (t) => {
+    const flowsOf = (t) => {
         const cached = flowMemo.get(t.sym);
         if (cached)
             return cached;
         const into = new Set();
+        const receivers = new Set();
         for (const sf of typed.appSources) {
             walk(sf, node => {
                 if (!ts.isExpression(node) || !isFlowSite(node) || !mentionsType(t, checker.getTypeAtLocation(node)))
                     return;
+                const target = checker.getContextualType(node);
+                if (target && !(target.flags & (ts.TypeFlags.Any | ts.TypeFlags.Unknown)) && !mentionsType(t, target))
+                    for (const r of receiving(t, checker.getTypeAtLocation(node), target))
+                        receivers.add(r);
                 for (const d of namedAt(node, t))
                     into.add(d);
             });
         }
-        const found = [...into];
+        const found = { into: [...into], receivers: [...receivers] };
         flowMemo.set(t.sym, found);
         return found;
     };
+    const flowsInto = (t) => flowsOf(t).into;
     // T leaves the program where its own values do, or where a type it travels as does.
     const leaves = (t, seen = new Set([t.sym])) => {
         const direct = escapes(t);
@@ -371,8 +398,27 @@ function redundancyFailures(typed, changedLines, config) {
         if (!sym)
             return 'no such property';
         const declaration = sym.declarations?.[0];
-        const isOurs = (s) => !!s && (s === sym || !!s.declarations?.some(d => d === declaration));
-        const ofType = (expr) => mentionsType(t, checker.getTypeAtLocation(expr));
+        const ownRead = (s) => !!s && (s === sym || !!s.declarations?.some(d => d === declaration));
+        const ownType = (expr) => mentionsType(t, checker.getTypeAtLocation(expr));
+        let found = scanReads(name, ownRead, ownType);
+        if (found)
+            return found;
+        // A value of T received as another type (`p?: { x: string }` holding a T) is read through that type's member of the same name.
+        const { receivers } = flowsOf(t);
+        const members = new Set(receivers.map(r => checker.getPropertyOfType(r, name)).filter((m) => !!m));
+        if (members.size) {
+            const memberDecls = new Set([...members].flatMap(m => m.declarations ?? []));
+            const viaRead = (s) => !!s && (members.has(s) || !!s.declarations?.some(d => memberDecls.has(d)));
+            const viaType = (expr) => receivers.includes(checker.getNonNullableType(checker.getTypeAtLocation(expr)));
+            found = scanReads(name, viaRead, viaType);
+            if (found)
+                return found;
+        }
+        const text = textReads(t, name);
+        return text ? `${text.file} (by name)` : undefined;
+    };
+    // A read of `name` in a non-test file: an access whose symbol `isOurs` accepts, or a destructuring or `['name']` of a value `ofType` accepts.
+    const scanReads = (name, isOurs, ofType) => {
         for (const sf of typed.appSources) {
             if (!sf.text.includes(name) && !sf.text.includes('...'))
                 continue;
@@ -390,8 +436,7 @@ function redundancyFailures(typed, changedLines, config) {
             if (read)
                 return at(read);
         }
-        const text = textReads(t, name);
-        return text ? `${text.file} (by name)` : undefined;
+        return undefined;
     };
     for (const t of declaredTypes) {
         const hosts = hostsOf(t);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rigour-labs/core",
-  "version": "6.12.2-rc.3",
+  "version": "6.12.2-rc.5",
   "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.3",
-    "@rigour-labs/brain-linux-arm64": "6.12.2-rc.3",
-    "@rigour-labs/brain-darwin-x64": "6.12.2-rc.3",
-    "@rigour-labs/brain-win-x64": "6.12.2-rc.3",
-    "@rigour-labs/brain-linux-x64": "6.12.2-rc.3"
+    "@rigour-labs/brain-darwin-x64": "6.12.2-rc.5",
+    "@rigour-labs/brain-linux-arm64": "6.12.2-rc.5",
+    "@rigour-labs/brain-win-x64": "6.12.2-rc.5",
+    "@rigour-labs/brain-linux-x64": "6.12.2-rc.5",
+    "@rigour-labs/brain-darwin-arm64": "6.12.2-rc.5"
   },
   "devDependencies": {
     "@types/fs-extra": "^11.0.4",