@rigour-labs/core 6.8.0 → 6.8.1

package/dist/gates/agent-team.test.js

@@ -1,113 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { AgentTeamGate, registerAgent, getSession, clearSession } from './agent-team.js';
-import * as fs from 'fs';
-import * as path from 'path';
-import * as os from 'os';
-describe('AgentTeamGate', () => {
-    let testDir;
-    beforeEach(() => {
-        testDir = fs.mkdtempSync(path.join(os.tmpdir(), 'agent-team-test-'));
-    });
-    afterEach(() => {
-        clearSession(testDir);
-        fs.rmSync(testDir, { recursive: true, force: true });
-    });
-    describe('gate initialization', () => {
-        it('should create gate with default config', () => {
-            const gate = new AgentTeamGate();
-            expect(gate.id).toBe('agent-team');
-            expect(gate.title).toBe('Agent Team Governance');
-        });
-        it('should skip when not enabled', async () => {
-            const gate = new AgentTeamGate({ enabled: false });
-            const failures = await gate.run({ cwd: testDir });
-            expect(failures).toEqual([]);
-        });
-    });
-    describe('session management', () => {
-        it('should register an agent', () => {
-            const session = registerAgent(testDir, 'agent-a', ['src/api/**']);
-            expect(session.agents).toHaveLength(1);
-            expect(session.agents[0].agentId).toBe('agent-a');
-            expect(session.agents[0].taskScope).toEqual(['src/api/**']);
-        });
-        it('should update existing agent registration', () => {
-            registerAgent(testDir, 'agent-a', ['src/api/**']);
-            const session = registerAgent(testDir, 'agent-a', ['src/api/**', 'src/utils/**']);
-            expect(session.agents).toHaveLength(1);
-            expect(session.agents[0].taskScope).toEqual(['src/api/**', 'src/utils/**']);
-        });
-        it('should persist session to disk', () => {
-            registerAgent(testDir, 'agent-a', ['src/**']);
-            const sessionPath = path.join(testDir, '.rigour', 'agent-session.json');
-            expect(fs.existsSync(sessionPath)).toBe(true);
-        });
-        it('should load session from disk', () => {
-            registerAgent(testDir, 'agent-a', ['src/**']);
-            // Clear in-memory cache
-            clearSession(testDir);
-            // Re-register to re-create session file
-            registerAgent(testDir, 'agent-b', ['tests/**']);
-            const session = getSession(testDir);
-            expect(session).not.toBeNull();
-            expect(session.agents).toHaveLength(1); // Only agent-b after clearSession
-        });
-        it('should clear session', () => {
-            registerAgent(testDir, 'agent-a', ['src/**']);
-            clearSession(testDir);
-            const session = getSession(testDir);
-            expect(session).toBeNull();
-        });
-    });
-    describe('max concurrent agents check', () => {
-        it('should pass when under limit', async () => {
-            const gate = new AgentTeamGate({ enabled: true, max_concurrent_agents: 3 });
-            registerAgent(testDir, 'agent-a', ['src/a/**']);
-            registerAgent(testDir, 'agent-b', ['src/b/**']);
-            const failures = await gate.run({ cwd: testDir });
-            expect(failures).toEqual([]);
-        });
-        it('should fail when over limit', async () => {
-            const gate = new AgentTeamGate({ enabled: true, max_concurrent_agents: 2 });
-            registerAgent(testDir, 'agent-a', ['src/a/**']);
-            registerAgent(testDir, 'agent-b', ['src/b/**']);
-            registerAgent(testDir, 'agent-c', ['src/c/**']);
-            const failures = await gate.run({ cwd: testDir });
-            expect(failures).toHaveLength(1);
-            expect(failures[0].title).toBe('Too Many Concurrent Agents');
-        });
-    });
-    describe('task scope conflicts (strict mode)', () => {
-        it('should pass when scopes are disjoint', async () => {
-            const gate = new AgentTeamGate({
-                enabled: true,
-                task_ownership: 'strict'
-            });
-            registerAgent(testDir, 'agent-a', ['src/api/**']);
-            registerAgent(testDir, 'agent-b', ['src/ui/**']);
-            const failures = await gate.run({ cwd: testDir });
-            expect(failures).toEqual([]);
-        });
-        it('should fail when scopes overlap', async () => {
-            const gate = new AgentTeamGate({
-                enabled: true,
-                task_ownership: 'strict'
-            });
-            registerAgent(testDir, 'agent-a', ['src/api/**']);
-            registerAgent(testDir, 'agent-b', ['src/api/**']); // Same scope!
-            const failures = await gate.run({ cwd: testDir });
-            expect(failures).toHaveLength(1);
-            expect(failures[0].title).toBe('Task Scope Conflict');
-        });
-        it('should allow overlapping scopes in collaborative mode', async () => {
-            const gate = new AgentTeamGate({
-                enabled: true,
-                task_ownership: 'collaborative'
-            });
-            registerAgent(testDir, 'agent-a', ['src/api/**']);
-            registerAgent(testDir, 'agent-b', ['src/api/**']); // Same scope - OK in collaborative
-            const failures = await gate.run({ cwd: testDir });
-            expect(failures).toEqual([]);
-        });
-    });
-});

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

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

