@rigour-labs/core 6.5.1 → 6.5.2

package/dist/deep/fact-extractor.js

@@ -6,6 +6,7 @@
 import fs from 'fs-extra';
 import path from 'path';
 import { globby } from 'globby';
+import { directoriesAsGlobs, withDirectoryForms } from '../utils/glob-paths.js';
 const ANALYZABLE_EXTENSION = /\.(ts|js|tsx|jsx|py|go|rs|cs|java|rb|kt)$/i;
 /**
  * Lightweight regex-based fact extraction.
@@ -20,7 +21,7 @@ export async function extractFacts(cwd, ignore, scope) {
         '**/.git/**', '**/vendor/**', '**/__pycache__/**',
         '**/*.min.js', '**/*.bundle.js',
     ];
-    const matched = await globby(patterns, { cwd, ignore: ignorePatterns, followSymbolicLinks: false });
+    const matched = await globby(directoriesAsGlobs(cwd, patterns), { cwd, ignore: withDirectoryForms(ignorePatterns), expandDirectories: false, followSymbolicLinks: false });
     const files = matched.filter(f => ANALYZABLE_EXTENSION.test(f));
     const allFacts = [];
     for (const file of files) {

package/dist/deep/fact-extractor.test.js

@@ -3,7 +3,8 @@ import { describe, it, expect, vi, beforeEach } from 'vitest';
 // But we need to test extraction logic directly, so we also test via the public API
 const mockGlobby = vi.hoisted(() => vi.fn());
 const mockReadFile = vi.hoisted(() => vi.fn());
-vi.mock('globby', () => ({
+vi.mock('globby', async (importOriginal) => ({
+    isDynamicPattern: (await importOriginal()).isDynamicPattern,
     globby: mockGlobby,
 }));
 vi.mock('fs-extra', () => ({

package/dist/gates/ast.js

@@ -5,6 +5,7 @@ import { Gate } from './base.js';
 import { TypeScriptHandler } from './ast-handlers/typescript.js';
 import { PythonHandler } from './ast-handlers/python.js';
 import { UniversalASTHandler } from './ast-handlers/universal.js';
+import { directoriesAsGlobs, withDirectoryForms } from '../utils/glob-paths.js';
 export class ASTGate extends Gate {
     config;
     handlers = [];
@@ -35,9 +36,10 @@ export class ASTGate extends Gate {
         const ignore = [...new Set([...(context.ignore || []), ...defaultIgnore])].map(p => p.replace(/\\/g, '/'));
         const normalizedCwd = context.cwd.replace(/\\/g, '/');
         // Find all supported files
-        const files = await globby(patterns, {
+        const files = await globby(directoriesAsGlobs(normalizedCwd, patterns), {
             cwd: normalizedCwd,
-            ignore: ignore,
+            ignore: withDirectoryForms(ignore),
+            expandDirectories: false,
         });
         // Process files concurrently in batches for performance
         const CONCURRENCY = 16;

package/dist/gates/coverage.js

@@ -3,6 +3,7 @@ import path from 'path';
 import readline from 'node:readline';
 import { Gate } from './base.js';
 import { globby } from 'globby';
+import { withDirectoryForms } from '../utils/glob-paths.js';
 export class CoverageGate extends Gate {
     config;
     constructor(config) {
@@ -62,7 +63,8 @@ export class CoverageGate extends Gate {
             followSymbolicLinks: false,
             onlyFiles: true,
             deep: 8,
-            ignore: [...new Set([
+            expandDirectories: false,
+            ignore: withDirectoryForms([...new Set([
                     ...(context.ignore || []),
                     '**/node_modules/**',
                     '**/.git/**',
@@ -75,7 +77,7 @@ export class CoverageGate extends Gate {
                     '**/vendor/**',
                     '**/.venv/**',
                     '**/venv/**',
-                ])],
+                ])]),
         });
         if (reports.length === 0)
             return null;

package/dist/pattern-index/indexer.js

@@ -17,6 +17,7 @@ import { generateEmbedding } from './embeddings.js';
 import { hashContent } from './indexer-helpers.js';
 import { extractGoPatterns, extractRustPatterns, extractJVMStylePatterns, extractPythonPatterns, extractGenericCPatterns, } from './indexer-lang.js';
 import { nodeToPattern } from './indexer-ts.js';
+import { directoriesAsGlobs, withDirectoryForms } from '../utils/glob-paths.js';
 // ---------------------------------------------------------------------------
 // Configuration
 // ---------------------------------------------------------------------------
@@ -239,10 +240,11 @@ export class PatternIndexer {
         if (!this.config.indexTests) {
             exclude.push('**/*.test.*', '**/*.spec.*', '**/__tests__/**');
         }
-        return globby(patterns, {
+        return globby(directoriesAsGlobs(this.rootDir, patterns), {
             cwd: this.rootDir,
             absolute: true,
-            ignore: exclude,
+            ignore: withDirectoryForms(exclude),
+            expandDirectories: false,
             gitignore: true,
         });
     }

package/dist/review/review.d.ts

@@ -29,6 +29,8 @@ export interface ReviewResult {
     changedLines: Record<string, Set<number>>;
     report: Report | null;
     deepError?: string;
+    /** Gates that crashed instead of running; a proven one makes the result ERROR. */
+    gateErrors: string[];
 }
 export interface ReviewFinding {
     id: string;

package/dist/review/review.js

@@ -4,7 +4,8 @@
  *
  * Runs the configured gates on the files a change touches and keeps what
  * belongs to the change (see changed-lines.ts). A deep run that was asked for
- * but could not analyze anything makes the result ERROR, never a clean PASS.
+ * but could not analyze anything makes the result ERROR, never a clean PASS,
+ * and so does a proven gate that crashed (a heuristic one is only listed).
  */
 import { GateRunner } from '../gates/runner.js';
 import { changedLinesByFile, parseDiff, removedByFile } from '../utils/diff.js';
@@ -13,7 +14,7 @@ import { deepAnalysisError } from '../utils/deep-status.js';
 import { splitByChangedLines } from './changed-lines.js';
 import { changedFunctionSpans } from './changed-function-spans.js';
 import { withoutGenerated } from './generated-files.js';
-import { findingKey, quietSplit } from './quiet.js';
+import { findingKey, isProven, quietSplit } from './quiet.js';
 import { diffFromGit } from './git-diff.js';
 import { diffTestFailures } from './diff-test-findings.js';
 export async function reviewChange(input) {
@@ -21,7 +22,7 @@ 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: [], dismissed: 0, dismissedByGate: {}, unlocated: 0, excludedOutsideChangedLines: 0, changedLines, report: null };
+        return { status: 'PASS', findings: [], fileFindings: [], contextFindings: [], advisory: [], dismissed: 0, dismissedByGate: {}, unlocated: 0, excludedOutsideChangedLines: 0, changedLines, report: null, gateErrors: [] };
     }
     const deep = input.deep ? { ...input.deep, focusLines: changedLinesByFile(changedLines), removedLines: removedByFile(diff), diff } : undefined;
     const report = await new GateRunner(input.config).run(input.cwd, await normalizeScopePatterns(input.cwd, targets), deep);
