@rigour-labs/core 2.22.0 → 3.0.1

package/dist/hooks/templates.js

@@ -0,0 +1,232 @@
+/**
+ * Hook configuration templates for each AI coding tool.
+ *
+ * Each template generates the tool-native config format:
+ * - Claude Code: .claude/settings.json (PostToolUse matcher)
+ * - Cursor: .cursor/hooks.json (afterFileEdit event)
+ * - Cline: .clinerules/hooks/PostToolUse (executable script)
+ * - Windsurf: .windsurf/hooks.json (post_write_code event)
+ *
+ * @since v3.0.0
+ */
+/**
+ * Generate hook config files for a specific tool.
+ */
+export function generateHookFiles(tool, checkerPath) {
+    switch (tool) {
+        case 'claude':
+            return generateClaudeHooks(checkerPath);
+        case 'cursor':
+            return generateCursorHooks(checkerPath);
+        case 'cline':
+            return generateClineHooks(checkerPath);
+        case 'windsurf':
+            return generateWindsurfHooks(checkerPath);
+        default:
+            return [];
+    }
+}
+function generateClaudeHooks(checkerPath) {
+    const settings = {
+        hooks: {
+            PostToolUse: [
+                {
+                    matcher: "Write|Edit|MultiEdit",
+                    hooks: [
+                        {
+                            type: "command",
+                            command: `node ${checkerPath} --files "$TOOL_INPUT_file_path"`,
+                        }
+                    ]
+                }
+            ]
+        }
+    };
+    return [
+        {
+            path: '.claude/settings.json',
+            content: JSON.stringify(settings, null, 4),
+            description: 'Claude Code PostToolUse hook — runs Rigour fast-check after every Write/Edit',
+        },
+    ];
+}
+function generateCursorHooks(checkerPath) {
+    const hooks = {
+        version: 1,
+        hooks: {
+            afterFileEdit: [
+                {
+                    command: `node ${checkerPath} --stdin`,
+                }
+            ]
+        }
+    };
+    const wrapper = `#!/usr/bin/env node
+/**
+ * Cursor afterFileEdit hook wrapper for Rigour.
+ * Receives { file_path, old_content, new_content } on stdin.
+ * Runs Rigour fast-check on the edited file.
+ */
+const { runHookChecker } = require('./node_modules/@rigour-labs/core/dist/hooks/checker.js');
+
+let data = '';
+process.stdin.on('data', chunk => { data += chunk; });
+process.stdin.on('end', async () => {
+    try {
+        const payload = JSON.parse(data);
+        const result = await runHookChecker({
+            cwd: process.cwd(),
+            files: [payload.file_path],
+        });
+
+        // Write result to stdout for Cursor to consume
+        process.stdout.write(JSON.stringify({ status: 'ok' }));
+
+        // Log failures to stderr (visible in Cursor Hooks panel)
+        if (result.status === 'fail') {
+            for (const f of result.failures) {
+                const loc = f.line ? \`:\${f.line}\` : '';
+                process.stderr.write(\`[rigour/\${f.gate}] \${f.file}\${loc}: \${f.message}\\n\`);
+            }
+        }
+    } catch (err) {
+        process.stderr.write(\`Rigour hook error: \${err.message}\\n\`);
+        process.stdout.write(JSON.stringify({ status: 'ok' }));
+    }
+});
+`;
+    return [
+        {
+            path: '.cursor/hooks.json',
+            content: JSON.stringify(hooks, null, 4),
+            description: 'Cursor afterFileEdit hook config',
+        },
+        {
+            path: '.cursor/rigour-hook.js',
+            content: wrapper,
+            executable: true,
+            description: 'Cursor hook wrapper that reads stdin and runs Rigour checker',
+        },
+    ];
+}
+function generateClineHooks(checkerPath) {
+    const script = `#!/usr/bin/env node
+/**
+ * Cline PostToolUse hook for Rigour.
+ * Receives JSON on stdin with { toolName, toolInput, toolOutput }.
+ * Only triggers on write_to_file and replace_in_file tools.
+ */
+const { runHookChecker } = require('./node_modules/@rigour-labs/core/dist/hooks/checker.js');
+
+const WRITE_TOOLS = ['write_to_file', 'replace_in_file'];
+
+let data = '';
+process.stdin.on('data', chunk => { data += chunk; });
+process.stdin.on('end', async () => {
+    try {
+        const payload = JSON.parse(data);
+
+        if (!WRITE_TOOLS.includes(payload.toolName)) {
+            // Not a write tool, pass through
+            process.stdout.write(JSON.stringify({}));
+            process.exit(0);
+            return;
+        }
+
+        const filePath = payload.toolInput?.path || payload.toolInput?.file_path;
+        if (!filePath) {
+            process.stdout.write(JSON.stringify({}));
+            process.exit(0);
+            return;
+        }
+
+        const result = await runHookChecker({
+            cwd: process.cwd(),
+            files: [filePath],
+        });
+
+        if (result.status === 'fail') {
+            const messages = result.failures
+                .map(f => {
+                    const loc = f.line ? \`:\${f.line}\` : '';
+                    return \`[rigour/\${f.gate}] \${f.file}\${loc}: \${f.message}\`;
+                })
+                .join('\\n');
+
+            process.stdout.write(JSON.stringify({
+                contextModification: \`\\n[Rigour Quality Gate] Found \${result.failures.length} issue(s):\\n\${messages}\\nPlease fix before continuing.\`,
+            }));
+        } else {
+            process.stdout.write(JSON.stringify({}));
+        }
+    } catch (err) {
+        process.stderr.write(\`Rigour hook error: \${err.message}\\n\`);
+        process.stdout.write(JSON.stringify({}));
+    }
+});
+`;
+    return [
+        {
+            path: '.clinerules/hooks/PostToolUse',
+            content: script,
+            executable: true,
+            description: 'Cline PostToolUse hook — runs Rigour fast-check after file writes',
+        },
+    ];
+}
+function generateWindsurfHooks(checkerPath) {
+    const hooks = {
+        version: 1,
+        hooks: {
+            post_write_code: [
+                {
+                    command: `node ${checkerPath} --stdin`,
+                }
+            ]
+        }
+    };
+    const wrapper = `#!/usr/bin/env node
+/**
+ * Windsurf post_write_code hook wrapper for Rigour.
+ * Receives { file_path, content } on stdin from Cascade agent.
+ * Runs Rigour fast-check on the written file.
+ */
+const { runHookChecker } = require('./node_modules/@rigour-labs/core/dist/hooks/checker.js');
+
+let data = '';
+process.stdin.on('data', chunk => { data += chunk; });
+process.stdin.on('end', async () => {
+    try {
+        const payload = JSON.parse(data);
+        const result = await runHookChecker({
+            cwd: process.cwd(),
+            files: [payload.file_path],
+        });
+
+        if (result.status === 'fail') {
+            for (const f of result.failures) {
+                const loc = f.line ? \`:\${f.line}\` : '';
+                process.stderr.write(\`[rigour/\${f.gate}] \${f.file}\${loc}: \${f.message}\\n\`);
+            }
+            // Exit 2 = block (if configured), exit 0 = warn only
+            process.exit(0);
+        }
+    } catch (err) {
+        process.stderr.write(\`Rigour hook error: \${err.message}\\n\`);
+    }
+});
+`;
+    return [
+        {
+            path: '.windsurf/hooks.json',
+            content: JSON.stringify(hooks, null, 4),
+            description: 'Windsurf post_write_code hook config',
+        },
+        {
+            path: '.windsurf/rigour-hook.js',
+            content: wrapper,
+            executable: true,
+            description: 'Windsurf hook wrapper that reads stdin and runs Rigour checker',
+        },
+    ];
+}

