@rigour-labs/cli 2.9.4 → 2.11.0

package/dist/commands/studio.js

@@ -0,0 +1,272 @@
+import { Command } from 'commander';
+import path from 'path';
+import chalk from 'chalk';
+import { execa } from 'execa';
+import fs from 'fs-extra';
+import http from 'http';
+import { randomUUID } from 'crypto';
+export const studioCommand = new Command('studio')
+    .description('Launch Rigour Studio (Local-First Governance UI)')
+    .option('-p, --port <number>', 'Port to run the studio on', '3000')
+    .option('--dev', 'Run in development mode', true)
+    .action(async (options) => {
+    const cwd = process.cwd();
+    // Calculate the workspace root where the studio package lives
+    // This file is in packages/rigour-cli/src/commands/studio.ts (or dist/commands/studio.js)
+    const workspaceRoot = path.join(path.dirname(new URL(import.meta.url).pathname), '../../../../');
+    console.log(chalk.bold.cyan('\n🛡️ Launching Rigour Studio...'));
+    console.log(chalk.gray(`Project Root: ${cwd}`));
+    console.log(chalk.gray(`Shadowing interactions in ${path.join(cwd, '.rigour/events.jsonl')}\n`));
+    // For Phase 1, we start the studio in dev mode via pnpm
+    // This ensures the user has a live, hot-reloading governance dashboard
+    try {
+        // Start the Studio dev server in the workspace root
+        const studioProcess = execa('pnpm', ['--filter', '@rigour-labs/studio', 'dev', '--port', options.port], {
+            stdio: 'inherit',
+            shell: true,
+            cwd: workspaceRoot
+        });
+        // Start a small API server for events on port + 1
+        const apiPort = parseInt(options.port) + 1;
+        const eventsPath = path.join(cwd, '.rigour/events.jsonl');
+        const apiServer = http.createServer(async (req, res) => {
+            const url = new URL(req.url || '', `http://${req.headers.host || 'localhost'}`);
+            // Set global CORS headers
+            res.setHeader('Access-Control-Allow-Origin', '*');
+            res.setHeader('Access-Control-Allow-Methods', 'GET, OPTIONS');
+            res.setHeader('Access-Control-Allow-Headers', 'Content-Type');
+            if (req.method === 'OPTIONS') {
+                res.writeHead(204);
+                res.end();
+                return;
+            }
+            if (url.pathname === '/api/events') {
+                res.writeHead(200, {
+                    'Content-Type': 'text/event-stream',
+                    'Cache-Control': 'no-cache',
+                    'Connection': 'keep-alive'
+                });
+                // Send existing events first
+                if (await fs.pathExists(eventsPath)) {
+                    const content = await fs.readFile(eventsPath, 'utf8');
+                    const lines = content.split('\n').filter(l => l.trim());
+                    for (const line of lines) {
+                        res.write(`data: ${line}\n\n`);
+                    }
+                }
+                // Watch for new events
+                await fs.ensureDir(path.dirname(eventsPath));
+                const watcher = fs.watch(path.dirname(eventsPath), (eventType, filename) => {
+                    if (filename === 'events.jsonl') {
+                        fs.readFile(eventsPath, 'utf8').then(content => {
+                            const lines = content.split('\n').filter(l => l.trim());
+                            const lastLine = lines[lines.length - 1];
+                            if (lastLine) {
+                                res.write(`data: ${lastLine}\n\n`);
+                            }
+                        }).catch(() => { });
+                    }
+                });
+                req.on('close', () => watcher.close());
+            }
+            else if (url.pathname === '/api/file') {
+                const filePath = url.searchParams.get('path');
+                if (!filePath) {
+                    res.writeHead(400);
+                    res.end('Missing path parameter');
+                    return;
+                }
+                const absolutePath = path.resolve(cwd, filePath);
+                if (!absolutePath.startsWith(cwd)) {
+                    res.writeHead(403);
+                    res.end('Forbidden: Path outside project root');
+                    return;
+                }
+                try {
+                    const stats = await fs.stat(absolutePath);
+                    if (!stats.isFile()) {
+                        res.writeHead(400);
+                        res.end('Path is not a file');
+                        return;
+                    }
+                    const content = await fs.readFile(absolutePath, 'utf8');
+                    res.writeHead(200, { 'Content-Type': 'text/plain' });
+                    res.end(content);
+                }
+                catch (e) {
+                    res.writeHead(404);
+                    res.end(`File not found: ${e.message}`);
+                }
+            }
+            else if (url.pathname === '/api/tree') {
+                try {
+                    const getTree = async (dir) => {
+                        const entries = await fs.readdir(dir, { withFileTypes: true });
+                        let files = [];
+                        const exclude = [
+                            'node_modules', '.git', '.rigour', '.github', '.vscode', '.cursor',
+                            'venv', '.venv', 'dist', 'build', 'out', 'target', '__pycache__'
+                        ];
+                        for (const entry of entries) {
+                            if (exclude.includes(entry.name) || entry.name.startsWith('.')) {
+                                if (entry.name !== '.cursorrules' && entry.name !== '.cursor') {
+                                    continue;
+                                }
+                            }
+                            const fullPath = path.join(dir, entry.name);
+                            if (entry.isDirectory()) {
+                                files = [...files, ...(await getTree(fullPath))];
+                            }
+                            else {
+                                files.push(path.relative(cwd, fullPath));
+                            }
+                        }
+                        return files;
+                    };
+                    const tree = await getTree(cwd);
+                    res.writeHead(200, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify(tree));
+                }
+                catch (e) {
+                    res.writeHead(500);
+                    res.end(e.message);
+                }
+            }
+            else if (url.pathname === '/api/config') {
+                try {
+                    const configPath = path.join(cwd, 'rigour.yml');
+                    if (await fs.pathExists(configPath)) {
+                        const content = await fs.readFile(configPath, 'utf8');
+                        res.writeHead(200, { 'Content-Type': 'text/plain' });
+                        res.end(content);
+                    }
+                    else {
+                        res.writeHead(404);
+                        res.end('rigour.yml not found');
+                    }
+                }
+                catch (e) {
+                    res.writeHead(500);
+                    res.end(e.message);
+                }
+            }
+            else if (url.pathname === '/api/memory') {
+                try {
+                    const memoryPath = path.join(cwd, '.rigour/memory.json');
+                    if (await fs.pathExists(memoryPath)) {
+                        const content = await fs.readFile(memoryPath, 'utf8');
+                        res.writeHead(200, { 'Content-Type': 'application/json' });
+                        res.end(content);
+                    }
+                    else {
+                        res.end(JSON.stringify({}));
+                    }
+                }
+                catch (e) {
+                    res.writeHead(500);
+                    res.end(e.message);
+                }
+            }
+            else if (url.pathname === '/api/index-stats') {
+                try {
+                    const indexPath = path.join(cwd, '.rigour/patterns.json'); // Corrected path
+                    if (await fs.pathExists(indexPath)) {
+                        const content = await fs.readJson(indexPath);
+                        res.writeHead(200, { 'Content-Type': 'application/json' });
+                        res.end(JSON.stringify(content));
+                    }
+                    else {
+                        res.end(JSON.stringify({ patterns: [], stats: { totalPatterns: 0, totalFiles: 0, byType: {} } }));
+                    }
+                }
+                catch (e) {
+                    res.writeHead(500);
+                    res.end(e.message);
+                }
+            }
+            else if (url.pathname === '/api/index-search') {
+                const query = url.searchParams.get('q');
+                if (!query) {
+                    res.writeHead(400);
+                    res.end('Missing query parameter');
+                    return;
+                }
+                try {
+                    const { generateEmbedding, semanticSearch } = await import('@rigour-labs/core/pattern-index');
+                    const indexPath = path.join(cwd, '.rigour/patterns.json');
+                    if (!(await fs.pathExists(indexPath))) {
+                        res.writeHead(404);
+                        res.end('Index not found');
+                        return;
+                    }
+                    const indexData = await fs.readJson(indexPath);
+                    const queryVector = await generateEmbedding(query);
+                    const similarities = semanticSearch(queryVector, indexData.patterns);
+                    // Attach similarity to patterns and sort
+                    const results = indexData.patterns.map((p, i) => ({
+                        ...p,
+                        similarity: similarities[i]
+                    }))
+                        .filter((p) => p.similarity > 0.3) // Threshold
+                        .sort((a, b) => b.similarity - a.similarity)
+                        .slice(0, 20);
+                    res.writeHead(200, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify(results));
+                }
+                catch (e) {
+                    res.writeHead(500);
+                    res.end(e.message);
+                }
+            }
+            else if (url.pathname === '/api/arbitrate' && req.method === 'POST') {
+                let body = '';
+                req.on('data', chunk => body += chunk);
+                req.on('end', async () => {
+                    try {
+                        const decision = JSON.parse(body);
+                        const logEntry = JSON.stringify({
+                            id: randomUUID(),
+                            timestamp: new Date().toISOString(),
+                            tool: 'human_arbitration',
+                            requestId: decision.requestId,
+                            decision: decision.decision,
+                            status: decision.decision === 'approve' ? 'success' : 'error',
+                            arbitrated: true
+                        }) + "\n";
+                        await fs.appendFile(eventsPath, logEntry);
+                        res.writeHead(200);
+                        res.end(JSON.stringify({ success: true }));
+                    }
+                    catch (e) {
+                        res.writeHead(500);
+                        res.end(e.message);
+                    }
+                });
+                return;
+            }
+            else {
+                res.writeHead(404);
+                res.end();
+            }
+        });
+        apiServer.listen(apiPort, () => {
+            console.log(chalk.gray(`API Streamer active on port ${apiPort}`));
+        });
+        // Open browser
+        setTimeout(async () => {
+            const url = `http://localhost:${options.port}`;
+            console.log(chalk.green(`\n✅ Rigour Studio is live at ${chalk.bold(url)}`));
+            try {
+                await execa('open', [url]);
+            }
+            catch {
+            }
+        }, 2000);
+        await studioProcess;
+    }
+    catch (error) {
+        console.error(chalk.red(`\n❌ Failed to launch Rigour Studio: ${error.message}`));
+        console.log(chalk.yellow('Make sure to run "pnpm install" in the root directory.\n'));
+        process.exit(1);
+    }
+});

