@rigour-labs/core 2.22.0 → 3.0.0

package/src/discovery.test.ts

@@ -1,88 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { DiscoveryService } from './discovery.js';
-import fs from 'fs-extra';
-import path from 'path';
-
-vi.mock('fs-extra');
-
-describe('DiscoveryService', () => {
-    beforeEach(() => {
-        vi.resetAllMocks();
-    });
-
-    it('should discover project marker in root directory', async () => {
-        const service = new DiscoveryService();
-        vi.mocked(fs.pathExists).mockImplementation(async (p: string) => p.includes('package.json'));
-        vi.mocked(fs.readdir).mockResolvedValue(['package.json'] as any);
-        vi.mocked(fs.readFile).mockResolvedValue('{}' as any);
-
-        const result = await service.discover('/test');
-        // If package.json doesn't match a specific role marker, it stays Universal.
-        // Let's mock a specific one like 'express'
-        vi.mocked(fs.pathExists).mockImplementation(async (p: string) => p.includes('express'));
-        const result2 = await service.discover('/test');
-        expect(result2.matches.preset?.name).toBe('api');
-    });
-
-    it('should discover project marker in src/ directory (Deep Detection)', async () => {
-        const service = new DiscoveryService();
-        vi.mocked(fs.pathExists).mockImplementation((async (p: string) => {
-            if (p.endsWith('src')) return true;
-            if (p.includes('src/index.ts')) return true;
-            return false;
-        }) as any);
-        vi.mocked(fs.readdir).mockImplementation((async (p: string) => {
-            if (p.toString().endsWith('/test')) return ['src'] as any;
-            if (p.toString().endsWith('src')) return ['index.ts'] as any;
-            return [] as any;
-        }) as any);
-        vi.mocked(fs.readFile).mockResolvedValue('export const x = 1;' as any);
-
-        const result = await service.discover('/test');
-        // Since UNIVERSAL_CONFIG has a default, we check if it found something extra or matches expectation
-        // Default is universal, but detecting .ts should tilt it towards node or similar if configured
-        // In our current templates, package.json is the node marker.
-        // Let's check for paradigm detection which uses content
-        expect(result.config).toBeDefined();
-    });
-
-    it('should identify OOP paradigm from content in subfolder', async () => {
-        const service = new DiscoveryService();
-        vi.mocked(fs.pathExists).mockImplementation((async (p: string) => p.endsWith('src') || p.endsWith('src/Service.ts')) as any);
-        vi.mocked(fs.readdir).mockImplementation((async (p: string) => {
-            if (p.toString().endsWith('src')) return ['Service.ts'] as any;
-            return ['src'] as any;
-        }) as any);
-        vi.mocked(fs.readFile).mockResolvedValue('class MyService {}' as any);
-
-        const result = await service.discover('/test');
-        expect(result.matches.paradigm?.name).toBe('oop');
-    });
-
-    it('should include project-type-aware ignore patterns for API preset', async () => {
-        const service = new DiscoveryService();
-        // Mock finding requirements.txt (Python API marker)
-        vi.mocked(fs.pathExists).mockImplementation(async (p: string) => p.includes('requirements.txt'));
-        vi.mocked(fs.readdir).mockResolvedValue(['requirements.txt'] as any);
-        vi.mocked(fs.readFile).mockResolvedValue('flask==2.0.0' as any);
-
-        const result = await service.discover('/test');
-        expect(result.matches.preset?.name).toBe('api');
-        expect(result.config.ignore).toContain('venv/**');
-        expect(result.config.ignore).toContain('__pycache__/**');
-        expect(result.config.ignore).toContain('*.pyc');
-    });
-
-    it('should include project-type-aware ignore patterns for UI preset', async () => {
-        const service = new DiscoveryService();
-        // Mock finding next.config.js (UI marker)
-        vi.mocked(fs.pathExists).mockImplementation(async (p: string) => p.includes('next.config.js'));
-        vi.mocked(fs.readdir).mockResolvedValue(['next.config.js'] as any);
-        vi.mocked(fs.readFile).mockResolvedValue('module.exports = {}' as any);
-
-        const result = await service.discover('/test');
-        expect(result.matches.preset?.name).toBe('ui');
-        expect(result.config.ignore).toContain('node_modules/**');
-        expect(result.config.ignore).toContain('.next/**');
-    });
-});