package/dist/hooks/types.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Hook system types for multi-tool integration.
+ *
+ * Each AI coding tool (Claude Code, Cursor, Cline, Windsurf)
+ * has its own hook format. These types unify the config generation.
+ *
+ * @since v3.0.0
+ */
+export type HookTool = 'claude' | 'cursor' | 'cline' | 'windsurf';
+export interface HookConfig {
+    /** Which tools to generate hooks for */
+    tools: HookTool[];
+    /** Gates to run in the hook checker (fast subset) */
+    fast_gates: string[];
+    /** Max execution time in ms before the checker aborts */
+    timeout_ms: number;
+    /** Whether to block the tool on failure (exit 2) or just warn */
+    block_on_failure: boolean;
+}
+/** The fast gates that can run per-file in <200ms */
+export declare const FAST_GATE_IDS: readonly ["hallucinated-imports", "promise-safety", "security-patterns", "file-size"];
+export declare const DEFAULT_HOOK_CONFIG: HookConfig;
+export type FastGateId = typeof FAST_GATE_IDS[number];
+export interface HookCheckerResult {
+    status: 'pass' | 'fail' | 'error';
+    failures: Array<{
+        gate: string;
+        file: string;
+        message: string;
+        severity: string;
+        line?: number;
+    }>;
+    duration_ms: number;
+}