package/dist/gates/ast.test.js

@@ -1,112 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import fs from 'fs';
-import os from 'os';
-import path from 'path';
-import { ASTGate } from './ast.js';
-describe('ASTGate ignore behavior', () => {
-    let testDir;
-    beforeEach(() => {
-        testDir = fs.mkdtempSync(path.join(os.tmpdir(), 'ast-gate-test-'));
-    });
-    afterEach(() => {
-        fs.rmSync(testDir, { recursive: true, force: true });
-    });
-    it('keeps default ignores when context.ignore is an empty array', async () => {
-        const gate = new ASTGate({
-            ast: { max_params: 1 },
-        });
-        fs.mkdirSync(path.join(testDir, 'node_modules', 'example'), { recursive: true });
-        fs.writeFileSync(path.join(testDir, 'node_modules', 'example', 'bad.js'), 'function fromDeps(a, b, c) { return a + b + c; }', 'utf-8');
-        fs.mkdirSync(path.join(testDir, 'src'), { recursive: true });
-        fs.writeFileSync(path.join(testDir, 'src', 'ok.js'), 'function ok(a) { return a; }', 'utf-8');
-        const failures = await gate.run({
-            cwd: testDir,
-            ignore: [],
-        });
-        expect(failures).toHaveLength(0);
-    });
-    it('merges user ignore patterns with default ignores', async () => {
-        const gate = new ASTGate({
-            ast: { max_params: 1 },
-        });
-        fs.mkdirSync(path.join(testDir, 'generated'), { recursive: true });
-        fs.writeFileSync(path.join(testDir, 'generated', 'bad.js'), 'function generated(a, b, c) { return a + b + c; }', 'utf-8');
-        fs.mkdirSync(path.join(testDir, 'src'), { recursive: true });
-        fs.writeFileSync(path.join(testDir, 'src', 'ok.js'), 'function ok(a) { return a; }', 'utf-8');
-        const failures = await gate.run({
-            cwd: testDir,
-            ignore: ['generated/**'],
-        });
-        expect(failures).toHaveLength(0);
-    });
-    it('ignores generated studio-dist assets by default', async () => {
-        const gate = new ASTGate({
-            ast: { max_params: 1 },
-        });
-        fs.mkdirSync(path.join(testDir, 'packages', 'rigour-cli', 'studio-dist', 'assets'), { recursive: true });
-        fs.writeFileSync(path.join(testDir, 'packages', 'rigour-cli', 'studio-dist', 'assets', 'index.js'), 'function fromBundle(a, b, c) { return a + b + c; }', 'utf-8');
-        const failures = await gate.run({
-            cwd: testDir,
-            ignore: [],
-        });
-        expect(failures).toHaveLength(0);
-    });
-    it('ignores examples directory by default', async () => {
-        const gate = new ASTGate({
-            ast: { max_params: 1 },
-        });
-        fs.mkdirSync(path.join(testDir, 'examples', 'demo', 'src'), { recursive: true });
-        fs.writeFileSync(path.join(testDir, 'examples', 'demo', 'src', 'bad.js'), 'function noisy(a, b, c) { return a + b + c; }', 'utf-8');
-        const failures = await gate.run({
-            cwd: testDir,
-            ignore: [],
-        });
-        expect(failures).toHaveLength(0);
-    });
-    it('sets severity and provenance on AST violations', async () => {
-        const gate = new ASTGate({
-            ast: { max_params: 1 },
-        });
-        fs.mkdirSync(path.join(testDir, 'src'), { recursive: true });
-        fs.writeFileSync(path.join(testDir, 'src', 'bad.js'), 'function tooMany(a, b, c) { return a + b + c; }', 'utf-8');
-        const failures = await gate.run({ cwd: testDir, ignore: [] });
-        const target = failures.find((failure) => failure.id === 'AST_MAX_PARAMS');
-        expect(target).toBeDefined();
-        expect(target?.severity).toBe('medium');
-        expect(target?.provenance).toBe('traditional');
-    });
-    it('marks prototype pollution findings as security-critical', async () => {
-        const gate = new ASTGate({
-            ast: { max_params: 10 },
-        });
-        fs.mkdirSync(path.join(testDir, 'src'), { recursive: true });
-        fs.writeFileSync(path.join(testDir, 'src', 'pollute.js'), 'const target = {}; target.__proto__ = {};', 'utf-8');
-        const failures = await gate.run({ cwd: testDir, ignore: [] });
-        const target = failures.find((failure) => failure.id === 'SECURITY_PROTOTYPE_POLLUTION');
-        expect(target).toBeDefined();
-        expect(target?.severity).toBe('critical');
-        expect(target?.provenance).toBe('security');
-    });
-    it('does not attribute nested function complexity to parent function', async () => {
-        const gate = new ASTGate({
-            ast: { complexity: 3, max_params: 10 },
-        });
-        fs.mkdirSync(path.join(testDir, 'src'), { recursive: true });
-        fs.writeFileSync(path.join(testDir, 'src', 'nested.ts'), `
-            function outer(flag: boolean) {
-              function inner(x: number) {
-                if (x > 0) { return 1; }
-                if (x < 0) { return -1; }
-                if (x === 0) { return 0; }
-                return 0;
-              }
-              return flag ? inner(1) : inner(-1);
-            }
-            `, 'utf-8');
-        const failures = await gate.run({ cwd: testDir, ignore: [] });
-        const complexityTitles = failures
-            .filter((failure) => failure.id === 'AST_COMPLEXITY')
-            .map((failure) => failure.title);
-        expect(complexityTitles.some((title) => title.includes("'outer'"))).toBe(false);
-    });
-});

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

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

