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

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