@rigour-labs/core 6.8.0 → 6.8.1

package/dist/gates/js-style-context.test.d.ts

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

package/dist/gates/js-style-context.test.js

@@ -1,35 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { extractComparableJsNames } from './js-style-context.js';
-describe('context-aware JS naming', () => {
-    it('excludes exported Next route methods only inside app route files', () => {
-        const code = `
-            export async function GET() { return Response.json({}); }
-            export const POST = async () => Response.json({});
-            function GET_HELPER() { return 1; }
-        `;
-        expect(extractComparableJsNames(code, 'src/app/api/items/route.ts').map(item => item.name))
-            .toEqual(['GET_HELPER']);
-        expect(extractComparableJsNames(code, 'src/lib/route.ts').map(item => item.name))
-            .toEqual(['GET', 'POST', 'GET_HELPER']);
-    });
-    it('excludes JSX-returning components but keeps ordinary PascalCase functions', () => {
-        const code = `
-            export function StepReview() { return <section />; }
-            const WizardField = () => <input />;
-            function ParseValue() { return 1; }
-        `;
-        expect(extractComparableJsNames(code, 'src/components/WizardField.tsx').map(item => item.name))
-            .toEqual(['ParseValue']);
-    });
-    it('excludes module constants but keeps unconventional local variables', () => {
-        const code = `
-            const EMAIL_TEMPLATE = 'hello';
-            function sendMessage() {
-                const LOCAL_VALUE = 1;
-                return LOCAL_VALUE;
-            }
-        `;
-        expect(extractComparableJsNames(code, 'src/lib/template.ts').map(item => item.name))
-            .toEqual(['sendMessage', 'LOCAL_VALUE']);
-    });
-});

package/dist/gates/logic-drift.test.d.ts

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

package/dist/gates/logic-drift.test.js

@@ -1,52 +0,0 @@
-import { execFileSync } from 'node:child_process';
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import * as fs from 'fs';
-import * as os from 'os';
-import * as path from 'path';
-import { LogicDriftGate } from './logic-drift.js';
-describe('LogicDriftGate Git baseline', () => {
-    let cwd;
-    const git = (...args) => execFileSync('git', args, { cwd, stdio: 'pipe' });
-    beforeEach(() => {
-        cwd = fs.mkdtempSync(path.join(os.tmpdir(), 'logic-drift-'));
-        git('init', '-q', '-b', 'main');
-        git('config', 'user.name', 'Rigour Test');
-        git('config', 'user.email', 'test@example.invalid');
-        fs.mkdirSync(path.join(cwd, 'src'));
-        fs.writeFileSync(path.join(cwd, 'src/rules.ts'), 'export function eligible(score: number) { return score >= 10; }\n');
-        git('add', '.');
-        git('commit', '-qm', 'base');
-    });
-    afterEach(() => { fs.rmSync(cwd, { recursive: true, force: true }); });
-    it('reports a branch mutation consistently and clears it after merge', async () => {
-        const gate = new LogicDriftGate();
-        expect(await gate.run({ cwd })).toEqual([]);
-        git('switch', '-q', '-c', 'feature');
-        fs.writeFileSync(path.join(cwd, 'src/rules.ts'), 'export function eligible(score: number) { return score > 10; }\n');
-        const first = await gate.run({ cwd });
-        const second = await gate.run({ cwd });
-        expect(first).toEqual(second);
-        expect(first).toHaveLength(1);
-        expect(first.some(finding => finding.details.includes("'>=' to '>'"))).toBe(true);
-        expect(fs.existsSync(path.join(cwd, '.rigour/logic-baseline.json'))).toBe(false);
-        git('add', '.');
-        git('commit', '-qm', 'change boundary');
-        git('switch', '-q', 'main');
-        git('merge', '-q', '--ff-only', 'feature');
-        expect(await gate.run({ cwd })).toEqual([]);
-    }, 30_000);
-    it('reports return and branch count changes only when opted in', async () => {
-        git('switch', '-q', '-c', 'feature');
-        fs.writeFileSync(path.join(cwd, 'src/rules.ts'), 'export function eligible(score: number) {\n  if (score < 0) return false;\n  if (score > 100) return false;\n  return score >= 10;\n}\n');
-        expect(await new LogicDriftGate().run({ cwd })).toEqual([]);
-        const opted = await new LogicDriftGate({ track_returns: true, track_branches: true }).run({ cwd });
-        expect(opted.map(f => f.title).sort()).toEqual(['Logic Drift: Branch Change', 'Logic Drift: Return Change']);
-    }, 30_000);
-    it('does not use a moving local snapshot when Git has no main reference', async () => {
-        git('switch', '-q', '-c', 'feature');
-        git('branch', '-D', 'main');
-        const gate = new LogicDriftGate();
-        expect(await gate.run({ cwd })).toEqual([]);
-        expect(fs.existsSync(path.join(cwd, '.rigour/logic-baseline.json'))).toBe(false);
-    });
-});