package/src/discovery.ts

@@ -1,112 +0,0 @@
-import fs from 'fs-extra';
-import path from 'path';
-import { Config, Gates } from './types/index.js';
-import { TEMPLATES, PARADIGM_TEMPLATES, UNIVERSAL_CONFIG } from './templates/index.js';
-
-export interface DiscoveryResult {
-    config: Config;
-    matches: {
-        preset?: { name: string; marker: string };
-        paradigm?: { name: string; marker: string };
-    };
-}
-
-export class DiscoveryService {
-    async discover(cwd: string): Promise<DiscoveryResult> {
-        let config = { ...UNIVERSAL_CONFIG };
-        const matches: DiscoveryResult['matches'] = {};
-
-        // 1. Detect Role (ui, api, infra, data)
-        for (const template of TEMPLATES) {
-            const marker = await this.findFirstMarker(cwd, template.markers, true); // Search content for roles too
-            if (marker) {
-                config = this.mergeConfig(config, template.config);
-                matches.preset = { name: template.name, marker };
-                break; // Only one role for now
-            }
-        }
-
-        // 2. Detect Paradigm (oop, functional)
-        for (const template of PARADIGM_TEMPLATES) {
-            const marker = await this.findFirstMarker(cwd, template.markers, true); // Search content
-            if (marker) {
-                config = this.mergeConfig(config, template.config);
-                matches.paradigm = { name: template.name, marker };
-                break;
-            }
-        }
-
-        return { config, matches };
-    }
-
-    private mergeConfig(base: Config, extension: any): Config {
-        // Deep merge for gates to preserve defaults when overrides are partial
-        const mergedGates = { ...base.gates };
-        if (extension.gates) {
-            for (const [key, value] of Object.entries(extension.gates)) {
-                if (typeof value === 'object' && value !== null && !Array.isArray(value) && (mergedGates as any)[key]) {
-                    (mergedGates as any)[key] = { ...(mergedGates as any)[key], ...value };
-                } else {
-                    (mergedGates as any)[key] = value;
-                }
-            }
-        }
-
-        return {
-            ...base,
-            preset: extension.preset || base.preset,
-            paradigm: extension.paradigm || base.paradigm,
-            commands: { ...base.commands, ...extension.commands },
-            gates: mergedGates as Gates,
-            ignore: [...new Set([...(base.ignore || []), ...(extension.ignore || [])])],
-        };
-    }
-
-    private async findFirstMarker(cwd: string, markers: string[], searchContent: boolean = false): Promise<string | null> {
-        for (const marker of markers) {
-            const fullPath = path.join(cwd, marker);
-
-            // File/Directory existence check
-            if (await fs.pathExists(fullPath)) {
-                return marker;
-            }
-
-            // Deep content check for paradigms
-            if (searchContent) {
-                const match = await this.existsInContent(cwd, marker);
-                if (match) return `content:${marker}`;
-            }
-        }
-        return null;
-    }
-
-    private async existsInContent(cwd: string, pattern: string): Promise<boolean> {
-        // Simple heuristic: search in top 5 source files
-        const files = await this.findSourceFiles(cwd);
-        for (const file of files) {
-            const content = await fs.readFile(file, 'utf-8');
-            if (content.includes(pattern)) return true;
-        }
-        return false;
-    }
-
-    private async findSourceFiles(cwd: string): Promise<string[]> {
-        const extensions = ['.ts', '.js', '.py', '.go', '.java', '.tf', 'package.json'];
-        const samples: string[] = [];
-        const commonDirs = ['.', 'src', 'app', 'lib', 'api', 'pkg'];
-
-        for (const dir of commonDirs) {
-            const fullDir = path.join(cwd, dir);
-            if (!(await fs.pathExists(fullDir))) continue;
-
-            const files = await fs.readdir(fullDir);
-            for (const file of files) {
-                if (extensions.some(ext => file.endsWith(ext))) {
-                    samples.push(path.join(fullDir, file));
-                    if (samples.length >= 5) return samples;
-                }
-            }
-        }
-        return samples;
-    }
-}

