@rigour-labs/cli 3.0.0 → 3.0.2

package/dist/commands/demo.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/commands/demo.test.js

@@ -0,0 +1,59 @@
+/**
+ * Tests for the demo command — all modes: default, --hooks, --cinematic.
+ */
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { demoCommand } from './demo.js';
+describe('demoCommand', () => {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    let consoleSpy;
+    beforeEach(() => {
+        consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => { });
+        vi.spyOn(console, 'error').mockImplementation(() => { });
+        vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
+    });
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+    it('should run default demo without errors', async () => {
+        await expect(demoCommand({})).resolves.not.toThrow();
+    }, 30_000);
+    it('should run with --hooks flag', async () => {
+        await expect(demoCommand({ hooks: true, speed: 'fast' })).resolves.not.toThrow();
+        // Should show hooks simulation
+        const allOutput = consoleSpy.mock.calls.map((c) => c.join(' ')).join('\n');
+        expect(allOutput).toContain('hooks');
+    }, 30_000);
+    it('should run with --cinematic flag at fast speed', async () => {
+        await expect(demoCommand({ cinematic: true, speed: 'fast' })).resolves.not.toThrow();
+        // Cinematic mode should show the before/after flow
+        const allOutput = consoleSpy.mock.calls.map((c) => c.join(' ')).join('\n');
+        expect(allOutput).toContain('fix');
+    }, 60_000);
+    it('should produce FAIL status on demo project', async () => {
+        await demoCommand({ speed: 'fast' });
+        const allOutput = consoleSpy.mock.calls.map((c) => c.join(' ')).join('\n');
+        expect(allOutput).toContain('FAIL');
+    }, 30_000);
+    it('should generate fix packet and audit report', async () => {
+        await demoCommand({ speed: 'fast' });
+        const allOutput = consoleSpy.mock.calls.map((c) => c.join(' ')).join('\n');
+        expect(allOutput).toContain('Fix packet generated');
+        expect(allOutput).toContain('Audit report exported');
+    }, 30_000);
+    it('should show score bars in output', async () => {
+        await demoCommand({ speed: 'fast' });
+        const allOutput = consoleSpy.mock.calls.map((c) => c.join(' ')).join('\n');
+        // Score bars use block characters
+        expect(allOutput).toContain('/100');
+    }, 30_000);
+    it('should show whitepaper link in cinematic closing', async () => {
+        await demoCommand({ cinematic: true, speed: 'fast' });
+        const allOutput = consoleSpy.mock.calls.map((c) => c.join(' ')).join('\n');
+        expect(allOutput).toContain('zenodo.org');
+    }, 60_000);
+    it('should show hooks init command in closing', async () => {
+        await demoCommand({ speed: 'fast' });
+        const allOutput = consoleSpy.mock.calls.map((c) => c.join(' ')).join('\n');
+        expect(allOutput).toContain('hooks init');
+    }, 30_000);
+});

package/dist/commands/hooks.d.ts

@@ -0,0 +1,22 @@
+/**
+ * `rigour hooks init` — Generate tool-specific hook configurations.
+ *
+ * Detects which AI coding tools are present (or accepts --tool flag)
+ * and generates the appropriate hook files so that Rigour runs
+ * quality checks after every file write/edit.
+ *
+ * Supported tools:
+ *   - Claude Code (.claude/settings.json PostToolUse)
+ *   - Cursor (.cursor/hooks.json afterFileEdit)
+ *   - Cline (.clinerules/hooks/PostToolUse)
+ *   - Windsurf (.windsurf/hooks.json post_write_code)
+ *
+ * @since v3.0.0
+ */
+export interface HooksOptions {
+    tool?: string;
+    dryRun?: boolean;
+    force?: boolean;
+    block?: boolean;
+}
+export declare function hooksInitCommand(cwd: string, options?: HooksOptions): Promise<void>;

package/dist/commands/hooks.js

