@rigour-labs/core 2.21.2 → 3.0.0

package/src/templates/index.ts

@@ -1,312 +0,0 @@
-import { Config, Commands, Gates } from '../types/index.js';
-
-export interface Template {
-    name: string;
-    markers: string[];
-    config: {
-        preset?: string;
-        paradigm?: string;
-        commands?: Partial<Commands>;
-        gates?: Partial<Gates>;
-        planned?: string[];
-        ignore?: string[];
-    };
-}
-
-export const TEMPLATES: Template[] = [
-    {
-        name: 'ui',
-        markers: [
-            'react',
-            'next',
-            'vue',
-            'svelte',
-            'next.config.js',
-            'vite.config.ts',
-            'tailwind.config.js',
-            'base.css',
-            'index.html',
-        ],
-        config: {
-            preset: 'ui',
-            ignore: [
-                '.git/**',
-                'node_modules/**',
-                'dist/**',
-                'build/**',
-                '.next/**',
-                '.nuxt/**',
-                '.svelte-kit/**',
-                'coverage/**',
-                '.turbo/**',
-            ],
-            gates: {
-                max_file_lines: 300,
-                required_files: ['docs/SPEC.md', 'docs/ARCH.md', 'README.md'],
-            },
-            planned: [
-                'Layer Boundary: Components cannot import from DB',
-                'Prop-Drilling Detection: Max depth 5',
-            ],
-        },
-    },
-    {
-        name: 'api',
-        markers: [
-            'express',
-            'fastify',
-            'nestjs',
-            'go.mod',
-            'requirements.txt',
-            'pyproject.toml',
-            'app.py',
-            'main.go',
-            'index.js',
-        ],
-        config: {
-            preset: 'api',
-            ignore: [
-                '.git/**',
-                // Node.js
-                'node_modules/**',
-                'dist/**',
-                // Python
-                'venv/**',
-                '.venv/**',
-                '__pycache__/**',
-                '*.pyc',
-                '.tox/**',
-                '.pytest_cache/**',
-                '.mypy_cache/**',
-                '*.egg-info/**',
-                // Go
-                'vendor/**',
-            ],
-            gates: {
-                max_file_lines: 400,
-                required_files: ['docs/SPEC.md', 'docs/ARCH.md', 'README.md'],
-            },
-            planned: [
-                'Service Layer Enforcement: Controllers -> Services only',
-                'Repo Pattern: Databases access isolated to repositories/',
-            ],
-        },
-    },
-    {
-        name: 'infra',
-        markers: [
-            'Dockerfile',
-            'docker-compose.yml',
-            'main.tf',
-            'k8s/',
-            'helm/',
-            'ansible/',
-        ],
-        config: {
-            preset: 'infra',
-            ignore: [
-                '.git/**',
-                '.terraform/**',
-                '*.tfstate',
-                '*.tfstate.backup',
-                '.terragrunt-cache/**',
-                'charts/**/*.tgz',
-            ],
-            gates: {
-                max_file_lines: 300,
-                required_files: ['docs/RUNBOOK.md', 'docs/ARCH.md', 'README.md'],
-            },
-        },
-    },
-    {
-        name: 'data',
-        markers: [
-            'ipynb',
-            'spark',
-            'pandas',
-            'data/',
-            'dbt_project.yml',
-        ],
-        config: {
-            preset: 'data',
-            ignore: [
-                '.git/**',
-                '.ipynb_checkpoints/**',
-                '__pycache__/**',
-                '*.pyc',
-                'dbt_packages/**',
-                'target/**',
-                'logs/**',
-                '*.parquet',
-                '*.csv',
-            ],
-            gates: {
-                max_file_lines: 500,
-                required_files: ['docs/DATA_DICTIONARY.md', 'docs/PIPELINE.md', 'README.md'],
-            },
-            planned: [
-                'Stochastic Determinism: Seed setting enforcement',
-                'Data Leaks: Detecting PII in notebook outputs',
-            ],
-        },
-    },
-];
-
-export const PARADIGM_TEMPLATES: Template[] = [
-    {
-        name: 'oop',
-        markers: [
-            'class ',
-            'interface ',
-            'implements ',
-            'extends ',
-            'constructor(',
-            'private ',
-            'public ',
-            'protected ',
-        ],
-        config: {
-            paradigm: 'oop',
-            gates: {
-                max_file_lines: 400,
-                ast: {
-                    complexity: 10,
-                    max_methods: 10,
-                    max_params: 5,
-                    max_nesting: 4,
-                    max_inheritance_depth: 3,
-                    max_class_dependencies: 5,
-                    max_function_lines: 60,
-                },
-            },
-        },
-    },
-    {
-        name: 'functional',
-        // Removed '=>' as primary marker - too broad (appears in OOP callbacks)
-        markers: [
-            'export const',
-            'reduce(',
-            '.pipe(',
-            'compose(',
-            'curry(',
-            'readonly ',
-        ],
-        config: {
-            paradigm: 'functional',
-            gates: {
-                max_file_lines: 350,
-                ast: {
-                    complexity: 8,
-                    max_methods: 15, // Functions, not classes
-                    max_params: 4,
-                    max_nesting: 3,
-                    max_inheritance_depth: 3,
-                    max_class_dependencies: 5,
-                    max_function_lines: 40,
-                },
-            },
-        },
-    },
-];
-
-export const UNIVERSAL_CONFIG: Config = {
-    version: 1,
-    commands: {},
-    gates: {
-        max_file_lines: 500,
-        forbid_todos: true,
-        forbid_fixme: true,
-        forbid_paths: [],
-        required_files: ['docs/SPEC.md', 'docs/ARCH.md', 'docs/DECISIONS.md', 'docs/TASKS.md'],
-        ast: {
-            complexity: 10,
-            max_methods: 10,
-            max_params: 5,
-            max_nesting: 4,
-            max_inheritance_depth: 3,
-            max_class_dependencies: 5,
-            max_function_lines: 50,
-        },
-        dependencies: {
-            forbid: [],
-        },
-        architecture: {
-            boundaries: [],
-        },
-        safety: {
-            max_files_changed_per_cycle: 10,
-            protected_paths: ['.github/**', 'docs/**', 'rigour.yml'],
-        },
-        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,
-        },
-        environment: {
-            enabled: true,
-            enforce_contracts: true,
-            tools: {},
-            required_env: [],
-        },
-        retry_loop_breaker: {
-            enabled: true,
-            max_retries: 3,
-            auto_classify: true,
-            doc_sources: {},
-        },
-        agent_team: {
-            enabled: false,
-            max_concurrent_agents: 3,
-            cross_agent_pattern_check: true,
-            handoff_verification: true,
-            task_ownership: 'strict',
-        },
-        checkpoint: {
-            enabled: false,
-            interval_minutes: 15,
-            quality_threshold: 80,
-            drift_detection: true,
-            auto_save_on_failure: true,
-        },
-        security: {
-            enabled: true,
-            sql_injection: true,
-            xss: true,
-            path_traversal: true,
-            hardcoded_secrets: true,
-            insecure_randomness: true,
-            command_injection: true,
-            block_on_severity: 'high',
-        },
-        adaptive: {
-            enabled: false,
-            base_coverage_threshold: 80,
-            base_quality_threshold: 80,
-            auto_detect_tier: true,
-        },
-        staleness: {
-            enabled: false,
-            rules: {
-                'no-var': true,
-                'no-commonjs': false,
-                'no-arguments': false,
-                'prefer-arrow': false,
-                'prefer-template': false,
-                'prefer-spread': false,
-                'prefer-rest': false,
-                'prefer-const': false,
-            },
-        },
-    },
-    output: {
-        report_path: 'rigour-report.json',
-    },
-    planned: [],
-    ignore: [],
-};