package/dist/gates/checkpoint.test.js

@@ -1,105 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { CheckpointGate, recordCheckpoint, getCheckpointSession, clearCheckpointSession, getOrCreateCheckpointSession, completeCheckpointSession, abortCheckpointSession } from './checkpoint.js';
-import * as fs from 'fs';
-import * as path from 'path';
-import * as os from 'os';
-describe('CheckpointGate', () => {
-    let testDir;
-    beforeEach(() => {
-        testDir = fs.mkdtempSync(path.join(os.tmpdir(), 'checkpoint-test-'));
-    });
-    afterEach(() => {
-        clearCheckpointSession(testDir);
-        fs.rmSync(testDir, { recursive: true, force: true });
-    });
-    describe('gate initialization', () => {
-        it('should create gate with default config', () => {
-            const gate = new CheckpointGate();
-            expect(gate.id).toBe('checkpoint');
-            expect(gate.title).toBe('Checkpoint Supervision');
-        });
-        it('should skip when not enabled', async () => {
-            const gate = new CheckpointGate({ enabled: false });
-            const failures = await gate.run({ cwd: testDir });
-            expect(failures).toEqual([]);
-        });
-    });
-    describe('session management', () => {
-        it('should create a new session', () => {
-            const session = getOrCreateCheckpointSession(testDir);
-            expect(session.sessionId).toMatch(/^chk-session-/);
-            expect(session.status).toBe('active');
-            expect(session.checkpoints).toHaveLength(0);
-        });
-        it('should record a checkpoint', () => {
-            const result = recordCheckpoint(testDir, 25, // progressPct
-            ['src/api/users.ts'], 'Implemented user API', 85 // qualityScore
-            );
-            expect(result.continue).toBe(true);
-            expect(result.checkpoint.progressPct).toBe(25);
-            expect(result.checkpoint.qualityScore).toBe(85);
-        });
-        it('should persist session to disk', () => {
-            recordCheckpoint(testDir, 50, [], 'Test', 90);
-            const sessionPath = path.join(testDir, '.rigour', 'checkpoint-session.json');
-            expect(fs.existsSync(sessionPath)).toBe(true);
-        });
-        it('should complete session', () => {
-            getOrCreateCheckpointSession(testDir);
-            completeCheckpointSession(testDir);
-            const session = getCheckpointSession(testDir);
-            expect(session?.status).toBe('completed');
-        });
-        it('should abort session with reason', () => {
-            getOrCreateCheckpointSession(testDir);
-            abortCheckpointSession(testDir, 'Quality too low');
-            const session = getCheckpointSession(testDir);
-            expect(session?.status).toBe('aborted');
-            expect(session?.checkpoints[0].summary).toContain('Quality too low');
-        });
-    });
-    describe('quality threshold', () => {
-        it('should continue when quality above threshold', () => {
-            const result = recordCheckpoint(testDir, 50, [], 'Good work', 85);
-            expect(result.continue).toBe(true);
-            expect(result.warnings).toHaveLength(0);
-        });
-        it('should stop when quality below threshold', () => {
-            const result = recordCheckpoint(testDir, 50, [], 'Poor work', 70);
-            expect(result.continue).toBe(false);
-            expect(result.warnings).toContain('Quality score 70% is below threshold 80%');
-        });
-    });
-    describe('drift detection', () => {
-        it('should detect quality degradation', () => {
-            // Record checkpoints with a sharp quality drop.
-            // EWMA with α=0.3: after 95, 90, the EWMA ≈ 93.5.
-            // A sudden drop to 55 creates a gap of ~38 which exceeds the
-            // drift_drop_threshold of 15, triggering the "Sudden quality drop" warning.
-            recordCheckpoint(testDir, 20, [], 'Start', 95);
-            recordCheckpoint(testDir, 40, [], 'Middle', 90);
-            const result = recordCheckpoint(testDir, 60, [], 'Decline', 55);
-            expect(result.warnings.some(w => w.includes('Sudden quality drop'))).toBe(true);
-        });
-        it('should not flag stable quality', () => {
-            recordCheckpoint(testDir, 20, [], 'Start', 85);
-            recordCheckpoint(testDir, 40, [], 'Middle', 85);
-            const result = recordCheckpoint(testDir, 60, [], 'Stable', 85);
-            expect(result.warnings.filter(w => w.includes('Drift'))).toHaveLength(0);
-        });
-    });
-    describe('gate run', () => {
-        it('should pass with healthy checkpoints', async () => {
-            const gate = new CheckpointGate({ enabled: true, quality_threshold: 80 });
-            recordCheckpoint(testDir, 50, [], 'Good work', 90);
-            const failures = await gate.run({ cwd: testDir });
-            expect(failures).toHaveLength(0);
-        });
-        it('should fail when quality below threshold', async () => {
-            const gate = new CheckpointGate({ enabled: true, quality_threshold: 80 });
-            recordCheckpoint(testDir, 50, [], 'Poor work', 70);
-            const failures = await gate.run({ cwd: testDir });
-            expect(failures.some(f => f.title === 'Quality Below Threshold')).toBe(true);
-        });
-    });
-});

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

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