@@ -0,0 +1,274 @@
+/**
+ * `rigour hooks init` — Generate tool-specific hook configurations.
+ *
+ * Detects which AI coding tools are present (or accepts --tool flag)
+ * and generates the appropriate hook files so that Rigour runs
+ * quality checks after every file write/edit.
+ *
+ * Supported tools:
+ *   - Claude Code (.claude/settings.json PostToolUse)
+ *   - Cursor (.cursor/hooks.json afterFileEdit)
+ *   - Cline (.clinerules/hooks/PostToolUse)
+ *   - Windsurf (.windsurf/hooks.json post_write_code)
+ *
+ * @since v3.0.0
+ */
+import fs from 'fs-extra';
+import path from 'path';
+import chalk from 'chalk';
+import { randomUUID } from 'crypto';
+// ── Studio event logging ─────────────────────────────────────────────
+async function logStudioEvent(cwd, event) {
+    try {
+        const rigourDir = path.join(cwd, '.rigour');
+        await fs.ensureDir(rigourDir);
+        const eventsPath = path.join(rigourDir, 'events.jsonl');
+        const logEntry = JSON.stringify({
+            id: randomUUID(),
+            timestamp: new Date().toISOString(),
+            ...event,
+        }) + '\n';
+        await fs.appendFile(eventsPath, logEntry);
+    }
+    catch {
+        // Silent fail
+    }
+}
+// ── Tool detection ───────────────────────────────────────────────────
+const TOOL_MARKERS = {
+    claude: ['CLAUDE.md', '.claude'],
+    cursor: ['.cursor', '.cursorrules'],
+    cline: ['.clinerules'],
+    windsurf: ['.windsurfrules', '.windsurf'],
+};
+function detectTools(cwd) {
+    const detected = [];
+    for (const [tool, markers] of Object.entries(TOOL_MARKERS)) {
+        for (const marker of markers) {
+            if (fs.existsSync(path.join(cwd, marker))) {
+                detected.push(tool);
+                break;
+            }
+        }
+    }
+    return detected;
+}
+function resolveCheckerPath(cwd) {
+    const localPath = path.join(cwd, 'node_modules', '@rigour-labs', 'core', 'dist', 'hooks', 'standalone-checker.js');
+    if (fs.existsSync(localPath)) {
+        return localPath;
+    }
+    return 'npx rigour-hook-check';
+}
+// ── Tool resolution (from --tool flag or auto-detect) ────────────────
+const ALL_TOOLS = ['claude', 'cursor', 'cline', 'windsurf'];
+function resolveTools(cwd, toolFlag) {
+    if (toolFlag === 'all') {
+        return ALL_TOOLS;
+    }
+    if (toolFlag) {
+        const requested = toolFlag.split(',').map(t => t.trim().toLowerCase());
+        const valid = requested.filter(t => ALL_TOOLS.includes(t));
+        if (valid.length === 0) {
+            console.error(chalk.red(`Unknown tool: ${toolFlag}. Valid: claude, cursor, cline, windsurf, all`));
+            process.exit(1);
+        }
+        return valid;
+    }
+    // Auto-detect
+    const detected = detectTools(cwd);
+    if (detected.length === 0) {
+        console.log(chalk.yellow('No AI coding tools detected. Defaulting to Claude Code.'));
+        console.log(chalk.dim('  Use --tool <name> to specify: claude, cursor, cline, windsurf, all\n'));
+        return ['claude'];
+    }
+    console.log(chalk.green(`Detected tools: ${detected.join(', ')}`));
+    return detected;
+}
+// ── Per-tool hook generators ─────────────────────────────────────────
+function generateClaudeHooks(checkerPath, block) {
+    const blockFlag = block ? ' --block' : '';
+    const settings = {
+        hooks: {
+            PostToolUse: [{
+                    matcher: "Write|Edit|MultiEdit",
+                    hooks: [{
+                            type: "command",
+                            command: `node ${checkerPath} --files "$TOOL_INPUT_file_path"${blockFlag}`,
+                        }]
+                }]
+        }
+    };
+    return [{
+            path: '.claude/settings.json',
+            content: JSON.stringify(settings, null, 4),
+            description: 'Claude Code PostToolUse hook',
+        }];
+}
+function generateCursorHooks(checkerPath, _block) {
+    const hooks = {
+        version: 1,
+        hooks: { afterFileEdit: [{ command: `node ${checkerPath} --stdin` }] }
+    };
+    return [{
+            path: '.cursor/hooks.json',
+            content: JSON.stringify(hooks, null, 4),
+            description: 'Cursor afterFileEdit hook config',
+        }];
+}
+function generateClineHooks(checkerPath, _block) {
+    const script = buildClineScript(checkerPath);
+    return [{
+            path: '.clinerules/hooks/PostToolUse',
+            content: script,
+            executable: true,
+            description: 'Cline PostToolUse executable hook',
+        }];
+}
+function buildClineScript(checkerPath) {
+    return `#!/usr/bin/env node
+/**
+ * Cline PostToolUse hook for Rigour.
+ * Receives JSON on stdin with { toolName, toolInput }.
+ */
+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)) {
+            process.stdout.write(JSON.stringify({}));
+            return;
+        }
+        const filePath = payload.toolInput?.path || payload.toolInput?.file_path;
+        if (!filePath) {
+            process.stdout.write(JSON.stringify({}));
+            return;
+        }
+
+        const { execSync } = require('child_process');
+        const raw = execSync(
+            \`node ${checkerPath} --files "\${filePath}"\`,
+            { encoding: 'utf-8', timeout: 5000 }
+        );
+        const result = JSON.parse(raw);
+        if (result.status === 'fail') {
+            const msgs = result.failures
+                .map(f => \`[rigour/\${f.gate}] \${f.file}: \${f.message}\`)
+                .join('\\n');
+            process.stdout.write(JSON.stringify({
+                contextModification: \`\\n[Rigour] \${result.failures.length} issue(s):\\n\${msgs}\\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({}));
+    }
+});
+`;
+}
+function generateWindsurfHooks(checkerPath, _block) {
+    const hooks = {
+        version: 1,
+        hooks: { post_write_code: [{ command: `node ${checkerPath} --stdin` }] }
+    };
+    return [{
+            path: '.windsurf/hooks.json',
+            content: JSON.stringify(hooks, null, 4),
+            description: 'Windsurf post_write_code hook config',
+        }];
+}
+const GENERATORS = {
+    claude: generateClaudeHooks,
+    cursor: generateCursorHooks,
+    cline: generateClineHooks,
+    windsurf: generateWindsurfHooks,
+};
+// ── File writing ─────────────────────────────────────────────────────
+function printDryRun(files) {
+    console.log(chalk.cyan('\nDry run — files that would be created:\n'));
+    for (const file of files) {
+        console.log(chalk.bold(`  ${file.path}`));
+        console.log(chalk.dim(`    ${file.description}`));
+        if (file.executable) {
+            console.log(chalk.dim('    (executable)'));
+        }
+    }
+    console.log('');
+}
+async function writeHookFiles(cwd, files, force) {
+    let written = 0;
+    let skipped = 0;
+    for (const file of files) {
+        const fullPath = path.join(cwd, file.path);
+        const exists = await fs.pathExists(fullPath);
+        if (exists && !force) {
+            console.log(chalk.yellow(`  SKIP ${file.path} (already exists, use --force to overwrite)`));
+            skipped++;
+            continue;
+        }
+        await fs.ensureDir(path.dirname(fullPath));
+        await fs.writeFile(fullPath, file.content, 'utf-8');
+        if (file.executable) {
+            await fs.chmod(fullPath, 0o755);
+        }
+        console.log(chalk.green(`  CREATE ${file.path}`));
+        console.log(chalk.dim(`         ${file.description}`));
+        written++;
+    }
+    return { written, skipped };
+}
+// ── Next-steps guidance ──────────────────────────────────────────────
+const NEXT_STEPS = {
+    claude: 'Claude Code: Hooks are active immediately. Rigour runs after every Write/Edit.',
+    cursor: 'Cursor: Reload window (Cmd+Shift+P > Reload). Check Output > Hooks panel for logs.',
+    cline: 'Cline: Hook is active. Quality feedback appears in agent context on violations.',
+    windsurf: 'Windsurf: Reload editor. Check terminal for Rigour output after Cascade writes.',
+};
+function printNextSteps(tools) {
+    console.log(chalk.cyan('\nNext steps:'));
+    for (const tool of tools) {
+        console.log(chalk.dim(`  ${NEXT_STEPS[tool]}`));
+    }
+    console.log('');
+}
+// ── Main command entry point ─────────────────────────────────────────
+export async function hooksInitCommand(cwd, options = {}) {
+    console.log(chalk.blue('\nRigour Hooks Setup\n'));
+    await logStudioEvent(cwd, {
+        type: 'tool_call',
+        tool: 'rigour_hooks_init',
+        arguments: { tool: options.tool, dryRun: options.dryRun },
+    });
+    const tools = resolveTools(cwd, options.tool);
+    const checkerPath = resolveCheckerPath(cwd);
+    const block = !!options.block;
+    // Collect generated files from all tools
+    const allFiles = [];
+    for (const tool of tools) {
+        allFiles.push(...GENERATORS[tool](checkerPath, block));
+    }
+    if (options.dryRun) {
+        printDryRun(allFiles);
+        return;
+    }
+    const { written, skipped } = await writeHookFiles(cwd, allFiles, !!options.force);
+    console.log('');
+    if (written > 0) {
+        console.log(chalk.green.bold(`Created ${written} hook file(s).`));
+    }
+    if (skipped > 0) {
+        console.log(chalk.yellow(`Skipped ${skipped} existing file(s).`));
+    }
+    printNextSteps(tools);
+    await logStudioEvent(cwd, {
+        type: 'tool_response',
+        tool: 'rigour_hooks_init',
+        status: 'success',
+        content: [{ type: 'text', text: `Generated hooks for: ${tools.join(', ')}` }],
+    });
+}