package/src/types/fix-packet.ts

@@ -1,32 +0,0 @@
-import { z } from 'zod';
-
-/**
- * Fix Packet v2 Schema
- * Designed for high-fidelity communication with AI agents during the refinement loop.
- */
-export const FixPacketV2Schema = z.object({
-    version: z.literal(2),
-    goal: z.string().default('Achieve PASS state for all quality gates'),
-    violations: z.array(z.object({
-        id: z.string(),
-        gate: z.string(),
-        severity: z.enum(['low', 'medium', 'high', 'critical']).default('medium'),
-        category: z.string().optional(),
-        title: z.string(),
-        details: z.string(),
-        files: z.array(z.string()).optional(),
-        hint: z.string().optional(),
-        instructions: z.array(z.string()).optional(), // Step-by-step fix instructions
-        metrics: z.record(z.any()).optional(), // e.g., { complexity: 15, max: 10 }
-    })),
-    constraints: z.object({
-        protected_paths: z.array(z.string()).optional(),
-        do_not_touch: z.array(z.string()).optional(), // Alias for protected_paths
-        max_files_changed: z.number().optional(),
-        no_new_deps: z.boolean().optional().default(true),
-        allowed_dependencies: z.array(z.string()).optional(),
-        paradigm: z.string().optional(), // 'oop', 'functional'
-    }).optional().default({}),
-});
-
-export type FixPacketV2 = z.infer<typeof FixPacketV2Schema>;

