@rigour-labs/core 2.21.2 → 3.0.0

package/src/services/adaptive-thresholds.ts

@@ -1,275 +0,0 @@
-/**
- * Adaptive Thresholds Service
- * 
- * Dynamically adjusts quality gate thresholds based on:
- * - Project maturity (age, commit count, file count)
- * - Historical failure rates
- * - Complexity tier (hobby/startup/enterprise)
- * - Recent trends (improving/degrading)
- * 
- * This enables Rigour to be "strict but fair" - new projects get
- * more lenient thresholds while mature codebases are held to higher standards.
- * 
- * @since v2.14.0
- */
-
-import * as fs from 'fs';
-import * as path from 'path';
-import { Logger } from '../utils/logger.js';
-
-export type ComplexityTier = 'hobby' | 'startup' | 'enterprise';
-export type QualityTrend = 'improving' | 'stable' | 'degrading';
-
-export interface ProjectMetrics {
-    fileCount: number;
-    commitCount?: number;
-    ageInDays?: number;
-    testCoverage?: number;
-    recentFailureRate?: number;
-}
-
-export interface AdaptiveConfig {
-    enabled?: boolean;
-    base_coverage_threshold?: number;
-    base_quality_threshold?: number;
-    auto_detect_tier?: boolean;
-    forced_tier?: ComplexityTier;
-}
-
-export interface ThresholdAdjustments {
-    tier: ComplexityTier;
-    trend: QualityTrend;
-    coverageThreshold: number;
-    qualityThreshold: number;
-    securityBlockLevel: 'critical' | 'high' | 'medium' | 'low';
-    leniencyFactor: number; // 0.0 = strict, 1.0 = lenient
-    reasoning: string[];
-}
-
-// Historical failure data (persisted to .rigour/adaptive-history.json)
-interface FailureHistory {
-    runs: {
-        timestamp: string;
-        passedGates: number;
-        failedGates: number;
-        totalFailures: number;
-    }[];
-    lastUpdated: string;
-}
-
-let cachedHistory: FailureHistory | null = null;
-
-/**
- * Load failure history from disk
- */
-function loadHistory(cwd: string): FailureHistory {
-    if (cachedHistory) return cachedHistory;
-
-    const historyPath = path.join(cwd, '.rigour', 'adaptive-history.json');
-    try {
-        if (fs.existsSync(historyPath)) {
-            cachedHistory = JSON.parse(fs.readFileSync(historyPath, 'utf-8'));
-            return cachedHistory!;
-        }
-    } catch (e) {
-        Logger.debug('Failed to load adaptive history, starting fresh');
-    }
-
-    cachedHistory = { runs: [], lastUpdated: new Date().toISOString() };
-    return cachedHistory;
-}
-
-/**
- * Save failure history to disk
- */
-function saveHistory(cwd: string, history: FailureHistory): void {
-    const rigourDir = path.join(cwd, '.rigour');
-    if (!fs.existsSync(rigourDir)) {
-        fs.mkdirSync(rigourDir, { recursive: true });
-    }
-    const historyPath = path.join(rigourDir, 'adaptive-history.json');
-    fs.writeFileSync(historyPath, JSON.stringify(history, null, 2));
-    cachedHistory = history;
-}
-
-/**
- * Record a gate run for historical tracking
- */
-export function recordGateRun(
-    cwd: string,
-    passedGates: number,
-    failedGates: number,
-    totalFailures: number
-): void {
-    const history = loadHistory(cwd);
-    history.runs.push({
-        timestamp: new Date().toISOString(),
-        passedGates,
-        failedGates,
-        totalFailures,
-    });
-
-    // Keep last 100 runs
-    if (history.runs.length > 100) {
-        history.runs = history.runs.slice(-100);
-    }
-
-    history.lastUpdated = new Date().toISOString();
-    saveHistory(cwd, history);
-}
-
-/**
- * Get quality trend from historical data
- */
-export function getQualityTrend(cwd: string): QualityTrend {
-    const history = loadHistory(cwd);
-    if (history.runs.length < 5) return 'stable';
-
-    const recent = history.runs.slice(-10);
-    const older = history.runs.slice(-20, -10);
-
-    if (older.length === 0) return 'stable';
-
-    const recentFailRate = recent.reduce((sum, r) => sum + r.totalFailures, 0) / recent.length;
-    const olderFailRate = older.reduce((sum, r) => sum + r.totalFailures, 0) / older.length;
-
-    const delta = recentFailRate - olderFailRate;
-
-    if (delta < -2) return 'improving';
-    if (delta > 2) return 'degrading';
-    return 'stable';
-}
-
-/**
- * Detect project complexity tier based on metrics
- */
-export function detectComplexityTier(metrics: ProjectMetrics): ComplexityTier {
-    // Enterprise: Large teams, many files, mature codebase
-    if (metrics.fileCount > 500 || (metrics.commitCount && metrics.commitCount > 1000)) {
-        return 'enterprise';
-    }
-
-    // Startup: Growing codebase, active development
-    if (metrics.fileCount > 50 || (metrics.commitCount && metrics.commitCount > 100)) {
-        return 'startup';
-    }
-
-    // Hobby: Small projects, early stage
-    return 'hobby';
-}
-
-/**
- * Calculate adaptive thresholds based on project state
- */
-export function calculateAdaptiveThresholds(
-    cwd: string,
-    metrics: ProjectMetrics,
-    config: AdaptiveConfig = {}
-): ThresholdAdjustments {
-    const reasoning: string[] = [];
-
-    // Determine tier
-    const tier = config.forced_tier ??
-        (config.auto_detect_tier !== false ? detectComplexityTier(metrics) : 'startup');
-    reasoning.push(`Complexity tier: ${tier} (files: ${metrics.fileCount})`);
-
-    // Get trend
-    const trend = getQualityTrend(cwd);
-    reasoning.push(`Quality trend: ${trend}`);
-
-    // Base thresholds
-    let coverageThreshold = config.base_coverage_threshold ?? 80;
-    let qualityThreshold = config.base_quality_threshold ?? 80;
-    let securityBlockLevel: 'critical' | 'high' | 'medium' | 'low' = 'high';
-    let leniencyFactor = 0.5;
-
-    // Adjust by tier
-    switch (tier) {
-        case 'hobby':
-            // Lenient for small/new projects
-            coverageThreshold = Math.max(50, coverageThreshold - 30);
-            qualityThreshold = Math.max(60, qualityThreshold - 20);
-            securityBlockLevel = 'critical'; // Only block on critical
-            leniencyFactor = 0.8;
-            reasoning.push('Hobby tier: relaxed thresholds, only critical security blocks');
-            break;
-
-        case 'startup':
-            // Moderate strictness
-            coverageThreshold = Math.max(60, coverageThreshold - 15);
-            qualityThreshold = Math.max(70, qualityThreshold - 10);
-            securityBlockLevel = 'high';
-            leniencyFactor = 0.5;
-            reasoning.push('Startup tier: moderate thresholds, high+ security blocks');
-            break;
-
-        case 'enterprise':
-            // Strict standards
-            coverageThreshold = coverageThreshold;
-            qualityThreshold = qualityThreshold;
-            securityBlockLevel = 'medium';
-            leniencyFactor = 0.2;
-            reasoning.push('Enterprise tier: strict thresholds, medium+ security blocks');
-            break;
-    }
-
-    // Adjust by trend
-    if (trend === 'improving') {
-        // Reward improvement with slightly relaxed thresholds
-        coverageThreshold = Math.max(50, coverageThreshold - 5);
-        qualityThreshold = Math.max(60, qualityThreshold - 5);
-        leniencyFactor = Math.min(1, leniencyFactor + 0.1);
-        reasoning.push('Improving trend: bonus threshold relaxation (+5%)');
-    } else if (trend === 'degrading') {
-        // Tighten thresholds to encourage recovery
-        coverageThreshold = Math.min(95, coverageThreshold + 5);
-        qualityThreshold = Math.min(95, qualityThreshold + 5);
-        leniencyFactor = Math.max(0, leniencyFactor - 0.1);
-        reasoning.push('Degrading trend: tightened thresholds (-5%)');
-    }
-
-    // Recent failure rate adjustment
-    if (metrics.recentFailureRate !== undefined) {
-        if (metrics.recentFailureRate > 50) {
-            // High failure rate - be more lenient to avoid discouragement
-            leniencyFactor = Math.min(1, leniencyFactor + 0.2);
-            reasoning.push(`High failure rate (${metrics.recentFailureRate.toFixed(0)}%): increased leniency`);
-        } else if (metrics.recentFailureRate < 10) {
-            // Low failure rate - team is mature, can handle stricter gates
-            leniencyFactor = Math.max(0, leniencyFactor - 0.1);
-            reasoning.push(`Low failure rate (${metrics.recentFailureRate.toFixed(0)}%): stricter enforcement`);
-        }
-    }
-
-    return {
-        tier,
-        trend,
-        coverageThreshold: Math.round(coverageThreshold),
-        qualityThreshold: Math.round(qualityThreshold),
-        securityBlockLevel,
-        leniencyFactor: Math.round(leniencyFactor * 100) / 100,
-        reasoning,
-    };
-}
-
-/**
- * Clear adaptive history (for testing)
- */
-export function clearAdaptiveHistory(cwd: string): void {
-    cachedHistory = null;
-    const historyPath = path.join(cwd, '.rigour', 'adaptive-history.json');
-    if (fs.existsSync(historyPath)) {
-        fs.unlinkSync(historyPath);
-    }
-}
-
-/**
- * Get summary of adaptive thresholds for logging
- */
-export function getAdaptiveSummary(adjustments: ThresholdAdjustments): string {
-    return `[${adjustments.tier.toUpperCase()}] ` +
-        `Coverage: ${adjustments.coverageThreshold}%, ` +
-        `Quality: ${adjustments.qualityThreshold}%, ` +
-        `Security: ${adjustments.securityBlockLevel}+, ` +
-        `Trend: ${adjustments.trend}`;
-}