package/dist/gates/phantom-apis.test.d.ts

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

package/dist/gates/phantom-apis.test.js

@@ -1,396 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-const mockFindFiles = vi.hoisted(() => vi.fn());
-const mockReadFile = vi.hoisted(() => vi.fn());
-const mockPathExists = vi.hoisted(() => vi.fn());
-vi.mock('../utils/scanner.js', () => ({
-    FileScanner: { findFiles: mockFindFiles },
-}));
-vi.mock('fs-extra', () => ({
-    default: {
-        readFile: mockReadFile,
-        pathExists: mockPathExists,
-        pathExistsSync: vi.fn().mockReturnValue(false),
-        readFileSync: vi.fn().mockReturnValue(''),
-        readJson: vi.fn().mockResolvedValue(null),
-        readdirSync: vi.fn().mockReturnValue([]),
-    },
-}));
-import { PhantomApisGate } from './phantom-apis.js';
-describe('PhantomApisGate — Node.js', () => {
-    let gate;
-    beforeEach(() => {
-        gate = new PhantomApisGate();
-        vi.clearAllMocks();
-    });
-    it('should flag non-existent fs methods', async () => {
-        mockFindFiles.mockResolvedValue(['src/utils.ts']);
-        mockReadFile.mockResolvedValue(`
-import fs from 'fs';
-const data = fs.readFileAsync('test.txt');
-const result = fs.writeFilePromise('out.txt', data);
-        `);
-        const failures = await gate.run({ cwd: '/project' });
-        expect(failures).toHaveLength(1);
-        expect(failures[0].details).toContain('readFileAsync');
-        expect(failures[0].details).toContain('writeFilePromise');
-    });
-    it('should NOT flag real fs methods', async () => {
-        mockFindFiles.mockResolvedValue(['src/utils.ts']);
-        mockReadFile.mockResolvedValue(`
-import fs from 'fs';
-const data = fs.readFileSync('test.txt', 'utf-8');
-fs.writeFileSync('out.txt', data);
-fs.existsSync('/tmp');
-const stream = fs.createReadStream('big.txt');
-        `);
-        const failures = await gate.run({ cwd: '/project' });
-        expect(failures).toHaveLength(0);
-    });
-    it('should flag non-existent path methods', async () => {
-        mockFindFiles.mockResolvedValue(['src/paths.ts']);
-        mockReadFile.mockResolvedValue(`
-import path from 'path';
-const combined = path.combine('a', 'b');
-const exists = path.exists('/tmp');
-        `);
-        const failures = await gate.run({ cwd: '/project' });
-        expect(failures).toHaveLength(1);
-        expect(failures[0].details).toContain('combine');
-        expect(failures[0].details).toContain('exists');
-    });
-    it('should NOT flag a property that shares the module name', async () => {
-        mockFindFiles.mockResolvedValue(['src/generate.ts']);
-        mockReadFile.mockResolvedValue(`
-import * as path from 'node:path';
-const tag = proc.path.split('.')[0];
-const dir = path.dirname(file);
-        `);
-        const failures = await gate.run({ cwd: '/project' });
-        expect(failures).toHaveLength(0);
-    });
-    it('should NOT flag real path methods', async () => {
-        mockFindFiles.mockResolvedValue(['src/paths.ts']);
-        mockReadFile.mockResolvedValue(`
-import path from 'path';
-const p = path.join('a', 'b');
-const ext = path.extname('file.txt');
-const abs = path.resolve('.');
-        `);
-        const failures = await gate.run({ cwd: '/project' });
-        expect(failures).toHaveLength(0);
-    });
-    it('should flag non-existent crypto methods', async () => {
-        mockFindFiles.mockResolvedValue(['src/crypto.ts']);
-        mockReadFile.mockResolvedValue(`
-import crypto from 'crypto';
-const hash = crypto.generateHash('sha256', 'data');
-const key = crypto.createKey('aes-256');
-        `);
-        const failures = await gate.run({ cwd: '/project' });
-        expect(failures).toHaveLength(1);
-        expect(failures[0].details).toContain('generateHash');
-        expect(failures[0].details).toContain('createKey');
-    });
-    it('should NOT flag real crypto methods', async () => {
-        mockFindFiles.mockResolvedValue(['src/crypto.ts']);
-        mockReadFile.mockResolvedValue(`
-import crypto from 'crypto';
-const hash = crypto.createHash('sha256');
-const uuid = crypto.randomUUID();
-        `);
-        const failures = await gate.run({ cwd: '/project' });
-        expect(failures).toHaveLength(0);
-    });
-    it('should handle require() imports', async () => {
-        mockFindFiles.mockResolvedValue(['src/legacy.js']);
-        mockReadFile.mockResolvedValue(`
-const fs = require('fs');
-fs.readFileAsync('data.txt');
-        `);
-        const failures = await gate.run({ cwd: '/project' });
-        expect(failures).toHaveLength(1);
-        expect(failures[0].details).toContain('readFileAsync');
-    });
-    it('should handle node: protocol imports', async () => {
-        mockFindFiles.mockResolvedValue(['src/modern.ts']);
-        mockReadFile.mockResolvedValue(`
-import os from 'node:os';
-const info = os.cpuInfo();
-        `);
-        const failures = await gate.run({ cwd: '/project' });
-        expect(failures).toHaveLength(1);
-        expect(failures[0].details).toContain('cpuInfo');
-    });
-    it('should suggest closest real method', async () => {
-        mockFindFiles.mockResolvedValue(['src/typo.ts']);
-        mockReadFile.mockResolvedValue(`
-import fs from 'fs';
-fs.readFileSyn('data.txt');
-        `);
-        const failures = await gate.run({ cwd: '/project' });
-        expect(failures).toHaveLength(1);
-        expect(failures[0].details).toContain('readFileSync');
-    });
-    it('should ignore phantom method mentions inside comments', async () => {
-        mockFindFiles.mockResolvedValue(['src/docs.ts']);
-        mockReadFile.mockResolvedValue(`
-import fs from 'fs';
-// fs.readFileAsync('data.txt')
-/* path.combine('a', 'b') */
-/**
- * fs.writeFilePromise('out.txt')
- */
-const data = fs.readFileSync('real.txt', 'utf-8');
-        `);
-        const failures = await gate.run({ cwd: '/project' });
-        expect(failures).toHaveLength(0);
-    });
-    it('should not scan when disabled', async () => {
-        const disabled = new PhantomApisGate({ enabled: false });
-        const failures = await disabled.run({ cwd: '/project' });
-        expect(failures).toHaveLength(0);
-        expect(mockFindFiles).not.toHaveBeenCalled();
-    });
-});
-describe('PhantomApisGate — Python', () => {
-    let gate;
-    beforeEach(() => {
-        gate = new PhantomApisGate();
-        vi.clearAllMocks();
-    });
-    it('should flag non-existent os methods', async () => {
-        mockFindFiles.mockResolvedValue(['utils.py']);
-        mockReadFile.mockResolvedValue(`
-import os
-current = os.getCurrentDirectory()
-files = os.listFiles('.')
-        `);
-        const failures = await gate.run({ cwd: '/project' });
-        expect(failures).toHaveLength(1);
-        expect(failures[0].details).toContain('getCurrentDirectory');
-        expect(failures[0].details).toContain('listFiles');
-    });
-    it('should NOT flag real os methods', async () => {
-        mockFindFiles.mockResolvedValue(['utils.py']);
-        mockReadFile.mockResolvedValue(`
-import os
-current = os.getcwd()
-files = os.listdir('.')
-exists = os.path
-        `);
-        const failures = await gate.run({ cwd: '/project' });
-        expect(failures).toHaveLength(0);
-    });
-    it('should flag non-existent json methods', async () => {
-        mockFindFiles.mockResolvedValue(['parser.py']);
-        mockReadFile.mockResolvedValue(`
-import json
-data = json.parse('{"key": "value"}')
-result = json.stringify(data)
-        `);
-        const failures = await gate.run({ cwd: '/project' });
-        expect(failures).toHaveLength(1);
-        expect(failures[0].details).toContain('parse');
-        expect(failures[0].details).toContain('stringify');
-    });
-    it('should NOT flag real json methods', async () => {
-        mockFindFiles.mockResolvedValue(['parser.py']);
-        mockReadFile.mockResolvedValue(`
-import json
-data = json.loads('{"key": "value"}')
-output = json.dumps(data)
-        `);
-        const failures = await gate.run({ cwd: '/project' });
-        expect(failures).toHaveLength(0);
-    });
-    it('should handle aliased imports', async () => {
-        mockFindFiles.mockResolvedValue(['utils.py']);
-        mockReadFile.mockResolvedValue(`
-import os as operating_system
-result = operating_system.getCurrentDirectory()
-        `);
-        const failures = await gate.run({ cwd: '/project' });
-        expect(failures).toHaveLength(1);
-        expect(failures[0].details).toContain('getCurrentDirectory');
-    });
-    it('should flag non-existent subprocess methods', async () => {
-        mockFindFiles.mockResolvedValue(['runner.py']);
-        mockReadFile.mockResolvedValue(`
-import subprocess
-result = subprocess.execute(['ls', '-la'])
-        `);
-        const failures = await gate.run({ cwd: '/project' });
-        expect(failures).toHaveLength(1);
-        expect(failures[0].details).toContain('execute');
-    });
-});
-describe('PhantomApisGate — Go', () => {
-    let gate;
-    beforeEach(() => {
-        gate = new PhantomApisGate();
-        vi.clearAllMocks();
-    });
-    it('should flag Python-style Go method names', async () => {
-        mockFindFiles.mockResolvedValue(['main.go']);
-        mockReadFile.mockResolvedValue(`
-package main
-import "strings"
-func main() {
-    result := strings.includes("hello", "ell")
-}
-        `);
-        const failures = await gate.run({ cwd: '/project' });
-        expect(failures).toHaveLength(1);
-        expect(failures[0].details).toContain('includes');
-        expect(failures[0].details).toContain('strings.Contains');
-    });
-    it('should flag JS-style JSON methods in Go', async () => {
-        mockFindFiles.mockResolvedValue(['parser.go']);
-        mockReadFile.mockResolvedValue(`
-package main
-import "encoding/json"
-func parse() {
-    data := json.parse(raw)
-    out := json.stringify(data)
-}
-        `);
-        const failures = await gate.run({ cwd: '/project' });
-        expect(failures).toHaveLength(1);
-        expect(failures[0].details).toContain('parse');
-    });
-    it('should flag os.Exists in Go', async () => {
-        mockFindFiles.mockResolvedValue(['files.go']);
-        mockReadFile.mockResolvedValue(`
-package main
-import "os"
-func check() {
-    exists := os.Exists("/tmp/file")
-}
-        `);
-        const failures = await gate.run({ cwd: '/project' });
-        expect(failures).toHaveLength(1);
-        expect(failures[0].details).toContain('Exists');
-    });
-    it('should NOT flag real Go stdlib functions (os.ReadFile, fmt.Print, math.Max)', async () => {
-        mockFindFiles.mockResolvedValue(['main.go']);
-        mockReadFile.mockResolvedValue(`
-package main
-
-import (
-    "fmt"
-    "math"
-    "os"
-)
-
-func main() {
-    data, err := os.ReadFile("config.json")
-    if err != nil {
-        fmt.Printf("error: %v\n", err)
-        return
-    }
-    fmt.Println(string(data))
-    fmt.Print("done\n")
-    x := math.Max(1.5, 2.5)
-    fmt.Sprintf("max: %f", x)
-    fmt.Fprintf(os.Stderr, "log\n")
-}
-        `);
-        const failures = await gate.run({ cwd: '/project' });
-        expect(failures).toHaveLength(0);
-    });
-});
-describe('PhantomApisGate — C#', () => {
-    let gate;
-    beforeEach(() => {
-        gate = new PhantomApisGate();
-        vi.clearAllMocks();
-    });
-    it('should flag Java-style method casing in C#', async () => {
-        mockFindFiles.mockResolvedValue(['Program.cs']);
-        mockReadFile.mockResolvedValue(`
-using System;
-class Program {
-    void Main() {
-        string s = "hello";
-        int len = s.length;
-        bool eq = s.equals("world");
-        string str = s.toString();
-    }
-}
-        `);
-        const failures = await gate.run({ cwd: '/project' });
-        expect(failures.length).toBeGreaterThanOrEqual(1);
-        expect(failures[0].details).toMatch(/length|equals|toString/);
-    });
-    it('should flag Java collections in C#', async () => {
-        mockFindFiles.mockResolvedValue(['Service.cs']);
-        mockReadFile.mockResolvedValue(`
-using System.Collections.Generic;
-List<string> items = new ArrayList<string>();
-HashMap<string, int> map = new HashMap<string, int>();
-System.out.println("hello");
-        `);
-        const failures = await gate.run({ cwd: '/project' });
-        expect(failures.length).toBeGreaterThanOrEqual(1);
-    });
-});
-describe('PhantomApisGate — Java', () => {
-    let gate;
-    beforeEach(() => {
-        gate = new PhantomApisGate();
-        vi.clearAllMocks();
-    });
-    it('should flag JS/Python-style method names in Java', async () => {
-        mockFindFiles.mockResolvedValue(['Main.java']);
-        mockReadFile.mockResolvedValue(`
-import java.util.List;
-class Main {
-    void test() {
-        List<String> items = new ArrayList<>();
-        items.push("hello");
-        items.includes("test");
-    }
-}
-        `);
-        const failures = await gate.run({ cwd: '/project' });
-        expect(failures.length).toBeGreaterThanOrEqual(1);
-        expect(failures[0].details).toMatch(/push|includes/);
-    });
-    it('should flag new List() in Java', async () => {
-        mockFindFiles.mockResolvedValue(['Service.java']);
-        mockReadFile.mockResolvedValue(`
-import java.util.*;
-class Service {
-    List<String> items = new List<String>();
-    Map<String, Integer> map = new Map<String, Integer>();
-}
-        `);
-        const failures = await gate.run({ cwd: '/project' });
-        expect(failures.length).toBeGreaterThanOrEqual(1);
-    });
-    it('should NOT flag real Java methods (Deque.push, StringBuilder.append, stream().sorted(), List.reversed())', async () => {
-        mockFindFiles.mockResolvedValue(['RealJava.java']);
-        mockReadFile.mockResolvedValue(`
-import java.util.*;
-import java.util.stream.*;
-class RealJava {
-    void test() {
-        Deque<String> deque = new ArrayDeque<>();
-        deque.push("hello");
-
-        Stack<Integer> stack = new Stack<>();
-        stack.push(42);
-
-        StringBuilder sb = new StringBuilder();
-        sb.append("world");
-
-        List<Integer> nums = List.of(3, 1, 2);
-        List<Integer> sorted = nums.stream().sorted().collect(Collectors.toList());
-        List<Integer> rev = nums.reversed();
-    }
-}
-        `);
-        const failures = await gate.run({ cwd: '/project' });
-        expect(failures).toHaveLength(0);
-    });
-});