package/src/types/index.ts

@@ -1,159 +0,0 @@
-import { z } from 'zod';
-
-export const GatesSchema = z.object({
-    max_file_lines: z.number().optional().default(500),
-    forbid_todos: z.boolean().optional().default(true),
-    forbid_fixme: z.boolean().optional().default(true),
-    forbid_paths: z.array(z.string()).optional().default([]),
-    required_files: z.array(z.string()).optional().default([
-        'docs/SPEC.md',
-        'docs/ARCH.md',
-        'docs/DECISIONS.md',
-        'docs/TASKS.md',
-    ]),
-    ast: z.object({
-        complexity: z.number().optional().default(10),
-        max_methods: z.number().optional().default(10),
-        max_params: z.number().optional().default(5),
-        max_nesting: z.number().optional().default(4),
-        max_inheritance_depth: z.number().optional().default(3),
-        max_class_dependencies: z.number().optional().default(5),
-        max_function_lines: z.number().optional().default(50),
-    }).optional().default({}),
-    staleness: z.object({
-        enabled: z.boolean().optional().default(false),
-        // Rule-based staleness detection (toggle individual rules)
-        rules: z.record(z.boolean()).optional().default({
-            'no-var': true,              // var → const/let (ES6+)
-            'no-commonjs': false,        // require() → import
-            'no-arguments': false,       // arguments → rest params
-            'prefer-arrow': false,       // function → arrow function
-            'prefer-template': false,    // 'a' + b → `a${b}`
-            'prefer-spread': false,      // apply() → spread
-            'prefer-rest': false,        // arguments → ...args
-            'prefer-const': false,       // let (unchanged) → const
-        }),
-    }).optional().default({}),
-    dependencies: z.object({
-        forbid: z.array(z.string()).optional().default([]),
-        trusted_registry: z.string().optional(),
-    }).optional().default({}),
-    architecture: z.object({
-        boundaries: z.array(z.object({
-            from: z.string(),
-            to: z.string(),
-            mode: z.enum(['allow', 'deny']).default('deny'),
-        })).optional().default([]),
-    }).optional().default({}),
-    safety: z.object({
-        max_files_changed_per_cycle: z.number().optional().default(10),
-        protected_paths: z.array(z.string()).optional().default(['.github/**', 'docs/**', 'rigour.yml']),
-    }).optional().default({}),
-    context: z.object({
-        enabled: z.boolean().optional().default(true),
-        sensitivity: z.number().min(0).max(1).optional().default(0.8), // 0.8 correlation threshold
-        mining_depth: z.number().optional().default(100), // Number of files to sample
-        ignored_patterns: z.array(z.string()).optional().default([]),
-        // v2.14+ Extended Context for frontier models
-        cross_file_patterns: z.boolean().optional().default(true),
-        naming_consistency: z.boolean().optional().default(true),
-        import_relationships: z.boolean().optional().default(true),
-        max_cross_file_depth: z.number().optional().default(50),
-    }).optional().default({}),
-    environment: z.object({
-        enabled: z.boolean().optional().default(true),
-        enforce_contracts: z.boolean().optional().default(true), // Auto-discovery of versions from truth sources
-        tools: z.record(z.string()).optional().default({}), // Explicit overrides
-        required_env: z.array(z.string()).optional().default([]),
-    }).optional().default({}),
-    retry_loop_breaker: z.object({
-        enabled: z.boolean().optional().default(true),
-        max_retries: z.number().optional().default(3), // Fail after 3 consecutive failures in same category
-        auto_classify: z.boolean().optional().default(true), // Auto-detect failure category from error message
-        doc_sources: z.record(z.string()).optional().default({}), // Custom doc URLs per category
-    }).optional().default({}),
-    agent_team: z.object({
-        enabled: z.boolean().optional().default(false),
-        max_concurrent_agents: z.number().optional().default(3),
-        cross_agent_pattern_check: z.boolean().optional().default(true),
-        handoff_verification: z.boolean().optional().default(true),
-        task_ownership: z.enum(['strict', 'collaborative']).optional().default('strict'),
-    }).optional().default({}),
-    checkpoint: z.object({
-        enabled: z.boolean().optional().default(false),
-        interval_minutes: z.number().optional().default(15),
-        quality_threshold: z.number().optional().default(80),
-        drift_detection: z.boolean().optional().default(true),
-        auto_save_on_failure: z.boolean().optional().default(true),
-    }).optional().default({}),
-    security: z.object({
-        enabled: z.boolean().optional().default(true),
-        sql_injection: z.boolean().optional().default(true),
-        xss: z.boolean().optional().default(true),
-        path_traversal: z.boolean().optional().default(true),
-        hardcoded_secrets: z.boolean().optional().default(true),
-        insecure_randomness: z.boolean().optional().default(true),
-        command_injection: z.boolean().optional().default(true),
-        block_on_severity: z.enum(['critical', 'high', 'medium', 'low']).optional().default('high'),
-    }).optional().default({}),
-    adaptive: z.object({
-        enabled: z.boolean().optional().default(false),
-        base_coverage_threshold: z.number().optional().default(80),
-        base_quality_threshold: z.number().optional().default(80),
-        auto_detect_tier: z.boolean().optional().default(true),
-        forced_tier: z.enum(['hobby', 'startup', 'enterprise']).optional(),
-    }).optional().default({}),
-});
-
-export const CommandsSchema = z.object({
-    format: z.string().optional(),
-    lint: z.string().optional(),
-    typecheck: z.string().optional(),
-    test: z.string().optional(),
-});
-
-export const ConfigSchema = z.object({
-    version: z.number().default(1),
-    preset: z.string().optional(),
-    paradigm: z.string().optional(),
-    commands: CommandsSchema.optional().default({}),
-    gates: GatesSchema.optional().default({}),
-    output: z.object({
-        report_path: z.string().default('rigour-report.json'),
-    }).optional().default({}),
-    planned: z.array(z.string()).optional().default([]),
-    ignore: z.array(z.string()).optional().default([]),
-});
-
-export type Gates = z.infer<typeof GatesSchema>;
-export type Commands = z.infer<typeof CommandsSchema>;
-export type Config = z.infer<typeof ConfigSchema>;
-
-export type RawGates = z.input<typeof GatesSchema>;
-export type RawCommands = z.input<typeof CommandsSchema>;
-export type RawConfig = z.input<typeof ConfigSchema>;
-
-export const StatusSchema = z.enum(['PASS', 'FAIL', 'SKIP', 'ERROR']);
-export type Status = z.infer<typeof StatusSchema>;
-
-export const FailureSchema = z.object({
-    id: z.string(),
-    title: z.string(),
-    details: z.string(),
-    files: z.array(z.string()).optional(),
-    line: z.number().optional(),
-    endLine: z.number().optional(),
-    hint: z.string().optional(),
-});
-export type Failure = z.infer<typeof FailureSchema>;
-
-export const ReportSchema = z.object({
-    status: StatusSchema,
-    summary: z.record(StatusSchema),
-    failures: z.array(FailureSchema),
-    stats: z.object({
-        duration_ms: z.number(),
-        score: z.number().optional(),
-    }),
-});
-export type Report = z.infer<typeof ReportSchema>;

