@rigour-labs/core 2.21.2 → 3.0.0

package/src/context.test.ts

@@ -1,256 +0,0 @@
-import { describe, it, expect, beforeAll, afterAll } from 'vitest';
-import { GateRunner } from '../src/gates/runner.js';
-import fs from 'fs-extra';
-import path from 'path';
-import { fileURLToPath } from 'url';
-
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-const TEST_CWD = path.join(__dirname, '../temp-test-context');
-
-describe('Context Awareness Engine', () => {
-    beforeAll(async () => {
-        await fs.ensureDir(TEST_CWD);
-    });
-
-    afterAll(async () => {
-        await fs.remove(TEST_CWD);
-    });
-
-    it('should detect context drift for redundant env suffixes (Golden Example)', async () => {
-        // Setup: Define standard GCP_PROJECT_ID
-        await fs.writeFile(path.join(TEST_CWD, '.env.example'), 'GCP_PROJECT_ID=my-project\n');
-
-        // Setup: Use drifted GCP_PROJECT_ID_PRODUCTION
-        await fs.writeFile(path.join(TEST_CWD, 'feature.js'), `
-            const id = process.env.GCP_PROJECT_ID_PRODUCTION;
-            console.log(id);
-        `);
-
-        const config = {
-            version: 1,
-            commands: {},
-            gates: {
-                context: {
-                    enabled: true,
-                    sensitivity: 0.8,
-                    mining_depth: 10,
-                    ignored_patterns: [],
-                    cross_file_patterns: true,
-                    naming_consistency: true,
-                    import_relationships: true,
-                    max_cross_file_depth: 50,
-                },
-            },
-            output: { report_path: 'rigour-report.json' }
-        };
-
-        const runner = new GateRunner(config as any);
-        const report = await runner.run(TEST_CWD);
-
-        const driftFailures = report.failures.filter(f => f.id === 'context-drift');
-        expect(driftFailures.length).toBeGreaterThan(0);
-        expect(driftFailures[0].details).toContain('GCP_PROJECT_ID_PRODUCTION');
-        expect(driftFailures[0].hint).toContain('GCP_PROJECT_ID');
-    });
-
-    it('should not flag valid environment variables', async () => {
-        await fs.writeFile(path.join(TEST_CWD, 'valid.js'), `
-            const id = process.env.GCP_PROJECT_ID;
-        `);
-
-        const config = {
-            version: 1,
-            commands: {},
-            gates: {
-                context: {
-                    enabled: true,
-                    sensitivity: 0.8,
-                    mining_depth: 100,
-                    ignored_patterns: [],
-                    cross_file_patterns: true,
-                    naming_consistency: true,
-                    import_relationships: true,
-                    max_cross_file_depth: 50,
-                },
-            },
-            output: { report_path: 'rigour-report.json' }
-        };
-
-        const runner = new GateRunner(config as any);
-        const report = await runner.run(TEST_CWD);
-
-        const driftFailures = report.failures.filter(f => f.id === 'context-drift');
-        // Filter out failures from other files if they still exist in TEST_CWD
-        const specificFailures = driftFailures.filter(f => f.files?.includes('valid.js'));
-        expect(specificFailures.length).toBe(0);
-    });
-    it('should classify arrow function exports as camelCase, not unknown', async () => {
-        // Create files with arrow function patterns that previously returned 'unknown'
-        await fs.writeFile(path.join(TEST_CWD, 'api.ts'), `
-            export const fetchData = async () => { return []; };
-            export const getUserProfile = async (id: string) => { return {}; };
-            export const use = () => {};
-            export const get = async () => {};
-            const handleClick = (e: Event) => {};
-            let processItem = async (item: any) => {};
-        `);
-
-        // Create a second file with consistent arrow function naming
-        await fs.writeFile(path.join(TEST_CWD, 'service.ts'), `
-            export const createUser = async (data: any) => {};
-            export const deleteUser = async (id: string) => {};
-            export const updateUser = async (id: string, data: any) => {};
-        `);
-
-        const config = {
-            version: 1,
-            commands: {},
-            gates: {
-                context: {
-                    enabled: true,
-                    sensitivity: 0.8,
-                    mining_depth: 10,
-                    ignored_patterns: [],
-                    cross_file_patterns: true,
-                    naming_consistency: true,
-                    import_relationships: true,
-                    max_cross_file_depth: 50,
-                },
-            },
-            output: { report_path: 'rigour-report.json' }
-        };
-
-        const runner = new GateRunner(config as any);
-        const report = await runner.run(TEST_CWD);
-
-        // Should NOT have any "unknown" naming convention failures
-        const namingFailures = report.failures.filter(f =>
-            f.id === 'context-drift' && f.details?.includes('unknown')
-        );
-        expect(namingFailures.length).toBe(0);
-    });
-
-    it('should not classify plain variable declarations as function patterns', async () => {
-        // Create file with non-function const declarations
-        await fs.writeFile(path.join(TEST_CWD, 'constants.ts'), `
-            export const API_URL = 'https://api.example.com';
-            export const MAX_RETRIES = 3;
-            const config = { timeout: 5000 };
-            let count = 0;
-        `);
-
-        // Create file with actual functions for a dominant pattern
-        await fs.writeFile(path.join(TEST_CWD, 'utils.ts'), `
-            function getData() { return []; }
-            function setData(d: any) { return d; }
-            function processRequest(req: any) { return req; }
-        `);
-
-        const config = {
-            version: 1,
-            commands: {},
-            gates: {
-                context: {
-                    enabled: true,
-                    sensitivity: 0.8,
-                    mining_depth: 10,
-                    ignored_patterns: [],
-                    cross_file_patterns: true,
-                    naming_consistency: true,
-                    import_relationships: true,
-                    max_cross_file_depth: 50,
-                },
-            },
-            output: { report_path: 'rigour-report.json' }
-        };
-
-        const runner = new GateRunner(config as any);
-        const report = await runner.run(TEST_CWD);
-
-        // SCREAMING_SNAKE constants should NOT create naming drift failures
-        // because they should not be in the 'function' pattern bucket at all
-        const namingFailures = report.failures.filter(f =>
-            f.id === 'context-drift' && f.details?.includes('SCREAMING_SNAKE')
-        );
-        expect(namingFailures.length).toBe(0);
-    });
-});
-
-/**
- * Direct unit tests for detectCasing logic
- */
-describe('detectCasing classification', () => {
-    // We test the regex rules directly since detectCasing is private
-    function detectCasing(name: string): string {
-        if (/^[A-Z][a-z]/.test(name) && /[a-z][A-Z]/.test(name)) return 'PascalCase';
-        if (/^[a-z]/.test(name) && /[a-z][A-Z]/.test(name)) return 'camelCase';
-        if (/^[a-z][a-zA-Z0-9]*$/.test(name)) return 'camelCase';  // single-word lowercase
-        if (/^[a-z]+(_[a-z]+)+$/.test(name)) return 'snake_case';
-        if (/^[A-Z]+(_[A-Z]+)*$/.test(name)) return 'SCREAMING_SNAKE';
-        if (/^[A-Z][a-zA-Z]*$/.test(name)) return 'PascalCase';
-        return 'unknown';
-    }
-
-    // Multi-word camelCase
-    it('classifies multi-word camelCase', () => {
-        expect(detectCasing('fetchData')).toBe('camelCase');
-        expect(detectCasing('getUserProfile')).toBe('camelCase');
-        expect(detectCasing('handleClick')).toBe('camelCase');
-        expect(detectCasing('processItem')).toBe('camelCase');
-        expect(detectCasing('createNewUser')).toBe('camelCase');
-    });
-
-    // Single-word lowercase (the bug fix)
-    it('classifies single-word lowercase as camelCase', () => {
-        expect(detectCasing('fetch')).toBe('camelCase');
-        expect(detectCasing('use')).toBe('camelCase');
-        expect(detectCasing('get')).toBe('camelCase');
-        expect(detectCasing('set')).toBe('camelCase');
-        expect(detectCasing('run')).toBe('camelCase');
-        expect(detectCasing('a')).toBe('camelCase');
-        expect(detectCasing('x')).toBe('camelCase');
-        expect(detectCasing('id')).toBe('camelCase');
-    });
-
-    // Single-word lowercase with digits
-    it('classifies lowercase with digits as camelCase', () => {
-        expect(detectCasing('handler2')).toBe('camelCase');
-        expect(detectCasing('config3')).toBe('camelCase');
-        expect(detectCasing('v2')).toBe('camelCase');
-    });
-
-    // PascalCase
-    it('classifies PascalCase', () => {
-        expect(detectCasing('MyComponent')).toBe('PascalCase');
-        expect(detectCasing('UserService')).toBe('PascalCase');
-        expect(detectCasing('App')).toBe('PascalCase');
-        expect(detectCasing('A')).toBe('SCREAMING_SNAKE'); // single uppercase letter
-    });
-
-    // snake_case
-    it('classifies snake_case', () => {
-        expect(detectCasing('my_func')).toBe('snake_case');
-        expect(detectCasing('get_data')).toBe('snake_case');
-        expect(detectCasing('process_all_items')).toBe('snake_case');
-    });
-
-    // SCREAMING_SNAKE
-    it('classifies SCREAMING_SNAKE_CASE', () => {
-        expect(detectCasing('API_URL')).toBe('SCREAMING_SNAKE');
-        expect(detectCasing('MAX_RETRIES')).toBe('SCREAMING_SNAKE');
-        expect(detectCasing('A')).toBe('SCREAMING_SNAKE');
-        expect(detectCasing('DB')).toBe('SCREAMING_SNAKE');
-    });
-
-    // Edge cases that should NOT be unknown
-    it('does not return unknown for valid identifiers', () => {
-        const validIdentifiers = [
-            'fetch', 'getData', 'MyClass', 'my_func', 'API_KEY',
-            'use', 'run', 'a', 'x', 'id', 'App', 'handler2',
-            'processItem', 'UserProfile', 'get_all_data', 'MAX_SIZE',
-        ];
-        for (const name of validIdentifiers) {
-            expect(detectCasing(name)).not.toBe('unknown');
-        }
-    });
-});

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');
-    });
-});