package/dist/gates/promise-safety.test.d.ts

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

package/dist/gates/promise-safety.test.js

@@ -1,34 +0,0 @@
-import fs from 'fs';
-import os from 'os';
-import path from 'path';
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import { PromiseSafetyGate } from './promise-safety.js';
-describe('PromiseSafetyGate unhandled .then', () => {
-    let cwd;
-    beforeEach(() => { cwd = fs.mkdtempSync(path.join(os.tmpdir(), 'promise-safety-')); });
-    afterEach(() => { fs.rmSync(cwd, { recursive: true, force: true }); });
-    async function thenFindings(code) {
-        fs.writeFileSync(path.join(cwd, 'session.ts'), code);
-        const failures = await new PromiseSafetyGate().run({ cwd });
-        return failures.filter(f => f.details.includes('unhandled-then')).length;
-    }
-    it('flags a .then chain with no .catch', async () => {
-        expect(await thenFindings('export function wake(p: Promise<number>) {\n  p.then(n => {\n    if (n > 1) log(n);\n  });\n}\ndeclare function log(n: number): void;\n')).toBe(1);
-    });
-    it('finds the .catch that closes a chain whose callback body has if and return statements', async () => {
-        const code = [
-            'export function wake(accepted: Promise<{ action: string }>) {',
-            '  void accepted',
-            '    .then(result => {',
-            "      if (result.action === 'wake') {",
-            '        return run();',
-            '      }',
-            '      return undefined;',
-            '    })',
-            '    .catch(() => {});',
-            '}',
-            'declare function run(): Promise<void>;',
-        ].join('\n');
-        expect(await thenFindings(code)).toBe(0);
-    });
-});

