@rigour-labs/core 3.0.0 → 3.0.2

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

@@ -8,3 +8,4 @@ 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

@@ -8,6 +8,7 @@ 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/templates/index.js

@@ -482,6 +482,13 @@ export const UNIVERSAL_CONFIG = {
             ignore_patterns: [],
         },
     },
+    hooks: {
+        enabled: false,
+        tools: [],
+        fast_gates: ['hallucinated-imports', 'promise-safety', 'security-patterns', 'file-size'],
+        timeout_ms: 5000,
+        block_on_failure: false,
+    },
     output: {
         report_path: 'rigour-report.json',
     },

package/dist/types/index.d.ts

@@ -568,6 +568,25 @@ export declare const CommandsSchema: z.ZodObject<{
     typecheck?: string | undefined;
     test?: string | undefined;
 }>;
+export declare const HooksSchema: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    tools: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodEnum<["claude", "cursor", "cline", "windsurf"]>, "many">>>;
+    fast_gates: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
+    timeout_ms: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    block_on_failure: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+}, "strip", z.ZodTypeAny, {
+    enabled: boolean;
+    tools: ("claude" | "cursor" | "cline" | "windsurf")[];
+    fast_gates: string[];
+    timeout_ms: number;
+    block_on_failure: boolean;
+}, {
+    enabled?: boolean | undefined;
+    tools?: ("claude" | "cursor" | "cline" | "windsurf")[] | undefined;
+    fast_gates?: string[] | undefined;
+    timeout_ms?: number | undefined;
+    block_on_failure?: boolean | undefined;
+}>>>;
 export declare const ConfigSchema: z.ZodObject<{
     version: z.ZodDefault<z.ZodNumber>;
     preset: z.ZodOptional<z.ZodString>;
@@ -1141,6 +1160,25 @@ export declare const ConfigSchema: z.ZodObject<{
             check_unsafe_fetch?: boolean | undefined;
         } | undefined;
     }>>>;
+    hooks: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        tools: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodEnum<["claude", "cursor", "cline", "windsurf"]>, "many">>>;
+        fast_gates: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
+        timeout_ms: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        block_on_failure: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    }, "strip", z.ZodTypeAny, {
+        enabled: boolean;
+        tools: ("claude" | "cursor" | "cline" | "windsurf")[];
+        fast_gates: string[];
+        timeout_ms: number;
+        block_on_failure: boolean;
+    }, {
+        enabled?: boolean | undefined;
+        tools?: ("claude" | "cursor" | "cline" | "windsurf")[] | undefined;
+        fast_gates?: string[] | undefined;
+        timeout_ms?: number | undefined;
+        block_on_failure?: boolean | undefined;
+    }>>>;
     output: z.ZodDefault<z.ZodOptional<z.ZodObject<{
         report_path: z.ZodDefault<z.ZodString>;
     }, "strip", z.ZodTypeAny, {
@@ -1278,6 +1316,13 @@ export declare const ConfigSchema: z.ZodObject<{
             check_unsafe_fetch: boolean;
         };
     };
+    hooks: {
+        enabled: boolean;
+        tools: ("claude" | "cursor" | "cline" | "windsurf")[];
+        fast_gates: string[];
+        timeout_ms: number;
+        block_on_failure: boolean;
+    };
     output: {
         report_path: string;
     };
@@ -1414,6 +1459,13 @@ export declare const ConfigSchema: z.ZodObject<{
             check_unsafe_fetch?: boolean | undefined;
         } | undefined;
     } | undefined;
+    hooks?: {
+        enabled?: boolean | undefined;
+        tools?: ("claude" | "cursor" | "cline" | "windsurf")[] | undefined;
+        fast_gates?: string[] | undefined;
+        timeout_ms?: number | undefined;
+        block_on_failure?: boolean | undefined;
+    } | undefined;
     output?: {
         report_path?: string | undefined;
     } | undefined;
@@ -1421,9 +1473,11 @@ export declare const ConfigSchema: z.ZodObject<{
 }>;
 export type Gates = z.infer<typeof GatesSchema>;
 export type Commands = z.infer<typeof CommandsSchema>;
+export type Hooks = z.infer<typeof HooksSchema>;
 export type Config = z.infer<typeof ConfigSchema>;
 export type RawGates = z.input<typeof GatesSchema>;
 export type RawCommands = z.input<typeof CommandsSchema>;
+export type RawHooks = z.input<typeof HooksSchema>;
 export type RawConfig = z.input<typeof ConfigSchema>;
 export declare const StatusSchema: z.ZodEnum<["PASS", "FAIL", "SKIP", "ERROR"]>;
 export type Status = z.infer<typeof StatusSchema>;

package/dist/types/index.js

@@ -144,12 +144,25 @@ export const CommandsSchema = z.object({
     typecheck: z.string().optional(),
     test: z.string().optional(),
 });
+export const HooksSchema = z.object({
+    enabled: z.boolean().optional().default(false),
+    tools: z.array(z.enum(['claude', 'cursor', 'cline', 'windsurf'])).optional().default([]),
+    fast_gates: z.array(z.string()).optional().default([
+        'hallucinated-imports',
+        'promise-safety',
+        'security-patterns',
+        'file-size',
+    ]),
+    timeout_ms: z.number().optional().default(5000),
+    block_on_failure: z.boolean().optional().default(false),
+}).optional().default({});
 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({}),
+    hooks: HooksSchema,
     output: z.object({
         report_path: z.string().default('rigour-report.json'),
     }).optional().default({}),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rigour-labs/core",
-  "version": "3.0.0",
+  "version": "3.0.2",
   "description": "Deterministic quality gate engine for AI-generated code. AST analysis, drift detection, and Fix Packet generation across TypeScript, JavaScript, Python, Go, Ruby, and C#.",
   "license": "MIT",
   "homepage": "https://rigour.run",