package/src/environment.test.ts

@@ -1,115 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { GateRunner } from './gates/runner.js';
-import { Config, RawConfig, ConfigSchema } from './types/index.js';
-import fs from 'fs-extra';
-import path from 'path';
-
-describe('Environment Alignment Gate', () => {
-    const testDir = path.join(process.cwd(), 'temp-test-env');
-
-    beforeEach(async () => {
-        await fs.ensureDir(testDir);
-    });
-
-    afterEach(async () => {
-        await fs.remove(testDir);
-    });
-
-    it('should detect tool version mismatch (Explicit)', async () => {
-        const rawConfig: RawConfig = {
-            version: 1,
-            gates: {
-                environment: {
-                    enabled: true,
-                    enforce_contracts: false,
-                    tools: {
-                        node: ">=99.0.0" // Guaranteed to fail
-                    }
-                }
-            }
-        };
-
-        const config = ConfigSchema.parse(rawConfig);
-        const runner = new GateRunner(config);
-        const report = await runner.run(testDir);
-
-        expect(report.status).toBe('FAIL');
-        const envFailure = report.failures.find(f => f.id === 'environment-alignment');
-        expect(envFailure).toBeDefined();
-        expect(envFailure?.details).toContain('node');
-        expect(envFailure?.details).toContain('version mismatch');
-    });
-
-    it('should detect missing environment variables', async () => {
-        const rawConfig: RawConfig = {
-            version: 1,
-            gates: {
-                environment: {
-                    enabled: true,
-                    required_env: ["RIGOUR_TEST_VAR_MISSING"]
-                }
-            }
-        };
-
-        const config = ConfigSchema.parse(rawConfig);
-        const runner = new GateRunner(config);
-        const report = await runner.run(testDir);
-
-        expect(report.status).toBe('FAIL');
-        expect(report.failures[0].details).toContain('RIGOUR_TEST_VAR_MISSING');
-    });
-
-    it('should discover contracts from pyproject.toml', async () => {
-        // Create mock pyproject.toml with a version that will surely fail
-        await fs.writeFile(path.join(testDir, 'pyproject.toml'), `
-[tool.ruff]
-ruff = ">=99.14.0"
-`);
-
-        const rawConfig: RawConfig = {
-            version: 1,
-            gates: {
-                environment: {
-                    enabled: true,
-                    enforce_contracts: true,
-                    tools: {} // Should discover ruff from file
-                }
-            }
-        };
-
-        const config = ConfigSchema.parse(rawConfig);
-        const runner = new GateRunner(config);
-        const report = await runner.run(testDir);
-
-        // This might pass or fail depending on the local ruff version, 
-        // but we want to check if the gate attempted to check ruff.
-        // If ruff is missing, it will fail with "is missing".
-        const ruffFailure = report.failures.find(f => f.details.includes('ruff'));
-        expect(ruffFailure).toBeDefined();
-    });
-
-    it('should prioritize environment gate and run it first', async () => {
-        const rawConfig: RawConfig = {
-            version: 1,
-            gates: {
-                max_file_lines: 1,
-                environment: {
-                    enabled: true,
-                    required_env: ["MANDATORY_SECRET_MISSING"]
-                }
-            }
-        };
-
-        const config = ConfigSchema.parse(rawConfig);
-
-        // Create a file that would fail max_file_lines
-        await fs.writeFile(path.join(testDir, 'large.js'), 'line1\nline2\nline3');
-
-        const runner = new GateRunner(config);
-        const report = await runner.run(testDir);
-
-        // In a real priority system, we might want to stop after environment failure.
-        // Currently GateRunner runs all, but environment-alignment has been unshifted.
-        expect(Object.keys(report.summary)[0]).toBe('environment-alignment');
-    });
-});