package/dist/gates/runner.test.d.ts

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

package/dist/gates/runner.test.js

@@ -1,77 +0,0 @@
-import fs from 'fs-extra';
-import os from 'os';
-import path from 'path';
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import { GateRunner } from './runner.js';
-import { DeepAnalysisGate } from './deep-analysis.js';
-function mockDeep(outcome, failures = []) {
-    vi.spyOn(DeepAnalysisGate.prototype, 'run').mockResolvedValue(failures);
-    vi.spyOn(DeepAnalysisGate.prototype, 'getOutcome').mockReturnValue({
-        status: 'ok', mode: 'facts', filesAnalyzed: 1, chunksTotal: 1, chunksFailed: 0, ...outcome,
-    });
-}
-describe('GateRunner deep stats execution mode', () => {
-    let testDir;
-    beforeEach(async () => {
-        testDir = await fs.mkdtemp(path.join(os.tmpdir(), 'rigour-runner-deep-'));
-        await fs.writeFile(path.join(testDir, 'index.ts'), 'export const ok = true;\n');
-    });
-    afterEach(async () => {
-        vi.restoreAllMocks();
-        await fs.remove(testDir);
-    });
-    function createRunner() {
-        return new GateRunner({
-            version: 1,
-            commands: {},
-            gates: {
-                max_file_lines: 500,
-                forbid_todos: true,
-                forbid_fixme: true,
-            },
-        });
-    }
-    it('reports local lite tier and the model the provider actually loaded', async () => {
-        mockDeep({ model: 'Qwen2.5-Coder-0.5B-Instruct (stock)', modelFallback: true });
-        const report = await createRunner().run(testDir, undefined, {
-            enabled: true, apiKey: 'sk-test', provider: 'local', pro: false,
-        });
-        expect(report.stats.deep?.tier).toBe('lite');
-        expect(report.stats.deep?.model).toBe('Qwen2.5-Coder-0.5B-Instruct (stock)');
-        expect(report.stats.deep?.model_fallback).toBe(true);
-        expect(report.stats.deep?.status).toBe('ok');
-        expect(report.summary['deep-analysis']).toBe('PASS');
-    });
-    it('reports local deep tier when provider=local and pro=true', async () => {
-        mockDeep({ model: 'Rigour-Deep-v5.0.0 (Qwen2.5-Coder-1.5B fine-tuned)', modelFallback: false });
-        const report = await createRunner().run(testDir, undefined, {
-            enabled: true, apiKey: 'sk-test', provider: 'local', pro: true,
-        });
-        expect(report.stats.deep?.tier).toBe('deep');
-        expect(report.stats.deep?.model).toBe('Rigour-Deep-v5.0.0 (Qwen2.5-Coder-1.5B fine-tuned)');
-    });
-    it('reports cloud tier/model for cloud providers', async () => {
-        mockDeep({ model: 'gpt-4.1-mini' });
-        const report = await createRunner().run(testDir, undefined, {
-            enabled: true, apiKey: 'sk-test', provider: 'openai', modelName: 'gpt-4.1-mini', pro: false,
-        });
-        expect(report.stats.deep?.tier).toBe('cloud');
-        expect(report.stats.deep?.model).toBe('gpt-4.1-mini');
-    });
-    it('reports a deep run that could not analyze anything as ERROR with a visible failure', async () => {
-        mockDeep({ status: 'error', chunksTotal: 3, chunksFailed: 3, error: 'All 3 inference call(s) failed.' });
-        const report = await createRunner().run(testDir, undefined, { enabled: true, pro: false });
-        expect(report.summary['deep-analysis']).toBe('ERROR');
-        expect(report.status).toBe('FAIL');
-        expect(report.stats.deep).toMatchObject({ status: 'error', chunks_total: 3, chunks_failed: 3, error: 'All 3 inference call(s) failed.' });
-        const failure = report.failures.find(f => f.id === 'deep-analysis');
-        expect(failure?.title).toBe('Deep analysis did not run');
-        expect(failure?.details).toContain('All 3 inference call(s) failed.');
-    });
-    it('keeps a partial run as PASS/FAIL by findings and records failed chunks', async () => {
-        mockDeep({ status: 'partial', chunksTotal: 4, chunksFailed: 1 });
-        const report = await createRunner().run(testDir, undefined, { enabled: true, pro: false });
-        expect(report.summary['deep-analysis']).toBe('PASS');
-        expect(report.stats.deep).toMatchObject({ status: 'partial', chunks_total: 4, chunks_failed: 1 });
-    });
-});