package/src/utils/logger.ts

@@ -1,43 +0,0 @@
-import chalk from 'chalk';
-
-export enum LogLevel {
-    DEBUG = 0,
-    INFO = 1,
-    WARN = 2,
-    ERROR = 3,
-}
-
-export class Logger {
-    private static level: LogLevel = LogLevel.INFO;
-
-    static setLevel(level: LogLevel) {
-        this.level = level;
-    }
-
-    static info(message: string) {
-        if (this.level <= LogLevel.INFO) {
-            console.error(chalk.blue('info: ') + message);
-        }
-    }
-
-    static warn(message: string) {
-        if (this.level <= LogLevel.WARN) {
-            console.error(chalk.yellow('warn: ') + message);
-        }
-    }
-
-    static error(message: string, error?: any) {
-        if (this.level <= LogLevel.ERROR) {
-            console.error(chalk.red('error: ') + message);
-            if (error) {
-                console.error(error);
-            }
-        }
-    }
-
-    static debug(message: string) {
-        if (this.level <= LogLevel.DEBUG) {
-            console.error(chalk.dim('debug: ') + message);
-        }
-    }
-}

package/src/utils/scanner.test.ts

@@ -1,37 +0,0 @@
-import { describe, it, expect, vi } from 'vitest';
-import { FileScanner } from './scanner.js';
-import { globby } from 'globby';
-
-vi.mock('globby', () => ({
-    globby: vi.fn(),
-}));
-
-describe('FileScanner', () => {
-    it('should merge default ignores with user ignores', async () => {
-        const options = {
-            cwd: '/test',
-            ignore: ['custom-ignore']
-        };
-
-        await FileScanner.findFiles(options);
-
-        const call = vi.mocked(globby).mock.calls[0];
-        const ignore = (call[1] as any).ignore;
-
-        expect(ignore).toContain('**/node_modules/**');
-        expect(ignore).toContain('custom-ignore');
-    });
-
-    it('should normalize paths to forward slashes', async () => {
-        const options = {
-            cwd: 'C:\\test\\path',
-            patterns: ['**\\*.ts']
-        };
-
-        await FileScanner.findFiles(options);
-
-        const call = vi.mocked(globby).mock.calls[1];
-        expect(call[0][0]).toBe('**/*.ts');
-        expect(call[1]?.cwd).toBe('C:/test/path');
-    });
-});