package/dist/commands/hooks.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/commands/hooks.test.js

@@ -0,0 +1,77 @@
+/**
+ * Tests for hooks init command.
+ */
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { hooksInitCommand } from './hooks.js';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import yaml from 'yaml';
+describe('hooksInitCommand', () => {
+    let testDir;
+    beforeEach(() => {
+        testDir = fs.mkdtempSync(path.join(os.tmpdir(), 'hooks-test-'));
+        // Write minimal rigour.yml
+        fs.writeFileSync(path.join(testDir, 'rigour.yml'), yaml.stringify({
+            version: 1,
+            gates: { max_file_lines: 500 },
+        }));
+        vi.spyOn(console, 'log').mockImplementation(() => { });
+        vi.spyOn(console, 'error').mockImplementation(() => { });
+    });
+    afterEach(() => {
+        fs.rmSync(testDir, { recursive: true, force: true });
+        vi.restoreAllMocks();
+    });
+    it('should generate Claude hooks', async () => {
+        await hooksInitCommand(testDir, { tool: 'claude' });
+        const settingsPath = path.join(testDir, '.claude', 'settings.json');
+        expect(fs.existsSync(settingsPath)).toBe(true);
+        const settings = JSON.parse(fs.readFileSync(settingsPath, 'utf-8'));
+        expect(settings.hooks).toBeDefined();
+        expect(settings.hooks.PostToolUse).toBeDefined();
+    });
+    it('should generate Cursor hooks', async () => {
+        await hooksInitCommand(testDir, { tool: 'cursor' });
+        const hooksPath = path.join(testDir, '.cursor', 'hooks.json');
+        expect(fs.existsSync(hooksPath)).toBe(true);
+        const hooks = JSON.parse(fs.readFileSync(hooksPath, 'utf-8'));
+        expect(hooks.hooks).toBeDefined();
+    });
+    it('should generate Cline hooks', async () => {
+        await hooksInitCommand(testDir, { tool: 'cline' });
+        const hookPath = path.join(testDir, '.clinerules', 'hooks', 'PostToolUse');
+        expect(fs.existsSync(hookPath)).toBe(true);
+    });
+    it('should generate Windsurf hooks', async () => {
+        await hooksInitCommand(testDir, { tool: 'windsurf' });
+        const hooksPath = path.join(testDir, '.windsurf', 'hooks.json');
+        expect(fs.existsSync(hooksPath)).toBe(true);
+    });
+    it('should support dry-run mode', async () => {
+        await hooksInitCommand(testDir, { tool: 'claude', dryRun: true });
+        // Dry run should NOT create files
+        const settingsPath = path.join(testDir, '.claude', 'settings.json');
+        expect(fs.existsSync(settingsPath)).toBe(false);
+    });
+    it('should not overwrite without --force', async () => {
+        // Create existing file
+        const claudeDir = path.join(testDir, '.claude');
+        fs.mkdirSync(claudeDir, { recursive: true });
+        fs.writeFileSync(path.join(claudeDir, 'settings.json'), '{"existing": true}');
+        await hooksInitCommand(testDir, { tool: 'claude' });
+        // Should keep existing content
+        const content = fs.readFileSync(path.join(claudeDir, 'settings.json'), 'utf-8');
+        expect(content).toContain('existing');
+    });
+    it('should overwrite with --force', async () => {
+        // Create existing file
+        const claudeDir = path.join(testDir, '.claude');
+        fs.mkdirSync(claudeDir, { recursive: true });
+        fs.writeFileSync(path.join(claudeDir, 'settings.json'), '{"existing": true}');
+        await hooksInitCommand(testDir, { tool: 'claude', force: true });
+        // Should have new hooks content
+        const content = fs.readFileSync(path.join(claudeDir, 'settings.json'), 'utf-8');
+        expect(content).toContain('PostToolUse');
+    });
+});