package/dist/gates/content.test.js

@@ -1,73 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import * as fs from 'fs';
-import * as path from 'path';
-import * as os from 'os';
-import { ContentGate } from './content.js';
-describe('ContentGate', () => {
-    let testDir;
-    beforeEach(() => {
-        testDir = fs.mkdtempSync(path.join(os.tmpdir(), 'content-gate-test-'));
-    });
-    afterEach(() => {
-        fs.rmSync(testDir, { recursive: true, force: true });
-    });
-    it('flags TODO and FIXME in comments', async () => {
-        fs.writeFileSync(path.join(testDir, 'app.ts'), `
-            // TODO: remove temporary fallback
-            const value = 1;
-            const x = value; // FIXME clean this before release
-        `);
-        const gate = new ContentGate({ forbidTodos: true, forbidFixme: true });
-        const failures = await gate.run({ cwd: testDir });
-        expect(failures).toHaveLength(2);
-    });
-    it('does not flag TODO or FIXME in non-comment string literals', async () => {
-        fs.writeFileSync(path.join(testDir, 'app.ts'), `
-            const message = "TODO this is user-facing text";
-            const note = "FIXME should not trigger in strings";
-        `);
-        const gate = new ContentGate({ forbidTodos: true, forbidFixme: true });
-        const failures = await gate.run({ cwd: testDir });
-        expect(failures).toHaveLength(0);
-    });
-    it('does not scan markdown files', async () => {
-        fs.writeFileSync(path.join(testDir, 'README.md'), `
-            # TODO
-            This is a product roadmap item.
-        `);
-        const gate = new ContentGate({ forbidTodos: true, forbidFixme: true });
-        const failures = await gate.run({ cwd: testDir });
-        expect(failures).toHaveLength(0);
-    });
-    it('respects config toggles', async () => {
-        fs.writeFileSync(path.join(testDir, 'app.ts'), `
-            // TODO: one
-            // FIXME: two
-        `);
-        const todoOnly = new ContentGate({ forbidTodos: true, forbidFixme: false });
-        const todoFailures = await todoOnly.run({ cwd: testDir });
-        expect(todoFailures).toHaveLength(1);
-        expect(todoFailures[0].details).toContain("TODO");
-        const fixmeOnly = new ContentGate({ forbidTodos: false, forbidFixme: true });
-        const fixmeFailures = await fixmeOnly.run({ cwd: testDir });
-        expect(fixmeFailures).toHaveLength(1);
-        expect(fixmeFailures[0].details).toContain("FIXME");
-    });
-    it('does not flag explanatory mentions of TODO/FIXME in comments', async () => {
-        fs.writeFileSync(path.join(testDir, 'notes.ts'), `
-            // counts TODO and FIXME markers from parsed files
-            const metrics = true;
-        `);
-        const gate = new ContentGate({ forbidTodos: true, forbidFixme: true });
-        const failures = await gate.run({ cwd: testDir });
-        expect(failures).toHaveLength(0);
-    });
-    it('skips test/spec files', async () => {
-        fs.writeFileSync(path.join(testDir, 'sample.test.ts'), `
-            // TODO: this should not be checked by content gate
-        `);
-        const gate = new ContentGate({ forbidTodos: true, forbidFixme: true });
-        const failures = await gate.run({ cwd: testDir });
-        expect(failures).toHaveLength(0);
-    });
-});

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

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