@@ -30,8 +31,10 @@ export async function reviewChange(input) {
     const split = splitByChangedLines(report.failures, changedLines, deep ? changedFunctionSpans(input.cwd, changedLines) : {});
     const deepError = deepAnalysisError(report);
     const quiet = quietSplit(input.cwd, split.findings, input.config.review?.include_heuristics);
+    const gateErrors = crashedGates(report);
+    const provenCrashed = gateErrors.some(id => isProven({ id }));
     return {
-        status: deepError ? 'ERROR' : quiet.speaking.length > 0 ? 'FAIL' : 'PASS',
+        status: deepError || provenCrashed ? 'ERROR' : quiet.speaking.length > 0 ? 'FAIL' : 'PASS',
         findings: quiet.speaking,
         advisory: quiet.advisory,
         dismissed: quiet.dismissed,
@@ -42,9 +45,13 @@ export async function reviewChange(input) {
         excludedOutsideChangedLines: split.outside,
         changedLines,
         report,
+        gateErrors,
         ...(deepError ? { deepError } : {}),
     };
 }
+function crashedGates(report) {
+    return Object.entries(report.summary).filter(([, status]) => status === 'ERROR').map(([id]) => id);
+}
 /** The JSON shape of a finding, shared by the CLI's --json and the MCP tool. */
 export function toReviewFinding(failure) {
     return {

package/dist/review/review.test.js

@@ -2,7 +2,8 @@ import { execFileSync } from 'child_process';
 import fs from 'fs';
 import os from 'os';
 import path from 'path';
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { GateRunner } from '../gates/runner.js';
 import { ConfigSchema } from '../types/index.js';
 import { parseDiff } from '../utils/diff.js';
 import { splitByChangedLines } from './changed-lines.js';
@@ -102,6 +103,29 @@ describe('git-backed review', () => {
         expect(semantic.map(f => [f.files?.[0], f.line])).toEqual([['src/notify.ts', 2]]);
         expect(toReviewFinding(semantic[0])).toMatchObject({ id: 'semantic-bugs', file: 'src/notify.ts', line: 2, severity: 'high' });
     });
+    it('runs every gate in a git worktree, where .git is a file', async () => {
+        write('src/a.ts', 'export const a = 1;\n');
+        git('add', '-A');
+        git('commit', '-qm', 'init');
+        const worktree = path.join(repo, 'wt');
+        git('worktree', 'add', '-q', worktree);
+        fs.writeFileSync(path.join(worktree, 'src/a.ts'), 'export const a = 1;\nexport const b = 2;\n');
+        const config = ConfigSchema.parse({ version: 1, ignore: ['.git/**', 'wt/**'] });
+        const result = await reviewChange({ cwd: worktree, config });
+        expect(result.gateErrors).toEqual([]);
+        expect(result.status).not.toBe('ERROR');
+    });
+    it('is ERROR when a proven gate crashed, and only lists a crashed heuristic gate', async () => {
+        write('src/a.ts', 'export const a = 1;\n');
+        const config = ConfigSchema.parse({ version: 1 });
+        const crash = (summary) => vi.spyOn(GateRunner.prototype, 'run').mockResolvedValueOnce({ status: 'FAIL', summary, failures: [], stats: { duration_ms: 0 } });
+        crash({ 'hallucinated-imports': 'ERROR' });
+        const proven = await reviewChange({ cwd: repo, config });
+        expect([proven.status, proven.gateErrors]).toEqual(['ERROR', ['hallucinated-imports']]);
+        crash({ 'style-drift': 'ERROR', 'semantic-bugs': 'PASS' });
+        const heuristic = await reviewChange({ cwd: repo, config });
+        expect([heuristic.status, heuristic.gateErrors]).toEqual(['PASS', ['style-drift']]);
+    });
     it('passes when nothing changed', async () => {
         write('src/a.ts', 'export const a = 1;\n');
         git('add', '-A');

package/dist/utils/glob-paths.d.ts

@@ -0,0 +1,4 @@
+/** Ignore entries: a plain path also ignores everything under it. Matched only, never listed. */
+export declare function withDirectoryForms(patterns: string[]): string[];
+/** Search patterns: a plain path that is a directory becomes `dir/**`; files and globs stay. */
+export declare function directoriesAsGlobs(cwd: string, patterns: string[]): string[];

package/dist/utils/glob-paths.js

@@ -0,0 +1,26 @@
+import fs from 'fs';
+import path from 'path';
+import { isDynamicPattern } from 'globby';
+/*
+ * globby's default directory expansion stats every pattern and ignore entry,
+ * and throws ENOTDIR when one runs through a file: `.git/**` in a git
+ * worktree, where `.git` is a file. Rigour turns it off
+ * (`expandDirectories: false`) and expands plain paths itself, as before:
+ * a directory `legacy` also means `legacy/**`.
+ */
+/** Ignore entries: a plain path also ignores everything under it. Matched only, never listed. */
+export function withDirectoryForms(patterns) {
+    return patterns.flatMap(pattern => isDynamicPattern(pattern) ? [pattern] : [pattern, `${pattern.replace(/\/+$/, '')}/**`]);
+}
+/** Search patterns: a plain path that is a directory becomes `dir/**`; files and globs stay. */
+export function directoriesAsGlobs(cwd, patterns) {
+    return patterns.map(pattern => !isDynamicPattern(pattern) && isDirectory(path.resolve(cwd, pattern)) ? `${pattern.replace(/\/+$/, '')}/**` : pattern);
+}
+function isDirectory(target) {
+    try {
+        return fs.statSync(target).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}

package/dist/utils/glob-paths.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utils/glob-paths.test.js

@@ -0,0 +1,40 @@
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { FileScanner } from './scanner.js';
+import { directoriesAsGlobs, withDirectoryForms } from './glob-paths.js';
+let root;
+beforeEach(() => {
+    root = fs.mkdtempSync(path.join(os.tmpdir(), 'glob-paths-'));
+    fs.mkdirSync(path.join(root, 'src'));
+    fs.mkdirSync(path.join(root, 'legacy'));
+    fs.writeFileSync(path.join(root, 'src', 'a.ts'), 'export const a = 1;\n');
+    fs.writeFileSync(path.join(root, 'legacy', 'old.ts'), 'export const b = 2;\n');
+});
+afterEach(() => fs.rmSync(root, { recursive: true, force: true }));
+describe('withDirectoryForms', () => {
+    it('adds the directory form to plain paths and leaves globs alone', () => {
+        expect(withDirectoryForms(['legacy', 'build/', '.git/**', '**/*.min.js'])).toEqual(['legacy', 'legacy/**', 'build/', 'build/**', '.git/**', '**/*.min.js']);
+    });
+});
+describe('directoriesAsGlobs', () => {
+    it('turns a directory into dir/** and leaves files, missing paths and globs alone', () => {
+        expect(directoriesAsGlobs(root, ['src', 'src/a.ts', 'missing', '**/*.ts'])).toEqual(['src/**', 'src/a.ts', 'missing', '**/*.ts']);
+    });
+});
+describe('FileScanner in a git worktree', () => {
+    it('scans when .git is a file and the config ignores .git/**', async () => {
+        fs.writeFileSync(path.join(root, '.git'), 'gitdir: /elsewhere/.git/worktrees/x\n');
+        const files = await FileScanner.findFiles({ cwd: root, patterns: ['**/*.ts'], ignore: ['.git/**'] });
+        expect(files.sort()).toEqual(['legacy/old.ts', 'src/a.ts']);
+    });
+    it('finds a file or a whole directory named by a plain path', async () => {
+        expect(await FileScanner.findFiles({ cwd: root, patterns: ['src/a.ts'] })).toEqual(['src/a.ts']);
+        expect(await FileScanner.findFiles({ cwd: root, patterns: ['legacy'] })).toEqual(['legacy/old.ts']);
+    });
+    it('still ignores a whole directory named by a plain path', async () => {
+        const files = await FileScanner.findFiles({ cwd: root, patterns: ['**/*.ts'], ignore: ['legacy'] });
+        expect(files).toEqual(['src/a.ts']);
+    });
+});

package/dist/utils/scanner.js

@@ -1,6 +1,7 @@
 import { globby } from 'globby';
 import fs from 'fs-extra';
 import path from 'path';
+import { directoriesAsGlobs, withDirectoryForms } from './glob-paths.js';
 /**
  * Glob patterns use `/` as the separator and `\` as the escape character.
  * Only on Windows can a backslash be a path separator, and even there one
@@ -33,9 +34,10 @@ export class FileScanner {
         const userIgnore = options.ignore || [];
         const ignore = [...new Set([...this.DEFAULT_IGNORE, ...userIgnore])].map(toGlobSeparators);
         const normalizedCwd = options.cwd.replace(/\\/g, '/');
-        return globby(patterns, {
+        return globby(directoriesAsGlobs(normalizedCwd, patterns), {
             cwd: normalizedCwd,
-            ignore: ignore,
+            ignore: withDirectoryForms(ignore),
+            expandDirectories: false,
         });
     }
     /**

package/dist/utils/scanner.test.js

@@ -1,7 +1,8 @@
 import { describe, it, expect, vi } from 'vitest';
 import { FileScanner } from './scanner.js';
 import { globby } from 'globby';
-vi.mock('globby', () => ({
+vi.mock('globby', async (importOriginal) => ({
+    isDynamicPattern: (await importOriginal()).isDynamicPattern,
     globby: vi.fn(),
 }));
 describe('FileScanner', () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rigour-labs/core",
-  "version": "6.5.1",
+  "version": "6.5.2",
   "description": "AI-native quality gate engine with local Bayesian learning. AST analysis, drift detection, Fix Packet generation, and agent self-healing across TypeScript, JavaScript, Python, Go, Ruby, and C#.",
   "engines": {
     "node": ">=22"
@@ -70,11 +70,11 @@
     "pg": "^8.16.3",
     "sqlite3": "^5.1.7",
     "openai": "^4.104.0",
-    "@rigour-labs/brain-darwin-arm64": "6.5.1",
-    "@rigour-labs/brain-linux-arm64": "6.5.1",
-    "@rigour-labs/brain-darwin-x64": "6.5.1",
-    "@rigour-labs/brain-linux-x64": "6.5.1",
-    "@rigour-labs/brain-win-x64": "6.5.1"
+    "@rigour-labs/brain-darwin-arm64": "6.5.2",
+    "@rigour-labs/brain-linux-arm64": "6.5.2",
+    "@rigour-labs/brain-darwin-x64": "6.5.2",
+    "@rigour-labs/brain-win-x64": "6.5.2",
+    "@rigour-labs/brain-linux-x64": "6.5.2"
   },
   "devDependencies": {
     "@types/fs-extra": "^11.0.4",