package/dist/hooks/types.js

@@ -0,0 +1,21 @@
+/**
+ * Hook system types for multi-tool integration.
+ *
+ * Each AI coding tool (Claude Code, Cursor, Cline, Windsurf)
+ * has its own hook format. These types unify the config generation.
+ *
+ * @since v3.0.0
+ */
+/** The fast gates that can run per-file in <200ms */
+export const FAST_GATE_IDS = [
+    'hallucinated-imports',
+    'promise-safety',
+    'security-patterns',
+    'file-size',
+];
+export const DEFAULT_HOOK_CONFIG = {
+    tools: ['claude'],
+    fast_gates: [...FAST_GATE_IDS],
+    timeout_ms: 5000,
+    block_on_failure: false,
+};

package/dist/index.d.ts

@@ -7,3 +7,5 @@ export * from './types/fix-packet.js';
 export { Gate, GateContext } from './gates/base.js';
 export { RetryLoopBreakerGate } from './gates/retry-loop-breaker.js';
 export * from './utils/logger.js';
+export * from './services/score-history.js';
+export * from './hooks/index.js';

package/dist/index.js

@@ -7,6 +7,8 @@ export * from './types/fix-packet.js';
 export { Gate } from './gates/base.js';
 export { RetryLoopBreakerGate } from './gates/retry-loop-breaker.js';
 export * from './utils/logger.js';
+export * from './services/score-history.js';
+export * from './hooks/index.js';
 // Pattern Index is intentionally NOT exported here to prevent
 // native dependency issues (sharp/transformers) from leaking into 
 // non-AI parts of the system. 

package/dist/services/fix-packet-service.d.ts

@@ -2,5 +2,4 @@ import { Report, Config } from '../types/index.js';
 import { FixPacketV2 } from '../types/fix-packet.js';
 export declare class FixPacketService {
     generate(report: Report, config: Config): FixPacketV2;
-    private inferSeverity;
 }

package/dist/services/fix-packet-service.js