package/dist/gates/coverage.test.js

@@ -1,53 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import fs from 'fs';
-import os from 'os';
-import path from 'path';
-import { CoverageGate } from './coverage.js';
-describe('CoverageGate', () => {
-    let testDir;
-    beforeEach(() => {
-        testDir = fs.mkdtempSync(path.join(os.tmpdir(), 'coverage-gate-test-'));
-    });
-    afterEach(() => {
-        fs.rmSync(testDir, { recursive: true, force: true });
-    });
-    it('flags low coverage from lcov report', async () => {
-        fs.mkdirSync(path.join(testDir, 'coverage'), { recursive: true });
-        fs.writeFileSync(path.join(testDir, 'coverage', 'lcov.info'), [
-            'TN:',
-            'SF:src/alpha.ts',
-            'LF:10',
-            'LH:3',
-            'end_of_record',
-        ].join('\n'), 'utf-8');
-        const gate = new CoverageGate({});
-        const failures = await gate.run({ cwd: testDir });
-        expect(failures).toHaveLength(1);
-        expect(failures[0].id).toBe('DYNAMIC_COVERAGE_LOW');
-        expect(failures[0].files).toEqual(['src/alpha.ts']);
-    });
-    it('parses coverage-final.json reports', async () => {
-        fs.writeFileSync(path.join(testDir, 'coverage-final.json'), JSON.stringify({
-            'src/beta.ts': {
-                s: { '1': 1, '2': 0, '3': 0, '4': 1 },
-            },
-        }), 'utf-8');
-        const gate = new CoverageGate({});
-        const failures = await gate.run({ cwd: testDir });
-        expect(failures).toHaveLength(0);
-    });
-    it('ignores coverage reports under node_modules', async () => {
-        fs.mkdirSync(path.join(testDir, 'node_modules', 'pkg', 'coverage'), { recursive: true });
-        fs.writeFileSync(path.join(testDir, 'node_modules', 'pkg', 'coverage', 'lcov.info'), ['TN:', 'SF:src/dep.ts', 'LF:10', 'LH:0', 'end_of_record'].join('\n'), 'utf-8');
-        const gate = new CoverageGate({});
-        const failures = await gate.run({ cwd: testDir });
-        expect(failures).toHaveLength(0);
-    });
-    it('respects context.ignore for coverage report discovery', async () => {
-        fs.mkdirSync(path.join(testDir, 'generated', 'reports'), { recursive: true });
-        fs.writeFileSync(path.join(testDir, 'generated', 'reports', 'lcov.info'), ['TN:', 'SF:src/generated.ts', 'LF:10', 'LH:0', 'end_of_record'].join('\n'), 'utf-8');
-        const gate = new CoverageGate({});
-        const failures = await gate.run({ cwd: testDir, ignore: ['generated/**'] });
-        expect(failures).toHaveLength(0);
-    });
-});