package/src/services/context-engine.ts

@@ -1,104 +0,0 @@
-import { FileScanner } from '../utils/scanner.js';
-import { Config } from '../types/index.js';
-import path from 'path';
-import fs from 'fs-extra';
-
-export interface ProjectAnchor {
-    id: string;
-    type: 'env' | 'naming' | 'import';
-    pattern: string;
-    confidence: number;
-    occurrences: number;
-}
-
-export interface GoldenRecord {
-    anchors: ProjectAnchor[];
-    metadata: {
-        scannedFiles: number;
-        detectedCasing: 'camelCase' | 'snake_case' | 'PascalCase' | 'unknown';
-    };
-}
-
-export class ContextEngine {
-    constructor(private config: Config) { }
-
-    async discover(cwd: string): Promise<GoldenRecord> {
-        const anchors: ProjectAnchor[] = [];
-        const files = await FileScanner.findFiles({
-            cwd,
-            patterns: [
-                '**/*.{ts,js,py,yaml,yml,json}',
-                '.env*',
-                '**/.env*',
-                '**/package.json',
-                '**/Dockerfile',
-                '**/*.tf'
-            ]
-        });
-
-        const limit = this.config.gates.context?.mining_depth || 100;
-        const samples = files.slice(0, limit);
-
-        const envVars = new Map<string, number>();
-        let scannedFiles = 0;
-
-        for (const file of samples) {
-            try {
-                const content = await fs.readFile(path.join(cwd, file), 'utf-8');
-                scannedFiles++;
-                this.mineEnvVars(content, file, envVars);
-            } catch (e) { }
-        }
-
-        // Logs removed to avoid stdout pollution in JSON mode
-
-        // Convert envVars to anchors
-        for (const [name, count] of envVars.entries()) {
-            const confidence = count >= 2 ? 1 : 0.5;
-            anchors.push({
-                id: name,
-                type: 'env',
-                pattern: name,
-                occurrences: count,
-                confidence
-            });
-        }
-
-        return {
-            anchors,
-            metadata: {
-                scannedFiles,
-                detectedCasing: 'unknown', // TODO: Implement casing discovery
-            }
-        };
-    }
-
-    private mineEnvVars(content: string, file: string, registry: Map<string, number>) {
-        const isAnchorSource = file.includes('.env') || file.includes('yml') || file.includes('yaml');
-
-        if (isAnchorSource) {
-            const matches = content.matchAll(/^\s*([A-Z0-9_]+)\s*=/gm);
-            for (const match of matches) {
-                // Anchors from .env count for more initially
-                registry.set(match[1], (registry.get(match[1]) || 0) + 2);
-            }
-        }
-
-        // Source code matches (process.env.VAR or process.env['VAR'])
-        const tsJsMatches = content.matchAll(/process\.env(?:\.([A-Z0-9_]+)|\[['"]([A-Z0-9_]+)['"]\])/g);
-        for (const match of tsJsMatches) {
-            const name = match[1] || match[2];
-            this.incrementRegistry(registry, name);
-        }
-
-        // Python matches (os.environ.get('VAR') or os.environ['VAR'])
-        const pyMatches = content.matchAll(/os\.environ(?:\.get\(|\[)['"]([A-Z0-9_]+)['"]/g);
-        for (const match of pyMatches) {
-            this.incrementRegistry(registry, match[1]);
-        }
-    }
-
-    private incrementRegistry(registry: Map<string, number>, key: string) {
-        registry.set(key, (registry.get(key) || 0) + 1);
-    }
-}

package/src/services/fix-packet-service.ts

@@ -1,42 +0,0 @@
-import { Report, Failure, Config } from '../types/index.js';
-import { FixPacketV2, FixPacketV2Schema } from '../types/fix-packet.js';
-
-export class FixPacketService {
-    generate(report: Report, config: Config): FixPacketV2 {
-        const violations = report.failures.map(f => ({
-            id: f.id,
-            gate: f.id,
-            severity: this.inferSeverity(f),
-            title: f.title,
-            details: f.details,
-            files: f.files,
-            hint: f.hint,
-            instructions: f.hint ? [f.hint] : [], // Use hint as first instruction
-            metrics: (f as any).metrics,
-        }));
-
-        const packet: FixPacketV2 = {
-            version: 2,
-            goal: "Achieve PASS state by resolving all listed engineering violations.",
-            violations,
-            constraints: {
-                paradigm: config.paradigm,
-                protected_paths: config.gates.safety?.protected_paths,
-                do_not_touch: config.gates.safety?.protected_paths,
-                max_files_changed: config.gates.safety?.max_files_changed_per_cycle,
-                no_new_deps: true,
-            },
-        };
-
-        return FixPacketV2Schema.parse(packet);
-    }
-
-    private inferSeverity(f: Failure): "low" | "medium" | "high" | "critical" {
-        // High complexity or God objects are usually High severity
-        if (f.id === 'ast-analysis') return 'high';
-        // Unit test or Lint failures are Medium
-        if (f.id === 'test' || f.id === 'lint') return 'medium';
-        // Documentation or small file size issues are Low
-        return 'medium';
-    }
-}

package/src/services/state-service.ts

@@ -1,138 +0,0 @@
-import fs from 'fs-extra';
-import path from 'path';
-import crypto from 'crypto';
-
-/**
- * Local Calibration State Service
- * 
- * DOCTRINE COMPLIANCE (§6):
- * - Local-only, deletable, optional
- * - Used ONLY for prioritization, ordering, early warnings
- * - NEVER stores: source code, file contents, raw paths, prompts, user identifiers
- * - State NEVER changes PASS/FAIL results (only ordering/messaging)
- */
-
-interface ViolationStats {
-    count: number;
-    lastSeen: string; // ISO timestamp
-    coOccurs: Record<string, number>; // Rule ID -> co-occurrence count
-}
-
-interface LocalState {
-    version: number;
-    createdAt: string;
-    violations: Record<string, ViolationStats>; // Rule ID -> stats
-}
-
-const STATE_DIR = '.rigour';
-const STATE_FILE = 'state.json';
-const CURRENT_VERSION = 1;
-
-export class StateService {
-    private statePath: string;
-    private state: LocalState;
-
-    constructor(cwd: string) {
-        this.statePath = path.join(cwd, STATE_DIR, STATE_FILE);
-        this.state = this.load();
-    }
-
-    private load(): LocalState {
-        try {
-            if (fs.existsSync(this.statePath)) {
-                const content = fs.readFileSync(this.statePath, 'utf-8');
-                return JSON.parse(content);
-            }
-        } catch {
-            // Corrupted or missing state - reset
-        }
-        return this.createEmpty();
-    }
-
-    private createEmpty(): LocalState {
-        return {
-            version: CURRENT_VERSION,
-            createdAt: new Date().toISOString(),
-            violations: {},
-        };
-    }
-
-    /**
-     * Record violation occurrences for prioritization.
-     * PRIVACY: Only stores rule IDs and counts, never file contents or paths.
-     */
-    recordViolations(ruleIds: string[]): void {
-        const now = new Date().toISOString();
-
-        for (const ruleId of ruleIds) {
-            if (!this.state.violations[ruleId]) {
-                this.state.violations[ruleId] = { count: 0, lastSeen: now, coOccurs: {} };
-            }
-            this.state.violations[ruleId].count++;
-            this.state.violations[ruleId].lastSeen = now;
-
-            // Track co-occurrences for pattern detection
-            for (const otherId of ruleIds) {
-                if (otherId !== ruleId) {
-                    this.state.violations[ruleId].coOccurs[otherId] =
-                        (this.state.violations[ruleId].coOccurs[otherId] || 0) + 1;
-                }
-            }
-        }
-    }
-
-    /**
-     * Prioritize violations for Fix Packet ordering.
-     * Most frequent + recent violations appear first.
-     */
-    prioritize(ruleIds: string[]): string[] {
-        return [...ruleIds].sort((a, b) => {
-            const statsA = this.state.violations[a];
-            const statsB = this.state.violations[b];
-
-            if (!statsA && !statsB) return 0;
-            if (!statsA) return 1;
-            if (!statsB) return -1;
-
-            // Higher count = higher priority
-            return statsB.count - statsA.count;
-        });
-    }
-
-    /**
-     * Get repeat violation hints for agent feedback.
-     */
-    getRepeatHints(ruleIds: string[]): Record<string, string> {
-        const hints: Record<string, string> = {};
-
-        for (const ruleId of ruleIds) {
-            const stats = this.state.violations[ruleId];
-            if (stats && stats.count > 2) {
-                hints[ruleId] = `This violation has occurred ${stats.count} times. Consider root-cause analysis.`;
-            }
-        }
-
-        return hints;
-    }
-
-    save(): void {
-        try {
-            fs.ensureDirSync(path.dirname(this.statePath));
-            fs.writeFileSync(this.statePath, JSON.stringify(this.state, null, 2));
-        } catch {
-            // Silent fail - state is optional
-        }
-    }
-
-    /**
-     * Clear all state (user privacy action).
-     */
-    clear(): void {
-        this.state = this.createEmpty();
-        try {
-            fs.removeSync(this.statePath);
-        } catch {
-            // Silent fail
-        }
-    }
-}

package/src/smoke.test.ts

@@ -1,18 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { GateRunner } from '../src/gates/runner.js';
-
-describe('GateRunner Smoke Test', () => {
-    it('should initialize with empty config', async () => {
-        const config = {
-            version: 1,
-            commands: {},
-            gates: {
-                max_file_lines: 500,
-                forbid_todos: true,
-                forbid_fixme: true,
-            },
-        };
-        const runner = new GateRunner(config as any);
-        expect(runner).toBeDefined();
-    });
-});