package/dist/init-rules.test.js

@@ -1,43 +1,43 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const vitest_1 = require("vitest");
-const init_js_1 = require("./commands/init.js");
-const fs_extra_1 = __importDefault(require("fs-extra"));
-const path_1 = __importDefault(require("path"));
-(0, vitest_1.describe)('Init Command Rules Verification', () => {
-    const testDir = path_1.default.join(process.cwd(), 'temp-init-rules-test');
-    (0, vitest_1.beforeEach)(async () => {
-        await fs_extra_1.default.ensureDir(testDir);
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import fs from 'fs-extra';
+import path from 'path';
+async function getInitCommand() {
+    const { initCommand } = await import('./commands/init.js');
+    return initCommand;
+}
+describe('Init Command Rules Verification', () => {
+    const testDir = path.join(process.cwd(), 'temp-init-rules-test');
+    beforeEach(async () => {
+        await fs.ensureDir(testDir);
     });
-    (0, vitest_1.afterEach)(async () => {
-        await fs_extra_1.default.remove(testDir);
+    afterEach(async () => {
+        await fs.remove(testDir);
     });
-    (0, vitest_1.it)('should create instructions with agnostic rules and cursor rules on init', async () => {
+    it('should create instructions with agnostic rules and cursor rules on init', async () => {
+        const initCommand = await getInitCommand();
         // Run init in test directory with all IDEs to verify rules in both locations
-        await (0, init_js_1.initCommand)(testDir, { ide: 'all' });
-        const instructionsPath = path_1.default.join(testDir, 'docs', 'AGENT_INSTRUCTIONS.md');
-        const mdcPath = path_1.default.join(testDir, '.cursor', 'rules', 'rigour.mdc');
-        (0, vitest_1.expect)(await fs_extra_1.default.pathExists(instructionsPath)).toBe(true);
-        (0, vitest_1.expect)(await fs_extra_1.default.pathExists(mdcPath)).toBe(true);
-        const instructionsContent = await fs_extra_1.default.readFile(instructionsPath, 'utf-8');
-        const mdcContent = await fs_extra_1.default.readFile(mdcPath, 'utf-8');
+        await initCommand(testDir, { ide: 'all' });
+        const instructionsPath = path.join(testDir, 'docs', 'AGENT_INSTRUCTIONS.md');
+        const mdcPath = path.join(testDir, '.cursor', 'rules', 'rigour.mdc');
+        expect(await fs.pathExists(instructionsPath)).toBe(true);
+        expect(await fs.pathExists(mdcPath)).toBe(true);
+        const instructionsContent = await fs.readFile(instructionsPath, 'utf-8');
+        const mdcContent = await fs.readFile(mdcPath, 'utf-8');
         // Check for agnostic instructions
-        (0, vitest_1.expect)(instructionsContent).toContain('# 🤖 CRITICAL INSTRUCTION FOR AI');
-        (0, vitest_1.expect)(instructionsContent).toContain('VERIFICATION PROOF REQUIRED');
+        expect(instructionsContent).toContain('# 🤖 CRITICAL INSTRUCTION FOR AI');
+        expect(instructionsContent).toContain('VERIFICATION PROOF REQUIRED');
         // Check for key sections in universal instructions
-        (0, vitest_1.expect)(instructionsContent).toContain('# 🛡️ Rigour: Engineering Excellence Protocol');
-        (0, vitest_1.expect)(instructionsContent).toContain('# Code Quality Standards');
+        expect(instructionsContent).toContain('# 🛡️ Rigour: Mandatory Engineering Governance Protocol');
+        expect(instructionsContent).toContain('# Code Quality Standards');
         // Check that MDC includes agnostic rules
-        (0, vitest_1.expect)(mdcContent).toContain('# 🤖 CRITICAL INSTRUCTION FOR AI');
+        expect(mdcContent).toContain('# 🤖 CRITICAL INSTRUCTION FOR AI');
     });
-    (0, vitest_1.it)('should create .clinerules when ide is cline or all', async () => {
-        await (0, init_js_1.initCommand)(testDir, { ide: 'cline' });
-        const clineRulesPath = path_1.default.join(testDir, '.clinerules');
-        (0, vitest_1.expect)(await fs_extra_1.default.pathExists(clineRulesPath)).toBe(true);
-        const content = await fs_extra_1.default.readFile(clineRulesPath, 'utf-8');
-        (0, vitest_1.expect)(content).toContain('# 🤖 CRITICAL INSTRUCTION FOR AI');
+    it('should create .clinerules when ide is cline or all', async () => {
+        const initCommand = await getInitCommand();
+        await initCommand(testDir, { ide: 'cline' });
+        const clineRulesPath = path.join(testDir, '.clinerules');
+        expect(await fs.pathExists(clineRulesPath)).toBe(true);
+        const content = await fs.readFile(clineRulesPath, 'utf-8');
+        expect(content).toContain('# 🤖 CRITICAL INSTRUCTION FOR AI');
     });
 });

package/dist/smoke.test.js

@@ -1,28 +1,26 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const vitest_1 = require("vitest");
-const check_js_1 = require("./commands/check.js");
-const fs_extra_1 = __importDefault(require("fs-extra"));
-const path_1 = __importDefault(require("path"));
-(0, vitest_1.describe)('CLI Smoke Test', () => {
-    const testDir = path_1.default.join(process.cwd(), 'temp-smoke-test');
-    (0, vitest_1.beforeEach)(async () => {
-        await fs_extra_1.default.ensureDir(testDir);
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import fs from 'fs-extra';
+import path from 'path';
+async function getCheckCommand() {
+    const { checkCommand } = await import('./commands/check.js');
+    return checkCommand;
+}
+describe('CLI Smoke Test', () => {
+    const testDir = path.join(process.cwd(), 'temp-smoke-test');
+    beforeEach(async () => {
+        await fs.ensureDir(testDir);
         // @ts-ignore
-        vitest_1.vi.spyOn(process, 'exit').mockImplementation(() => { });
+        vi.spyOn(process, 'exit').mockImplementation(() => { });
     });
-    (0, vitest_1.afterEach)(async () => {
-        await fs_extra_1.default.remove(testDir);
-        vitest_1.vi.restoreAllMocks();
+    afterEach(async () => {
+        await fs.remove(testDir);
+        vi.restoreAllMocks();
     });
-    (0, vitest_1.it)('should respect ignore patterns and avoid EPERM', async () => {
-        const restrictedDir = path_1.default.join(testDir, '.restricted');
-        await fs_extra_1.default.ensureDir(restrictedDir);
-        await fs_extra_1.default.writeFile(path_1.default.join(restrictedDir, 'secret.js'), 'TODO: leak');
-        await fs_extra_1.default.writeFile(path_1.default.join(testDir, 'rigour.yml'), `
+    it('should respect ignore patterns and avoid EPERM', async () => {
+        const restrictedDir = path.join(testDir, '.restricted');
+        await fs.ensureDir(restrictedDir);
+        await fs.writeFile(path.join(restrictedDir, 'secret.js'), 'TODO: leak');
+        await fs.writeFile(path.join(testDir, 'rigour.yml'), `
 version: 1
 ignore:
   - ".restricted/**"
@@ -31,33 +29,36 @@ gates:
   required_files: []
 `);
         // Simulate EPERM by changing permissions
-        await fs_extra_1.default.chmod(restrictedDir, 0o000);
+        await fs.chmod(restrictedDir, 0o000);
         try {
             // We need to mock process.exit or checkCommand should not exit if we want to test it easily
             // For now, we'll just verify it doesn't throw before it would exit (internal logic)
             // But checkCommand calls process.exit(1) on failure.
             // Re-importing checkCommand to ensure it uses the latest core
-            await (0, vitest_1.expect)((0, check_js_1.checkCommand)(testDir, [], { ci: true })).resolves.not.toThrow();
+            const checkCommand = await getCheckCommand();
+            await expect(checkCommand(testDir, [], { ci: true })).resolves.not.toThrow();
         }
         finally {
-            await fs_extra_1.default.chmod(restrictedDir, 0o777);
+            await fs.chmod(restrictedDir, 0o777);
         }
     });
-    (0, vitest_1.it)('should check specific files when provided', async () => {
-        await fs_extra_1.default.writeFile(path_1.default.join(testDir, 'bad.js'), 'TODO: fixme');
-        await fs_extra_1.default.writeFile(path_1.default.join(testDir, 'good.js'), 'console.log("hello")');
-        await fs_extra_1.default.writeFile(path_1.default.join(testDir, 'rigour.yml'), `
+    it('should check specific files when provided', async () => {
+        await fs.writeFile(path.join(testDir, 'bad.js'), 'TODO: fixme');
+        await fs.writeFile(path.join(testDir, 'good.js'), 'console.log("hello")');
+        await fs.writeFile(path.join(testDir, 'rigour.yml'), `
 version: 1
 gates:
   forbid_todos: true
   required_files: []
 `);
         // If we check ONLY good.js, it should PASS (exit PASS)
-        await (0, check_js_1.checkCommand)(testDir, [path_1.default.join(testDir, 'good.js')], { ci: true });
-        (0, vitest_1.expect)(process.exit).toHaveBeenCalledWith(0);
+        const checkCommand = await getCheckCommand();
+        await checkCommand(testDir, [path.join(testDir, 'good.js')], { ci: true });
+        expect(process.exit).toHaveBeenCalledWith(0);
         // If we check bad.js, it should FAIL (exit FAIL)
-        vitest_1.vi.clearAllMocks();
-        await (0, check_js_1.checkCommand)(testDir, [path_1.default.join(testDir, 'bad.js')], { ci: true });
-        (0, vitest_1.expect)(process.exit).toHaveBeenCalledWith(1);
+        vi.clearAllMocks();
+        const checkCommandFail = await getCheckCommand();
+        await checkCommandFail(testDir, [path.join(testDir, 'bad.js')], { ci: true });
+        expect(process.exit).toHaveBeenCalledWith(1);
     });
 });

package/package.json

@@ -1,6 +1,7 @@
 {
   "name": "@rigour-labs/cli",
-  "version": "2.9.4",
+  "version": "2.11.0",
+  "type": "module",
   "bin": {
     "rigour": "dist/cli.js"
   },
@@ -20,8 +21,9 @@
     "fs-extra": "^11.2.0",
     "globby": "^14.0.1",
     "inquirer": "9.2.16",
+    "ora": "^8.0.1",
     "yaml": "^2.8.2",
-    "@rigour-labs/core": "2.9.4"
+    "@rigour-labs/core": "2.11.0"
   },
   "devDependencies": {
     "@types/fs-extra": "^11.0.4",

package/src/cli.ts

@@ -6,10 +6,15 @@ import { explainCommand } from './commands/explain.js';
 import { runLoop } from './commands/run.js';
 import { guideCommand } from './commands/guide.js';
 import { setupCommand } from './commands/setup.js';
+import { indexCommand } from './commands/index.js';
+import { studioCommand } from './commands/studio.js';
 import chalk from 'chalk';
 
 const program = new Command();
 
+program.addCommand(indexCommand);
+program.addCommand(studioCommand);
+
 program
     .name('rigour')
     .description('🛡️ Rigour: The Quality Gate Loop for AI-Assisted Engineering')

package/src/commands/check.ts

@@ -4,6 +4,7 @@ import chalk from 'chalk';
 import yaml from 'yaml';
 import { GateRunner, ConfigSchema, Failure } from '@rigour-labs/core';
 import inquirer from 'inquirer';
+import { randomUUID } from 'crypto';
 
 // Exit codes per spec
 const EXIT_PASS = 0;
@@ -17,6 +18,23 @@ export interface CheckOptions {
     interactive?: boolean;
 }
 
+// Helper to log events for Rigour Studio
+async function logStudioEvent(cwd: string, event: any) {
+    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
+    }
+}
+
 export async function checkCommand(cwd: string, files: string[] = [], options: CheckOptions = {}) {
     const configPath = path.join(cwd, 'rigour.yml');
 
@@ -39,12 +57,30 @@ export async function checkCommand(cwd: string, files: string[] = [], options: C
         }
 
         const runner = new GateRunner(config);
+
+        const requestId = randomUUID();
+        await logStudioEvent(cwd, {
+            type: "tool_call",
+            requestId,
+            tool: "rigour_check",
+            arguments: { files }
+        });
+
         const report = await runner.run(cwd, files.length > 0 ? files : undefined);
 
         // Write machine report
         const reportPath = path.join(cwd, config.output.report_path);
         await fs.writeJson(reportPath, report, { spaces: 2 });
 
+        await logStudioEvent(cwd, {
+            type: "tool_response",
+            requestId,
+            tool: "rigour_check",
+            status: report.status === 'PASS' ? 'success' : 'error',
+            content: [{ type: "text", text: `Audit Result: ${report.status}` }],
+            _rigour_report: report
+        });
+
         // Generate Fix Packet v2 on failure
         if (report.status === 'FAIL') {
             const { FixPacketService } = await import('@rigour-labs/core');

package/src/commands/index.ts

@@ -0,0 +1,105 @@
+/**
+ * Index Command
+ * 
+ * Builds and updates the Rigour Pattern Index to prevent code reinvention.
+ */
+
+import { Command } from 'commander';
+import path from 'path';
+import chalk from 'chalk';
+import ora from 'ora';
+import fs from 'fs-extra';
+import { randomUUID } from 'crypto';
+
+// Helper to log events for Rigour Studio
+async function logStudioEvent(cwd: string, event: any) {
+    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
+    }
+}
+// Dynamic imports are used inside the action handler below to prevent
+// native dependency issues from affecting the rest of the CLI.
+
+export const indexCommand = new Command('index')
+    .description('Build or update the pattern index for the current project')
+    .option('-s, --semantic', 'Generate semantic embeddings for better matching (requires Transformers.js)', false)
+    .option('-f, --force', 'Force a full rebuild of the index', false)
+    .option('-o, --output <path>', 'Custom path for the index file')
+    .action(async (options) => {
+        const cwd = process.cwd();
+
+        // Dynamic import to isolate native dependencies
+        const {
+            PatternIndexer,
+            savePatternIndex,
+            loadPatternIndex,
+            getDefaultIndexPath
+        } = await import('@rigour-labs/core/pattern-index');
+
+        const indexPath = options.output || getDefaultIndexPath(cwd);
+        const spinner = ora('Initializing pattern indexer...').start();
+
+        try {
+            const requestId = randomUUID();
+            await logStudioEvent(cwd, {
+                type: "tool_call",
+                requestId,
+                tool: "rigour_index",
+                arguments: options
+            });
+
+            const indexer = new PatternIndexer(cwd, {
+                useEmbeddings: options.semantic
+            });
+
+            let index;
+            const existingIndex = await loadPatternIndex(indexPath);
+
+            if (existingIndex && !options.force) {
+                spinner.text = 'Updating existing pattern index...';
+                index = await indexer.updateIndex(existingIndex);
+            } else {
+                spinner.text = 'Building fresh pattern index (this may take a while)...';
+                index = await indexer.buildIndex();
+            }
+
+            spinner.text = 'Saving index to disk...';
+            await savePatternIndex(index, indexPath);
+
+            spinner.succeed(chalk.green(`Pattern index built successfully!`));
+
+            await logStudioEvent(cwd, {
+                type: "tool_response",
+                requestId,
+                tool: "rigour_index",
+                status: "success",
+                content: [{ type: "text", text: `Index built: ${index.stats.totalPatterns} patterns` }]
+            });
+            console.log(chalk.blue(`- Total Patterns: ${index.stats.totalPatterns}`));
+            console.log(chalk.blue(`- Total Files: ${index.stats.totalFiles}`));
+            console.log(chalk.blue(`- Index Path: ${indexPath}`));
+
+            if (options.semantic) {
+                console.log(chalk.magenta(`- Semantic Search: Enabled (Local Transformers.js)`));
+            }
+
+            const byType = Object.entries(index.stats.byType)
+                .map(([type, count]) => `${type}: ${count}`)
+                .join(', ');
+            console.log(chalk.gray(`Types: ${byType}`));
+
+        } catch (error: any) {
+            spinner.fail(chalk.red(`Failed to build pattern index: ${error.message}`));
+            process.exit(1);
+        }
+    });