package/dist/commands/init.js

@@ -4,6 +4,7 @@ import chalk from 'chalk';
 import yaml from 'yaml';
 import { DiscoveryService } from '@rigour-labs/core';
 import { CODE_QUALITY_RULES, DEBUGGING_RULES, COLLABORATION_RULES, AGNOSTIC_AI_INSTRUCTIONS } from './constants.js';
+import { hooksInitCommand } from './hooks.js';
 import { randomUUID } from 'crypto';
 // Helper to log events for Rigour Studio
 async function logStudioEvent(cwd, event) {
@@ -322,7 +323,9 @@ ${ruleContent}`;
             console.log(chalk.green('✔ Initialized Windsurf Handshake (.windsurfrules)'));
         }
     }
-    // 3. Update .gitignore
+    // 3. Auto-initialize hooks for detected AI coding tools
+    await initHooksForDetectedTools(cwd, detectedIDE);
+    // 4. Update .gitignore
     const gitignorePath = path.join(cwd, '.gitignore');
     const ignorePatterns = ['rigour-report.json', 'rigour-fix-packet.json', '.rigour/'];
     try {
@@ -368,3 +371,24 @@ ${ruleContent}`;
         content: [{ type: "text", text: `Rigour Governance Initialized` }]
     });
 }
+// Maps detected IDE to hook tool name
+const IDE_TO_HOOK_TOOL = {
+    claude: 'claude',
+    cursor: 'cursor',
+    cline: 'cline',
+    windsurf: 'windsurf',
+};
+async function initHooksForDetectedTools(cwd, detectedIDE) {
+    const hookTool = IDE_TO_HOOK_TOOL[detectedIDE];
+    if (!hookTool) {
+        return; // Unknown IDE or no hook support (vscode, gemini, codex)
+    }
+    try {
+        console.log(chalk.dim(`\n   Setting up real-time hooks for ${detectedIDE}...`));
+        await hooksInitCommand(cwd, { tool: hookTool });
+    }
+    catch {
+        // Non-fatal — hooks are a bonus, not a requirement
+        console.log(chalk.dim(`   (Hooks setup skipped — run 'rigour hooks init' manually)`));
+    }
+}