@@ -1,17 +1,22 @@
 import { FixPacketV2Schema } from '../types/fix-packet.js';
 export class FixPacketService {
     generate(report, config) {
-        const violations = report.failures.map(f => ({
+        // Sort violations: critical first, then high, medium, low, info
+        const severityOrder = { critical: 0, high: 1, medium: 2, low: 3, info: 4 };
+        const violations = report.failures
+            .map(f => ({
             id: f.id,
             gate: f.id,
-            severity: this.inferSeverity(f),
+            severity: (f.severity || 'medium'),
+            category: f.provenance,
             title: f.title,
             details: f.details,
             files: f.files,
             hint: f.hint,
-            instructions: f.hint ? [f.hint] : [], // Use hint as first instruction
+            instructions: f.hint ? [f.hint] : [],
             metrics: f.metrics,
-        }));
+        }))
+            .sort((a, b) => (severityOrder[a.severity] ?? 2) - (severityOrder[b.severity] ?? 2));
         const packet = {
             version: 2,
             goal: "Achieve PASS state by resolving all listed engineering violations.",
@@ -26,14 +31,4 @@ export class FixPacketService {
         };
         return FixPacketV2Schema.parse(packet);
     }
-    inferSeverity(f) {
-        // 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/dist/services/score-history.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Score History Service
+ *
+ * Append-only JSONL tracking of quality scores over time.
+ * Used for compliance dashboards, trend analysis, and audit reports.
+ *
+ * Uses JSONL (not JSON) to avoid read-modify-write race conditions
+ * when multiple agents run checks concurrently.
+ *
+ * @since v2.17.0
+ */
+export interface ScoreEntry {
+    timestamp: string;
+    status: 'PASS' | 'FAIL' | 'SKIP' | 'ERROR';
+    score: number;
+    ai_health_score?: number;
+    structural_score?: number;
+    failureCount: number;
+    severity_breakdown: Record<string, number>;
+    provenance_breakdown: Record<string, number>;
+}
+export interface ScoreTrend {
+    direction: 'improving' | 'stable' | 'degrading';
+    delta: number;
+    recentAvg: number;
+    previousAvg: number;
+    recentScores: number[];
+}
+/**
+ * Record a score entry after a rigour check run.
+ * Appends a single JSONL line. Auto-trims to MAX_ENTRIES.
+ */
+export declare function recordScore(cwd: string, report: {
+    status: string;
+    stats: {
+        score?: number;
+        ai_health_score?: number;
+        structural_score?: number;
+        severity_breakdown?: Record<string, number>;
+        provenance_breakdown?: Record<string, number>;
+    };
+    failures: {
+        length: number;
+    } | any[];
+}): void;
+/**
+ * Read the last N score entries.
+ */
+export declare function getScoreHistory(cwd: string, limit?: number): ScoreEntry[];
+/**
+ * Calculate score trend from history.
+ * Compares average of last 5 runs vs previous 5 runs.
+ */
+export declare function getScoreTrend(cwd: string): ScoreTrend | null;

package/dist/services/score-history.js

@@ -0,0 +1,122 @@
+/**
+ * Score History Service
+ *
+ * Append-only JSONL tracking of quality scores over time.
+ * Used for compliance dashboards, trend analysis, and audit reports.
+ *
+ * Uses JSONL (not JSON) to avoid read-modify-write race conditions
+ * when multiple agents run checks concurrently.
+ *
+ * @since v2.17.0
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+const MAX_ENTRIES = 100;
+const HISTORY_FILE = 'score-history.jsonl';
+function getHistoryPath(cwd) {
+    return path.join(cwd, '.rigour', HISTORY_FILE);
+}
+/**
+ * Record a score entry after a rigour check run.
+ * Appends a single JSONL line. Auto-trims to MAX_ENTRIES.
+ */
+export function recordScore(cwd, report) {
+    try {
+        const rigourDir = path.join(cwd, '.rigour');
+        if (!fs.existsSync(rigourDir)) {
+            fs.mkdirSync(rigourDir, { recursive: true });
+        }
+        const entry = {
+            timestamp: new Date().toISOString(),
+            status: report.status,
+            score: report.stats.score ?? 100,
+            ai_health_score: report.stats.ai_health_score,
+            structural_score: report.stats.structural_score,
+            failureCount: Array.isArray(report.failures) ? report.failures.length : 0,
+            severity_breakdown: report.stats.severity_breakdown ?? {},
+            provenance_breakdown: report.stats.provenance_breakdown ?? {},
+        };
+        const historyPath = getHistoryPath(cwd);
+        fs.appendFileSync(historyPath, JSON.stringify(entry) + '\n');
+        // Auto-trim if over MAX_ENTRIES
+        trimHistory(historyPath);
+    }
+    catch {
+        // Silent fail — score tracking should never break the check command
+    }
+}
+/**
+ * Read the last N score entries.
+ */
+export function getScoreHistory(cwd, limit = 20) {
+    try {
+        const historyPath = getHistoryPath(cwd);
+        if (!fs.existsSync(historyPath))
+            return [];
+        const lines = fs.readFileSync(historyPath, 'utf-8')
+            .trim()
+            .split('\n')
+            .filter(line => line.length > 0);
+        const entries = lines.map(line => JSON.parse(line));
+        return entries.slice(-limit);
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Calculate score trend from history.
+ * Compares average of last 5 runs vs previous 5 runs.
+ */
+export function getScoreTrend(cwd) {
+    const history = getScoreHistory(cwd, 20);
+    if (history.length < 3)
+        return null;
+    const scores = history.map(e => e.score);
+    const recentScores = scores.slice(-5);
+    const previousScores = scores.slice(-10, -5);
+    const recentAvg = recentScores.reduce((a, b) => a + b, 0) / recentScores.length;
+    if (previousScores.length === 0) {
+        return {
+            direction: 'stable',
+            delta: 0,
+            recentAvg: Math.round(recentAvg),
+            previousAvg: Math.round(recentAvg),
+            recentScores,
+        };
+    }
+    const previousAvg = previousScores.reduce((a, b) => a + b, 0) / previousScores.length;
+    const delta = recentAvg - previousAvg;
+    let direction;
+    if (delta > 3)
+        direction = 'improving';
+    else if (delta < -3)
+        direction = 'degrading';
+    else
+        direction = 'stable';
+    return {
+        direction,
+        delta: Math.round(delta * 10) / 10,
+        recentAvg: Math.round(recentAvg),
+        previousAvg: Math.round(previousAvg),
+        recentScores,
+    };
+}
+/**
+ * Trim JSONL file to last MAX_ENTRIES lines.
+ */
+function trimHistory(historyPath) {
+    try {
+        const lines = fs.readFileSync(historyPath, 'utf-8')
+            .trim()
+            .split('\n')
+            .filter(line => line.length > 0);
+        if (lines.length > MAX_ENTRIES) {
+            const trimmed = lines.slice(-MAX_ENTRIES);
+            fs.writeFileSync(historyPath, trimmed.join('\n') + '\n');
+        }
+    }
+    catch {
+        // Silent fail
+    }
+}