@rigour-labs/core 6.11.1-rc.1 → 6.11.1-rc.2

package/dist/gates/logic-drift-git-base.d.ts

@@ -1,4 +1,7 @@
 export interface GitLogicBase {
+    /** The commit compared against. */
+    base: string;
+    /** Tracked files that differ from the base (added, copied, modified, renamed). Untracked files are not in it. */
     changedFiles: Set<string>;
     readAtBase: (file: string) => string | null;
 }
@@ -14,3 +17,9 @@ export interface BranchBase {
 export declare function branchBase(cwd: string): BranchBase | null;
 /** Use a fixed commit for the entire scan; never move the baseline on read. */
 export declare function resolveGitLogicBase(cwd: string): GitLogicBase | null;
+/** Files git does not track and does not ignore: what an agent just created. */
+export declare function untrackedFiles(cwd: string): string[];
+/** Every file committed at `commit`, repository-relative with `/`. */
+export declare function filesAtCommit(cwd: string, commit: string): string[];
+/** The contents of `files` at `commit`, read by one git process; a file missing there is left out. */
+export declare function readManyAtCommit(cwd: string, commit: string, files: string[]): Map<string, string>;

package/dist/gates/logic-drift-git-base.js

@@ -40,7 +40,43 @@ export function resolveGitLogicBase(cwd) {
     if (diff === null)
         return null;
     return {
+        base,
         changedFiles: new Set(diff.split('\0').filter(Boolean)),
         readAtBase: file => git(cwd, ['show', `${base}:${file}`]),
     };
 }
+/** Files git does not track and does not ignore: what an agent just created. */
+export function untrackedFiles(cwd) {
+    return (git(cwd, ['ls-files', '--others', '--exclude-standard', '-z']) ?? '').split('\0').filter(Boolean);
+}
+/** Every file committed at `commit`, repository-relative with `/`. */
+export function filesAtCommit(cwd, commit) {
+    return (git(cwd, ['ls-tree', '-r', '--name-only', '-z', commit]) ?? '').split('\0').filter(Boolean);
+}
+/** The contents of `files` at `commit`, read by one git process; a file missing there is left out. */
+export function readManyAtCommit(cwd, commit, files) {
+    const contents = new Map();
+    if (files.length === 0)
+        return contents;
+    let out;
+    try {
+        out = execFileSync('git', ['cat-file', '--batch'], { cwd, input: files.map(file => `${commit}:${file}`).join('\n') + '\n', stdio: ['pipe', 'pipe', 'ignore'], maxBuffer: 256 * 1024 * 1024 });
+    }
+    catch {
+        return contents;
+    }
+    let at = 0;
+    for (const file of files) {
+        const end = out.indexOf(0x0a, at);
+        if (end < 0)
+            break;
+        const header = out.subarray(at, end).toString('utf8').split(' ');
+        at = end + 1;
+        if (header[1] !== 'blob')
+            continue; // "<name> missing", or not a file
+        const size = Number(header[2]);
+        contents.set(file, out.subarray(at, at + size).toString('utf8'));
+        at += size + 1;
+    }
+    return contents;
+}

package/dist/gates/style-drift.d.ts

@@ -32,8 +32,16 @@ export declare class StyleDriftGate extends Gate {
     constructor(config?: StyleDriftConfig);
     protected get provenance(): Provenance;
     run(context: GateContext): Promise<Failure[]>;
+    /**
+     * The changed and untracked files, each against a fingerprint of its language's files committed at the base.
+     * On the base branch with a clean tree nothing differs, so nothing is compared.
+     */
+    private againstGitBase;
+    /** Each file against its own language's fingerprint. */
+    private compare;
     private computePerLanguageBaseline;
     private computeFingerprint;
+    private fingerprintOf;
     private emptyFingerprint;
     private analyzeFile;
     private mergeIntoFingerprint;

package/dist/gates/style-drift.js

@@ -25,6 +25,7 @@ import { Logger } from '../utils/logger.js';
 import { languageAdapters } from './language-adapters/index.js';
 import { extractComparableJsNames } from './js-style-context.js';
 import { isScoped } from '../utils/scope.js';
+import { filesAtCommit, isGitWorktree, readManyAtCommit, resolveGitLogicBase, untrackedFiles } from './logic-drift-git-base.js';
 import { TRY_CATCH_PATTERN, CATCH_PATTERN, RESULT_TYPE_PATTERN, NAMED_IMPORT_PATTERN, WILDCARD_IMPORT_PATTERN, SIDE_EFFECT_IMPORT_PATTERN, DEFAULT_IMPORT_PATTERN, countQuotes, } from './style-drift-rules.js';
 import fs from 'fs-extra';
 import path from 'path';
@@ -43,16 +44,26 @@ export class StyleDriftGate extends Gate {
     async run(context) {
         if (!this.config.enabled)
             return [];
-        const failures = [];
         const baselinePath = path.join(context.cwd, this.config.baseline_path);
         // Find source files
+        const ignore = [...(context.ignore || []), '**/node_modules/**', '**/dist/**', '**/*.test.*', '**/*.spec.*', '**/*.d.ts'];
         const files = await FileScanner.findFiles({
             cwd: context.cwd,
             patterns: context.patterns || languageAdapters.getScanPatterns(),
-            ignore: [...(context.ignore || []), '**/node_modules/**', '**/dist/**', '**/*.test.*', '**/*.spec.*', '**/*.d.ts'],
+            ignore,
         });
         if (files.length === 0)
             return [];
+        // In a git checkout the project's style is the code committed at the base, read fresh on every run, and
+        // only the files that differ from it are compared. Nothing is cached, so no earlier run on a dirty tree
+        // can change a verdict, and a .rigour/style-baseline.json left by an older version is never read.
+        const gitBase = resolveGitLogicBase(context.cwd);
+        if (!gitBase && isGitWorktree(context.cwd)) {
+            Logger.info('Style Drift: no main reference available; comparison unavailable');
+            return [];
+        }
+        if (gitBase)
+            return this.againstGitBase(context, files, ignore, gitBase);
         // Group files by language
         const filesByLang = new Map();
         for (const file of files) {
@@ -94,6 +105,38 @@ export class StyleDriftGate extends Gate {
             return []; // No failures on first scan
         }
         // Subsequent scan: compare each file against its own language's baseline
+        return this.compare(context, files, baseline);
+    }
+    /**
+     * The changed and untracked files, each against a fingerprint of its language's files committed at the base.
+     * On the base branch with a clean tree nothing differs, so nothing is compared.
+     */
+    async againstGitBase(context, files, ignore, gitBase) {
+        const changed = new Set([...gitBase.changedFiles, ...untrackedFiles(context.cwd)]);
+        const compared = files.filter(file => changed.has(file));
+        if (compared.length === 0)
+            return [];
+        const languages = new Set(compared.map(file => languageAdapters.getAdapter(file)?.id));
+        const sampled = new Map();
+        for (const file of FileScanner.filterPaths(filesAtCommit(context.cwd, gitBase.base), { patterns: languageAdapters.getScanPatterns(), ignore })) {
+            const id = languageAdapters.getAdapter(file)?.id;
+            if (!id || !languages.has(id))
+                continue;
+            const list = sampled.get(id) ?? [];
+            if (list.length < this.config.sample_size)
+                list.push(file);
+            sampled.set(id, list);
+        }
+        const atBase = readManyAtCommit(context.cwd, gitBase.base, [...sampled.values()].flat());
+        const baseline = { languages: {}, createdAt: '', version: 3 };
+        for (const [id, list] of sampled) {
+            baseline.languages[id] = this.fingerprintOf(new Map(list.flatMap(file => atBase.has(file) ? [[file, atBase.get(file)]] : [])));
+        }
+        return this.compare(context, compared, baseline);
+    }
+    /** Each file against its own language's fingerprint. */
+    async compare(context, files, baseline) {
+        const failures = [];
         const contents = await FileScanner.readFiles(context.cwd, files, context.fileCache);
         for (const [file, content] of contents) {
             const adapter = languageAdapters.getAdapter(file);
@@ -132,8 +175,10 @@ export class StyleDriftGate extends Gate {
         return baseline;
     }
     async computeFingerprint(context, files) {
+        return this.fingerprintOf(await FileScanner.readFiles(context.cwd, files, context.fileCache));
+    }
+    fingerprintOf(contents) {
         const fingerprint = this.emptyFingerprint();
-        const contents = await FileScanner.readFiles(context.cwd, files, context.fileCache);
         for (const [file, content] of contents) {
             const fileAnalysis = this.analyzeFile(content, file);
             this.mergeIntoFingerprint(fingerprint, fileAnalysis);

package/dist/utils/scanner.d.ts

@@ -8,6 +8,8 @@ export declare class FileScanner {
     private static DEFAULT_PATTERNS;
     private static DEFAULT_IGNORE;
     static findFiles(options: ScannerOptions): Promise<string[]>;
+    /** The selection findFiles makes, over paths listed elsewhere (a commit's files) instead of the disk. */
+    static filterPaths(paths: string[], options: Omit<ScannerOptions, 'cwd'>): string[];
     /**
      * Read file contents. When a FileSystemCache is provided, uses it for
      * shared caching across gates (avoids re-loading per gate).

package/dist/utils/scanner.js

@@ -1,4 +1,5 @@
 import { globby } from 'globby';
+import micromatch from 'micromatch';
 import fs from 'fs-extra';
 import path from 'path';
 import { directoriesAsGlobs, withDirectoryForms } from './glob-paths.js';
@@ -42,6 +43,12 @@ export class FileScanner {
         });
         return files.sort();
     }
+    /** The selection findFiles makes, over paths listed elsewhere (a commit's files) instead of the disk. */
+    static filterPaths(paths, options) {
+        const patterns = (options.patterns || this.DEFAULT_PATTERNS).map(toGlobSeparators);
+        const ignore = withDirectoryForms([...new Set([...this.DEFAULT_IGNORE, ...(options.ignore || [])])].map(toGlobSeparators));
+        return paths.filter(file => micromatch.isMatch(file, patterns, { ignore })).sort();
+    }
     /**
      * Read file contents. When a FileSystemCache is provided, uses it for
      * shared caching across gates (avoids re-loading per gate).

package/package.json

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