@rigour-labs/cli 2.9.3 → 2.10.0

package/dist/cli.js

@@ -11,8 +11,10 @@ const explain_js_1 = require("./commands/explain.js");
 const run_js_1 = require("./commands/run.js");
 const guide_js_1 = require("./commands/guide.js");
 const setup_js_1 = require("./commands/setup.js");
+const index_js_1 = require("./commands/index.js");
 const chalk_1 = __importDefault(require("chalk"));
 const program = new commander_1.Command();
+program.addCommand(index_js_1.indexCommand);
 program
     .name('rigour')
     .description('🛡️ Rigour: The Quality Gate Loop for AI-Assisted Engineering')

package/dist/commands/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Index Command
+ *
+ * Builds and updates the Rigour Pattern Index to prevent code reinvention.
+ */
+import { Command } from 'commander';
+export declare const indexCommand: Command;

package/dist/commands/index.js

@@ -0,0 +1,60 @@
+"use strict";
+/**
+ * Index Command
+ *
+ * Builds and updates the Rigour Pattern Index to prevent code reinvention.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.indexCommand = void 0;
+const commander_1 = require("commander");
+const chalk_1 = __importDefault(require("chalk"));
+const ora_1 = __importDefault(require("ora"));
+// Dynamic imports are used inside the action handler below to prevent
+// native dependency issues from affecting the rest of the CLI.
+exports.indexCommand = new commander_1.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 = (0, ora_1.default)('Initializing pattern indexer...').start();
+    try {
+        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_1.default.green(`Pattern index built successfully!`));
+        console.log(chalk_1.default.blue(`- Total Patterns: ${index.stats.totalPatterns}`));
+        console.log(chalk_1.default.blue(`- Total Files: ${index.stats.totalFiles}`));
+        console.log(chalk_1.default.blue(`- Index Path: ${indexPath}`));
+        if (options.semantic) {
+            console.log(chalk_1.default.magenta(`- Semantic Search: Enabled (Local Transformers.js)`));
+        }
+        const byType = Object.entries(index.stats.byType)
+            .map(([type, count]) => `${type}: ${count}`)
+            .join(', ');
+        console.log(chalk_1.default.gray(`Types: ${byType}`));
+    }
+    catch (error) {
+        spinner.fail(chalk_1.default.red(`Failed to build pattern index: ${error.message}`));
+        process.exit(1);
+    }
+});

package/dist/init-rules.test.js

@@ -4,9 +4,12 @@ var __importDefault = (this && this.__importDefault) || function (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"));
+async function getInitCommand() {
+    const { initCommand } = await import('./commands/init.js');
+    return initCommand;
+}
 (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 () => {
@@ -16,8 +19,9 @@ const path_1 = __importDefault(require("path"));
         await fs_extra_1.default.remove(testDir);
     });
     (0, vitest_1.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' });
+        await 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);
@@ -34,7 +38,8 @@ const path_1 = __importDefault(require("path"));
         (0, vitest_1.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 initCommand = await getInitCommand();
+        await 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');

package/dist/smoke.test.js

@@ -4,9 +4,12 @@ var __importDefault = (this && this.__importDefault) || function (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"));
+async function getCheckCommand() {
+    const { checkCommand } = await import('./commands/check.js');
+    return checkCommand;
+}
 (0, vitest_1.describe)('CLI Smoke Test', () => {
     const testDir = path_1.default.join(process.cwd(), 'temp-smoke-test');
     (0, vitest_1.beforeEach)(async () => {
@@ -37,7 +40,8 @@ gates:
             // 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 (0, vitest_1.expect)(checkCommand(testDir, [], { ci: true })).resolves.not.toThrow();
         }
         finally {
             await fs_extra_1.default.chmod(restrictedDir, 0o777);
@@ -53,11 +57,13 @@ gates:
   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 });
+        const checkCommand = await getCheckCommand();
+        await checkCommand(testDir, [path_1.default.join(testDir, 'good.js')], { ci: true });
         (0, vitest_1.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 });
+        const checkCommandFail = await getCheckCommand();
+        await checkCommandFail(testDir, [path_1.default.join(testDir, 'bad.js')], { ci: true });
         (0, vitest_1.expect)(process.exit).toHaveBeenCalledWith(1);
     });
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rigour-labs/cli",
-  "version": "2.9.3",
+  "version": "2.10.0",
   "bin": {
     "rigour": "dist/cli.js"
   },
@@ -20,8 +20,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.3"
+    "@rigour-labs/core": "2.10.0"
   },
   "devDependencies": {
     "@types/fs-extra": "^11.0.4",

package/src/cli.ts

@@ -6,10 +6,13 @@ 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 chalk from 'chalk';
 
 const program = new Command();
 
+program.addCommand(indexCommand);
+
 program
     .name('rigour')
     .description('🛡️ Rigour: The Quality Gate Loop for AI-Assisted Engineering')

package/src/commands/index.ts

@@ -0,0 +1,70 @@
+/**
+ * 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';
+// 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 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!`));
+            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);
+        }
+    });

package/src/init-rules.test.ts

@@ -1,8 +1,14 @@
 import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
-import { initCommand } from './commands/init.js';
+
+
 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');
 
@@ -15,6 +21,7 @@ describe('Init Command Rules Verification', () => {
     });
 
     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 initCommand(testDir, { ide: 'all' });
 
@@ -40,6 +47,7 @@ describe('Init Command Rules Verification', () => {
     });
 
     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);

package/src/smoke.test.ts

@@ -1,8 +1,13 @@
 import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
-import { checkCommand } from './commands/check.js';
+
 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');
 
@@ -40,6 +45,7 @@ gates:
             // But checkCommand calls process.exit(1) on failure.
 
             // Re-importing checkCommand to ensure it uses the latest core
+            const checkCommand = await getCheckCommand();
             await expect(checkCommand(testDir, [], { ci: true })).resolves.not.toThrow();
         } finally {
             await fs.chmod(restrictedDir, 0o777);
@@ -57,12 +63,14 @@ gates:
 `);
 
         // If we check ONLY good.js, it should PASS (exit PASS)
+        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)
         vi.clearAllMocks();
-        await checkCommand(testDir, [path.join(testDir, 'bad.js')], { ci: true });
+        const checkCommandFail = await getCheckCommand();
+        await checkCommandFail(testDir, [path.join(testDir, 'bad.js')], { ci: true });
         expect(process.exit).toHaveBeenCalledWith(1);
     });
 });

package/vitest.config.ts

@@ -0,0 +1,10 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+    test: {
+        setupFiles: ['./vitest.setup.ts'],
+        deps: {
+            external: ['@xenova/transformers', 'sharp'],
+        },
+    },
+});

package/vitest.setup.ts

@@ -0,0 +1,30 @@
+import { vi } from 'vitest';
+
+// Mock Transformers.js to avoid native binary dependency issues and speed up tests
+vi.mock('@xenova/transformers', () => ({
+    pipeline: async () => {
+        // Return a mock extractor that produces deterministic "embeddings"
+        return async (text: string) => {
+            // Create a fake vector based on the text length or hash
+            const vector = new Array(384).fill(0);
+            for (let i = 0; i < Math.min(text.length, 384); i++) {
+                vector[i] = text.charCodeAt(i) / 255;
+            }
+            return { data: new Float32Array(vector) };
+        };
+    },
+    env: {
+        allowImageProcessors: false,
+    },
+}));
+
+// Also mock sharp just in case something else pulls it in
+vi.mock('sharp', () => ({
+    default: () => ({
+        resize: () => ({
+            toFormat: () => ({
+                toBuffer: async () => Buffer.from([]),
+            }),
+        }),
+    }),
+}));