package/src/utils/scanner.ts

@@ -1,43 +0,0 @@
-import { globby } from 'globby';
-import fs from 'fs-extra';
-import path from 'path';
-
-export interface ScannerOptions {
-    cwd: string;
-    patterns?: string[];
-    ignore?: string[];
-}
-
-export class FileScanner {
-    private static DEFAULT_PATTERNS = ['**/*.{ts,js,py,css,html,md}'];
-    private static DEFAULT_IGNORE = [
-        '**/node_modules/**',
-        '**/dist/**',
-        '**/package-lock.json',
-        '**/pnpm-lock.yaml',
-        '**/.git/**',
-        'rigour-report.json'
-    ];
-
-    static async findFiles(options: ScannerOptions): Promise<string[]> {
-        const patterns = (options.patterns || this.DEFAULT_PATTERNS).map(p => p.replace(/\\/g, '/'));
-        const userIgnore = options.ignore || [];
-        const ignore = [...new Set([...this.DEFAULT_IGNORE, ...userIgnore])].map(p => p.replace(/\\/g, '/'));
-        const normalizedCwd = options.cwd.replace(/\\/g, '/');
-
-        return globby(patterns, {
-            cwd: normalizedCwd,
-            ignore: ignore,
-        });
-    }
-
-    static async readFiles(cwd: string, files: string[]): Promise<Map<string, string>> {
-        const contents = new Map<string, string>();
-        for (const file of files) {
-            const normalizedFile = file.replace(/\//g, path.sep);
-            const filePath = path.isAbsolute(normalizedFile) ? normalizedFile : path.join(cwd, normalizedFile);
-            contents.set(file, await fs.readFile(filePath, 'utf-8'));
-        }
-        return contents;
-    }
-}

package/tsconfig.json

@@ -1,10 +0,0 @@
-{
-    "extends": "../../tsconfig.json",
-    "compilerOptions": {
-        "outDir": "dist",
-        "rootDir": "src"
-    },
-    "include": [
-        "src/**/*"
-    ]
-}

package/vitest.config.ts

@@ -1,7 +0,0 @@
-import { defineConfig } from 'vitest/config';
-
-export default defineConfig({
-    test: {
-        setupFiles: ['./vitest.setup.ts'],
-    },
-});

package/vitest.setup.ts

@@ -1,30 +0,0 @@
-import { vi } from 'vitest';
-
-// Mock Transformers.js to avoid native binary dependency issues and speed up tests
-vi.mock('@xenova/transformers', () => ({
-    pipeline: async () => {
-        // Return a mock extractor that produces deterministic "embeddings"
-        return async (text: string) => {
-            // Create a fake vector based on the text length or hash
-            const vector = new Array(384).fill(0);
-            for (let i = 0; i < Math.min(text.length, 384); i++) {
-                vector[i] = text.charCodeAt(i) / 255;
-            }
-            return { data: new Float32Array(vector) };
-        };
-    },
-    env: {
-        allowImageProcessors: false,
-    },
-}));
-
-// Also mock sharp just in case something else pulls it in
-vi.mock('sharp', () => ({
-    default: () => ({
-        resize: () => ({
-            toFormat: () => ({
-                toBuffer: async () => Buffer.from([]),
-            }),
-        }),
-    }),
-}));