package/src/gates/agent-team.test.ts

@@ -1,134 +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: string;
-
-    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/src/gates/agent-team.ts

@@ -1,210 +0,0 @@
-/**
- * Agent Team Governance Gate
- * 
- * Supervises multi-agent coordination for frontier models like
- * Opus 4.6 (agent teams) and GPT-5.3-Codex (coworking mode).
- * 
- * Detects:
- * - Cross-agent pattern conflicts
- * - Task scope violations
- * - Handoff context loss
- * 
- * @since v2.14.0
- */
-
-import { Gate, GateContext } from './base.js';
-import { Failure } from '../types/index.js';
-import { Logger } from '../utils/logger.js';
-import * as fs from 'fs';
-import * as path from 'path';
-
-export interface AgentRegistration {
-    agentId: string;
-    taskScope: string[];  // Glob patterns for files this agent owns
-    registeredAt: Date;
-    lastActivity?: Date;
-}
-
-export interface AgentTeamSession {
-    sessionId: string;
-    agents: AgentRegistration[];
-    startedAt: Date;
-}
-
-export interface AgentTeamConfig {
-    enabled?: boolean;
-    max_concurrent_agents?: number;
-    cross_agent_pattern_check?: boolean;
-    handoff_verification?: boolean;
-    task_ownership?: 'strict' | 'collaborative';
-}
-
-// In-memory session store (persisted to .rigour/agent-session.json)
-let currentSession: AgentTeamSession | null = null;
-
-/**
- * Register an agent in the current session
- */
-export function registerAgent(cwd: string, agentId: string, taskScope: string[]): AgentTeamSession {
-    if (!currentSession) {
-        currentSession = {
-            sessionId: `session-${Date.now()}`,
-            agents: [],
-            startedAt: new Date(),
-        };
-    }
-
-    // Check if agent already registered
-    const existing = currentSession.agents.find(a => a.agentId === agentId);
-    if (existing) {
-        existing.taskScope = taskScope;
-        existing.lastActivity = new Date();
-    } else {
-        currentSession.agents.push({
-            agentId,
-            taskScope,
-            registeredAt: new Date(),
-        });
-    }
-
-    // Persist session
-    persistSession(cwd);
-    return currentSession;
-}
-
-/**
- * Get current session status
- */
-export function getSession(cwd: string): AgentTeamSession | null {
-    if (!currentSession) {
-        loadSession(cwd);
-    }
-    return currentSession;
-}
-
-/**
- * Clear current session
- */
-export function clearSession(cwd: string): void {
-    currentSession = null;
-    const sessionPath = path.join(cwd, '.rigour', 'agent-session.json');
-    if (fs.existsSync(sessionPath)) {
-        fs.unlinkSync(sessionPath);
-    }
-}
-
-function persistSession(cwd: string): void {
-    const rigourDir = path.join(cwd, '.rigour');
-    if (!fs.existsSync(rigourDir)) {
-        fs.mkdirSync(rigourDir, { recursive: true });
-    }
-    const sessionPath = path.join(rigourDir, 'agent-session.json');
-    fs.writeFileSync(sessionPath, JSON.stringify(currentSession, null, 2));
-}
-
-function loadSession(cwd: string): void {
-    const sessionPath = path.join(cwd, '.rigour', 'agent-session.json');
-    if (fs.existsSync(sessionPath)) {
-        try {
-            const data = JSON.parse(fs.readFileSync(sessionPath, 'utf-8'));
-            currentSession = {
-                ...data,
-                startedAt: new Date(data.startedAt),
-                agents: data.agents.map((a: any) => ({
-                    ...a,
-                    registeredAt: new Date(a.registeredAt),
-                    lastActivity: a.lastActivity ? new Date(a.lastActivity) : undefined,
-                })),
-            };
-        } catch (err) {
-            Logger.warn('Failed to load agent session, starting fresh');
-            currentSession = null;
-        }
-    }
-}
-
-/**
- * Check if two glob patterns might overlap
- */
-function scopesOverlap(scope1: string[], scope2: string[]): string[] {
-    const overlapping: string[] = [];
-    for (const s1 of scope1) {
-        for (const s2 of scope2) {
-            // Simple overlap detection - same path or one is prefix of other
-            if (s1 === s2 || s1.startsWith(s2.replace('**', '')) || s2.startsWith(s1.replace('**', ''))) {
-                overlapping.push(`${s1} ↔ ${s2}`);
-            }
-        }
-    }
-    return overlapping;
-}
-
-export class AgentTeamGate extends Gate {
-    private config: AgentTeamConfig;
-
-    constructor(config: AgentTeamConfig = {}) {
-        super('agent-team', 'Agent Team Governance');
-        this.config = {
-            enabled: config.enabled ?? false,
-            max_concurrent_agents: config.max_concurrent_agents ?? 3,
-            cross_agent_pattern_check: config.cross_agent_pattern_check ?? true,
-            handoff_verification: config.handoff_verification ?? true,
-            task_ownership: config.task_ownership ?? 'strict',
-        };
-    }
-
-    async run(context: GateContext): Promise<Failure[]> {
-        if (!this.config.enabled) {
-            return [];
-        }
-
-        const failures: Failure[] = [];
-        const session = getSession(context.cwd);
-
-        if (!session || session.agents.length === 0) {
-            // No multi-agent session active, skip
-            return [];
-        }
-
-        Logger.info(`Agent Team Gate: ${session.agents.length} agents in session`);
-
-        // Check 1: Max concurrent agents
-        if (session.agents.length > (this.config.max_concurrent_agents ?? 3)) {
-            failures.push(this.createFailure(
-                `Too many concurrent agents: ${session.agents.length} (max: ${this.config.max_concurrent_agents})`,
-                undefined,
-                'Reduce the number of concurrent agents or increase max_concurrent_agents in rigour.yml',
-                'Too Many Concurrent Agents'
-            ));
-        }
-
-        // Check 2: Task scope conflicts (strict mode only)
-        if (this.config.task_ownership === 'strict') {
-            for (let i = 0; i < session.agents.length; i++) {
-                for (let j = i + 1; j < session.agents.length; j++) {
-                    const agent1 = session.agents[i];
-                    const agent2 = session.agents[j];
-                    const overlaps = scopesOverlap(agent1.taskScope, agent2.taskScope);
-
-                    if (overlaps.length > 0) {
-                        failures.push(this.createFailure(
-                            `Task scope conflict between ${agent1.agentId} and ${agent2.agentId}: ${overlaps.join(', ')}`,
-                            undefined,
-                            'In strict mode, each agent must have exclusive task scope. Either adjust scopes or set task_ownership: collaborative',
-                            'Task Scope Conflict'
-                        ));
-                    }
-                }
-            }
-        }
-
-        // Check 3: Cross-agent pattern detection (if enabled)
-        if (this.config.cross_agent_pattern_check && context.record) {
-            // This would integrate with the Pattern Index to detect conflicting patterns
-            // For now, we log that we would do this check
-            Logger.debug('Cross-agent pattern check: would analyze patterns across agent scopes');
-        }
-
-        return failures;
-    }
-}

package/src/gates/ast-handlers/base.ts

@@ -1,13 +0,0 @@
-import { Failure, Gates } from '../../types/index.js';
-
-export interface ASTHandlerContext {
-    cwd: string;
-    file: string;
-    content: string;
-}
-
-export abstract class ASTHandler {
-    constructor(protected config: Gates) { }
-    abstract supports(file: string): boolean;
-    abstract run(context: ASTHandlerContext): Promise<Failure[]>;
-}