package/dist/gates/dedupe-failures.test.d.ts

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

package/dist/gates/dedupe-failures.test.js

@@ -1,12 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { dedupeFailures } from './runner.js';
-const finding = (title, line = 3) => ({ id: 'semantic-bugs', title, details: '', severity: 'high', provenance: 'traditional', files: ['src/a.ts'], line });
-describe('dedupeFailures', () => {
-    it('keeps a learned rule that fires on the same line as a built-in rule of the same gate', () => {
-        const kept = dedupeFailures([finding('credential-redirect'), finding('learned-rule: require-option-redirect')]);
-        expect(kept.map(f => f.title)).toEqual(['credential-redirect', 'learned-rule: require-option-redirect']);
-    });
-    it('still drops the same rule reported twice on one line', () => {
-        expect(dedupeFailures([finding('credential-redirect'), finding('credential-redirect'), finding('credential-redirect', 9)])).toHaveLength(2);
-    });
-});

package/dist/gates/deep-analysis.test.d.ts

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

package/dist/gates/deep-analysis.test.js

@@ -1,86 +0,0 @@
-import fs from 'fs-extra';
-import os from 'os';
-import path from 'path';
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-const provider = vi.hoisted(() => ({
-    setup: vi.fn(async () => undefined),
-    analyze: vi.fn(async (_prompt) => '{"findings": []}'),
-}));
-vi.mock('../inference/index.js', () => ({
-    createProvider: () => ({
-        name: 'fake',
-        isAvailable: async () => true,
-        setup: provider.setup,
-        analyze: provider.analyze,
-        dispose: () => undefined,
-    }),
-}));
-vi.mock('../storage/local-memory.js', () => ({ checkLocalPatterns: async () => [] }));
-const { DeepAnalysisGate } = await import('./deep-analysis.js');
-const REPORT_TS = [
-    'export async function loadReport(days: number) {',
-    '  const rows = await fetchAll(days);',
-    '  return rows.length;',
-    '}',
-].join('\n');
-describe('DeepAnalysisGate', () => {
-    let cwd;
-    beforeEach(async () => {
-        cwd = await fs.mkdtemp(path.join(os.tmpdir(), 'rigour-deep-gate-'));
-        await fs.outputFile(path.join(cwd, 'src/report.ts'), REPORT_TS);
-        await fs.outputFile(path.join(cwd, 'src/other.ts'), 'export const other = 1;\nexport const two = 2;\nexport const three = 3;\n');
-        provider.setup.mockReset().mockResolvedValue(undefined);
-        provider.analyze.mockReset().mockResolvedValue('{"findings": []}');
-    });
-    afterEach(async () => { await fs.remove(cwd); });
-    const gate = () => new DeepAnalysisGate({ options: { enabled: true, provider: 'local' } });
-    it('records an error outcome when setup fails', async () => {
-        provider.setup.mockRejectedValue(new Error('engine missing'));
-        const g = gate();
-        expect(await g.run({ cwd })).toEqual([]);
-        expect(g.getOutcome()).toMatchObject({ status: 'error', error: 'engine missing' });
-    });
-    it('records an error outcome when every inference call fails', async () => {
-        provider.analyze.mockRejectedValue(new Error('invalid argument: --json'));
-        const g = gate();
-        await g.run({ cwd, patterns: ['src/report.ts', 'src/other.ts'] });
-        expect(g.getOutcome()).toMatchObject({ status: 'error', chunksTotal: 2, chunksFailed: 2 });
-        expect(g.getOutcome().error).toContain('invalid argument: --json');
-    });
-    it('records a partial outcome when some calls fail', async () => {
-        provider.analyze.mockRejectedValueOnce(new Error('timed out')).mockResolvedValue('{"findings": []}');
-        const g = gate();
-        await g.run({ cwd, patterns: ['src/report.ts', 'src/other.ts'] });
-        expect(g.getOutcome()).toMatchObject({ status: 'partial', chunksTotal: 2, chunksFailed: 1 });
-    });
-    it('reviews only the scoped file, with its numbered source', async () => {
-        const g = gate();
-        await g.run({ cwd, patterns: ['src/report.ts'] });
-        expect(provider.analyze).toHaveBeenCalledTimes(1);
-        const prompt = provider.analyze.mock.calls[0][0];
-        expect(prompt).toContain('2|   const rows = await fetchAll(days);');
-        expect(prompt).not.toContain('src/other.ts');
-        expect(g.getOutcome()).toMatchObject({ status: 'ok', mode: 'code', filesAnalyzed: 1 });
-    });
-    it('keeps grounded findings and drops ones about code that was not sent', async () => {
-        provider.analyze.mockResolvedValue(JSON.stringify({ findings: [
-                { category: 'scalability', severity: 'high', file: 'src/report.ts', line: 2, description: '`fetchAll` loads every row.', suggestion: 'Aggregate in SQL.', confidence: 0.8 },
-                { category: 'security', severity: 'high', file: 'src/report.ts', line: 3, description: '`sendSecret` leaks a token.', suggestion: 'x', confidence: 0.9 },
-            ] }));
-        const failures = await gate().run({ cwd, patterns: ['src/report.ts'] });
-        expect(failures).toHaveLength(1);
-        expect(failures[0]).toMatchObject({ id: 'deep-analysis', files: ['src/report.ts'], line: 2, provenance: 'deep-analysis', verified: true });
-    });
-    it('uses the facts prompt for an unscoped run', async () => {
-        const g = gate();
-        await g.run({ cwd });
-        expect(provider.analyze.mock.calls[0][0]).toContain('AST-EXTRACTED FACTS');
-        expect(g.getOutcome()).toMatchObject({ status: 'ok', mode: 'facts', filesAnalyzed: 2 });
-    });
-    it('is ok with no analyzable files in scope', async () => {
-        const g = gate();
-        expect(await g.run({ cwd, patterns: ['README.md'] })).toEqual([]);
-        expect(g.getOutcome()).toMatchObject({ status: 'ok', filesAnalyzed: 0 });
-        expect(provider.analyze).not.toHaveBeenCalled();
-    });
-});