package/dist/commands/init.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/commands/init.test.js

@@ -0,0 +1,97 @@
+/**
+ * Tests for init command — IDE detection, config generation, auto-hook integration.
+ */
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { initCommand } from './init.js';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+describe('initCommand', () => {
+    let testDir;
+    beforeEach(() => {
+        testDir = fs.mkdtempSync(path.join(os.tmpdir(), 'init-test-'));
+        // Minimal package.json for discovery
+        fs.writeFileSync(path.join(testDir, 'package.json'), JSON.stringify({
+            name: 'test-project',
+            dependencies: { express: '^4.0.0' },
+        }));
+        vi.spyOn(console, 'log').mockImplementation(() => { });
+        vi.spyOn(console, 'error').mockImplementation(() => { });
+    });
+    afterEach(() => {
+        fs.rmSync(testDir, { recursive: true, force: true });
+        vi.restoreAllMocks();
+    });
+    it('should create rigour.yml', async () => {
+        await initCommand(testDir);
+        const configPath = path.join(testDir, 'rigour.yml');
+        expect(fs.existsSync(configPath)).toBe(true);
+        const content = fs.readFileSync(configPath, 'utf-8');
+        expect(content).toContain('version');
+    });
+    it('should create docs/AGENT_INSTRUCTIONS.md', async () => {
+        await initCommand(testDir);
+        const docsPath = path.join(testDir, 'docs', 'AGENT_INSTRUCTIONS.md');
+        expect(fs.existsSync(docsPath)).toBe(true);
+        const content = fs.readFileSync(docsPath, 'utf-8');
+        expect(content).toContain('Rigour');
+    });
+    it('should support dry-run mode', async () => {
+        await initCommand(testDir, { dryRun: true });
+        // Dry run should NOT create rigour.yml
+        expect(fs.existsSync(path.join(testDir, 'rigour.yml'))).toBe(false);
+    });
+    it('should not overwrite without --force', async () => {
+        // Create existing rigour.yml
+        fs.writeFileSync(path.join(testDir, 'rigour.yml'), 'version: 1\nexisting: true\n');
+        await initCommand(testDir);
+        const content = fs.readFileSync(path.join(testDir, 'rigour.yml'), 'utf-8');
+        expect(content).toContain('existing');
+    });
+    it('should overwrite with --force', async () => {
+        // Create existing rigour.yml
+        fs.writeFileSync(path.join(testDir, 'rigour.yml'), 'version: 1\nexisting: true\n');
+        await initCommand(testDir, { force: true });
+        // Should create backup
+        expect(fs.existsSync(path.join(testDir, 'rigour.yml.bak'))).toBe(true);
+        // New config should not contain 'existing'
+        const content = fs.readFileSync(path.join(testDir, 'rigour.yml'), 'utf-8');
+        expect(content).not.toContain('existing: true');
+    });
+    it('should detect Claude IDE and create hooks', async () => {
+        // Create Claude marker
+        fs.mkdirSync(path.join(testDir, '.claude'), { recursive: true });
+        await initCommand(testDir);
+        // Should have created .claude/settings.json (hooks)
+        const settingsPath = path.join(testDir, '.claude', 'settings.json');
+        expect(fs.existsSync(settingsPath)).toBe(true);
+    });
+    it('should detect Cursor IDE and create hooks', async () => {
+        // Create Cursor marker
+        fs.mkdirSync(path.join(testDir, '.cursor'), { recursive: true });
+        await initCommand(testDir);
+        // Should have created .cursor/hooks.json
+        const hooksPath = path.join(testDir, '.cursor', 'hooks.json');
+        expect(fs.existsSync(hooksPath)).toBe(true);
+    });
+    it('should update .gitignore with rigour patterns', async () => {
+        await initCommand(testDir);
+        const gitignorePath = path.join(testDir, '.gitignore');
+        expect(fs.existsSync(gitignorePath)).toBe(true);
+        const content = fs.readFileSync(gitignorePath, 'utf-8');
+        expect(content).toContain('rigour-report.json');
+        expect(content).toContain('.rigour/');
+    });
+    it('should create .rigour/memory.json for Studio', async () => {
+        await initCommand(testDir);
+        const memPath = path.join(testDir, '.rigour', 'memory.json');
+        expect(fs.existsSync(memPath)).toBe(true);
+        const mem = JSON.parse(fs.readFileSync(memPath, 'utf-8'));
+        expect(mem.memories.project_boot).toBeDefined();
+    });
+    it('should support --ide flag to target specific IDE', async () => {
+        await initCommand(testDir, { ide: 'windsurf' });
+        // Should create windsurf rules
+        expect(fs.existsSync(path.join(testDir, '.windsurfrules'))).toBe(true);
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rigour-labs/cli",
-  "version": "3.0.0",
+  "version": "3.0.2",
   "description": "CLI quality gates for AI-generated code. Forces AI agents (Claude, Cursor, Copilot) to meet strict engineering standards with PASS/FAIL enforcement.",
   "license": "MIT",
   "homepage": "https://rigour.run",
@@ -44,7 +44,7 @@
     "inquirer": "9.2.16",
     "ora": "^8.0.1",
     "yaml": "^2.8.2",
-    "@rigour-labs/core": "3.0.0"
+    "@rigour-labs/core": "3.0.2"
   },
   "devDependencies": {
     "@types/fs-extra": "^11.0.4",