package/dist/gates/scoped-gates.test.d.ts

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

package/dist/gates/scoped-gates.test.js

@@ -1,52 +0,0 @@
-import fs from 'fs-extra';
-import os from 'os';
-import path from 'path';
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import { ContextGate } from './context.js';
-import { DependencyGate } from './dependency.js';
-import { LogicDriftGate } from './logic-drift.js';
-import { StyleDriftGate } from './style-drift.js';
-describe('gates on a scoped run', () => {
-    let cwd;
-    beforeEach(async () => { cwd = await fs.mkdtemp(path.join(os.tmpdir(), 'rigour-scoped-')); });
-    afterEach(async () => { await fs.remove(cwd); });
-    it('context-drift reports only findings that cite a file in scope', async () => {
-        await fs.outputFile(path.join(cwd, 'src/a.ts'), 'export const a = process.env.API_URL_PROD;\n');
-        await fs.outputFile(path.join(cwd, 'src/b.ts'), 'export const b = process.env.API_URL_STAGING;\n');
-        const gate = new ContextGate({ context: { enabled: true } });
-        const record = { anchors: [{ type: 'env', id: 'API_URL', confidence: 1 }] };
-        const unscoped = await gate.run({ cwd, record });
-        const scoped = await gate.run({ cwd, record, patterns: ['src/a.ts'] });
-        expect(unscoped.flatMap(f => f.files)).toEqual(expect.arrayContaining(['src/a.ts', 'src/b.ts']));
-        expect(scoped.length).toBeGreaterThan(0);
-        expect(scoped.every(f => f.files?.includes('src/a.ts'))).toBe(true);
-    });
-    it('dependency-guardian checks the manifest only when package.json is in scope', async () => {
-        await fs.outputJson(path.join(cwd, 'package.json'), { dependencies: { 'left-pad': '1.0.0' } });
-        await fs.outputFile(path.join(cwd, 'src/a.ts'), "import pad from 'left-pad';\n");
-        const gate = new DependencyGate({ gates: { dependencies: { forbid: ['left-pad'] } } });
-        expect(await gate.run({ cwd, patterns: ['src/a.ts'] })).toEqual([]);
-        const withManifest = await gate.run({ cwd, patterns: ['package.json'] });
-        expect(withManifest.some(f => f.title === 'Forbidden Dependency')).toBe(true);
-    });
-    it('logic-drift never creates or rewrites its baseline from a scoped run', async () => {
-        const baseline = path.join(cwd, '.rigour/logic-baseline.json');
-        await fs.outputFile(path.join(cwd, 'src/rules.ts'), 'export function eligible(score: number) { return score >= 10; }\n');
-        await fs.outputFile(path.join(cwd, 'src/other.ts'), 'export function other(n: number) { return n > 1; }\n');
-        const gate = new LogicDriftGate();
-        expect(await gate.run({ cwd, patterns: ['src/rules.ts'] })).toEqual([]);
-        expect(await fs.pathExists(baseline)).toBe(false);
-        await gate.run({ cwd });
-        const before = await fs.readFile(baseline, 'utf-8');
-        await fs.outputFile(path.join(cwd, 'src/rules.ts'), 'export function eligible(score: number) { return score > 10; }\n');
-        const scoped = await gate.run({ cwd, patterns: ['src/rules.ts'] });
-        expect(scoped.some(f => f.details.includes("'>=' to '>'"))).toBe(true);
-        expect(await fs.readFile(baseline, 'utf-8')).toBe(before);
-    });
-    it('style-drift does not create its baseline from a scoped run', async () => {
-        await fs.outputFile(path.join(cwd, 'src/a.ts'), 'export function doThing() { return 1; }\n');
-        const gate = new StyleDriftGate();
-        expect(await gate.run({ cwd, patterns: ['src/a.ts'] })).toEqual([]);
-        expect(await fs.pathExists(path.join(cwd, '.rigour/style-baseline.json'))).toBe(false);
-    });
-});

package/dist/gates/security-patterns-owasp.test.d.ts

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