package/dist/gates/deep-intent.test.d.ts

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

package/dist/gates/deep-intent.test.js

@@ -1,51 +0,0 @@
-import fs from 'fs';
-import os from 'os';
-import path from 'path';
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import { runIntentChecks } from './deep-intent.js';
-const DASHBOARD = [
-    'declare function getAccount(id: string): Promise<{ name: string }>;',
-    'declare function getRecommendedCourses(id: string): Promise<string[]>;',
-    'export async function loadDashboard(id: string) {',
-    '  const [account, recommended] = await Promise.all([getAccount(id), getRecommendedCourses(id)]);',
-    '  return { account, recommended };',
-    '}',
-].join('\n');
-/** Answers as if getRecommendedCourses were optional and getAccount required. */
-function provider(calls) {
-    return {
-        name: 'fake',
-        isAvailable: async () => true,
-        setup: async () => { },
-        dispose: () => { },
-        analyze: async (prompt) => {
-            calls.push(prompt);
-            const optional = /Question: [^\n]*getRecommendedCourses/.test(prompt);
-            const ifFails = prompt.includes('Question: If');
-            return JSON.stringify({ answer: ifFails === optional ? 'yes' : 'no' });
-        },
-    };
-}
-describe('runIntentChecks', () => {
-    let cwd;
-    beforeEach(() => { cwd = fs.mkdtempSync(path.join(os.tmpdir(), 'deep-intent-')); });
-    afterEach(() => { fs.rmSync(cwd, { recursive: true, force: true }); });
-    it('reports an optional read that can take down a required one', async () => {
-        fs.writeFileSync(path.join(cwd, 'dashboard.ts'), DASHBOARD);
-        const calls = [];
-        const [failure, ...rest] = await runIntentChecks(cwd, ['dashboard.ts'], provider(calls));
-        expect(rest).toHaveLength(0);
-        expect(calls).toHaveLength(4);
-        expect(failure).toMatchObject({
-            id: 'deep-analysis', files: ['dashboard.ts'], line: 4, category: 'optional-read-no-fallback',
-            provenance: 'deep-analysis', source: 'hybrid', verified: false,
-        });
-        expect(failure.details).toContain('`getRecommendedCourses` looks optional');
-    });
-    it('asks nothing when no file has an unhandled Promise.all', async () => {
-        fs.writeFileSync(path.join(cwd, 'plain.ts'), 'export const x = 1;\n');
-        const calls = [];
-        expect(await runIntentChecks(cwd, ['plain.ts', 'README.md'], provider(calls))).toEqual([]);
-        expect(calls).toEqual([]);
-    });
-});

package/dist/gates/deep-timeout.test.d.ts

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

package/dist/gates/deep-timeout.test.js

@@ -1,10 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { defaultTimeout } from './deep-analysis.js';
-describe('deep inference timeout', () => {
-    it('gives the local 7B tier four minutes a call, the small tiers one, and cloud two', () => {
-        expect(defaultTimeout({ enabled: true })).toBe(60_000);
-        expect(defaultTimeout({ enabled: true, pro: true })).toBe(60_000);
-        expect(defaultTimeout({ enabled: true, max: true })).toBe(240_000);
-        expect(defaultTimeout({ enabled: true, apiKey: 'k', provider: 'claude' })).toBe(120_000);
-    });
-});

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

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