@rigour-labs/cli 2.11.0 → 2.13.0

package/src/commands/studio.ts

@@ -1,273 +0,0 @@
-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: any) {
-                        res.writeHead(404);
-                        res.end(`File not found: ${e.message}`);
-                    }
-                } else if (url.pathname === '/api/tree') {
-                    try {
-                        const getTree = async (dir: string): Promise<string[]> => {
-                            const entries = await fs.readdir(dir, { withFileTypes: true });
-                            let files: string[] = [];
-                            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: any) {
-                        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: any) {
-                        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: any) {
-                        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: any) {
-                        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: any, i: number) => ({
-                            ...p,
-                            similarity: similarities[i]
-                        }))
-                            .filter((p: any) => p.similarity > 0.3) // Threshold
-                            .sort((a: any, b: any) => b.similarity - a.similarity)
-                            .slice(0, 20);
-
-                        res.writeHead(200, { 'Content-Type': 'application/json' });
-                        res.end(JSON.stringify(results));
-                    } catch (e: any) {
-                        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: any) {
-                            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: any) {
-            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/src/init-rules.test.ts

@@ -1,59 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach, vi } 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);
-    });
-
-    afterEach(async () => {
-        await fs.remove(testDir);
-    });
-
-    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' });
-
-        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
-        expect(instructionsContent).toContain('# 🤖 CRITICAL INSTRUCTION FOR AI');
-        expect(instructionsContent).toContain('VERIFICATION PROOF REQUIRED');
-
-        // Check for key sections in universal instructions
-        expect(instructionsContent).toContain('# 🛡️ Rigour: Mandatory Engineering Governance Protocol');
-        expect(instructionsContent).toContain('# Code Quality Standards');
-
-        // Check that MDC includes agnostic rules
-        expect(mdcContent).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/src/smoke.test.ts

@@ -1,76 +0,0 @@
-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
-        vi.spyOn(process, 'exit').mockImplementation(() => { });
-    });
-
-    afterEach(async () => {
-        await fs.remove(testDir);
-        vi.restoreAllMocks();
-    });
-
-    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/**"
-gates:
-  forbid_todos: true
-  required_files: []
-`);
-
-        // Simulate EPERM by changing permissions
-        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
-            const checkCommand = await getCheckCommand();
-            await expect(checkCommand(testDir, [], { ci: true })).resolves.not.toThrow();
-        } finally {
-            await fs.chmod(restrictedDir, 0o777);
-        }
-    });
-
-    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)
-        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();
-        const checkCommandFail = await getCheckCommand();
-        await checkCommandFail(testDir, [path.join(testDir, 'bad.js')], { ci: true });
-        expect(process.exit).toHaveBeenCalledWith(1);
-    });
-});

package/src/templates/handshake.mdc

@@ -1,36 +0,0 @@
----
-description: Mandatory Rigour Governance Protocol - Automated engineering enforcement (SOLID, DRY, Patterns).
-globs: **/*
----
-
-# 🛡️ Rigour: Mandatory Engineering Governance
-
-**You are an AI Engineering Agent governed by Rigour.** 
-
-Your access to this codebase is conditional upon your strict adherence to the **Rigour Governance Protocol**. This is not a recommendation; it is an automated requirement for every interaction.
-
-## 🚦 The Mandatory Governance Loop
-You MUST execute this loop for every engineering task. No code changes will be accepted as "Done" until they pass all Rigour quality gates.
-
-1.  **Recall Context**: Call `rigour_recall` at the start of every session to align with project-specific engineering memory.
-2.  **Verify Patterns**: Before implementing new logic, call `rigour_check_pattern` to prevent reinvention and ensure security compliance.
-3.  **Audit Enforcement**: Before finishing, you MUST call `rigour_check`.
-4.  **Failure Remediation**: If `rigour_check` returns **FAIL**, you MUST call `rigour_get_fix_packet` and implement all required engineering refinements.
-5.  **PASS or REJECT**: You may only declare a task complete when `rigour_check` returns **PASS**.
-
-## 🧩 Governance Standards
-Your logic is automatically audited against these core engineering gates:
-
-### 1. Architectural Integrity (SOLID)
-- **SRP**: Every component must have one reason to change.
-- **DIP**: Depend on abstractions, not concretions.
-
-### 2. Efficiency & Security (DRY + CVE)
-- **No Reinvention**: Reuse existing patterns identified by Rigour.
-- **Safety**: No vulnerable libraries or deprecated patterns allowed.
-
-## ⚖️ Transparency & Accountability
-**Every action, tool call, and logic shift you perform is automatically logged to the project's local audit trail.** This data is visible in real-time to the human governor in **Rigour Studio**. Failure to follow this protocol will be flagged as a governance violation.
-
-**GOVERNANCE STATUS: ACTIVE**
-**ENFORCEMENT: MANDATORY**

package/tsconfig.json

@@ -1,10 +0,0 @@
-{
-    "extends": "../../tsconfig.json",
-    "compilerOptions": {
-        "outDir": "dist",
-        "rootDir": "src"
-    },
-    "include": [
-        "src/**/*"
-    ]
-}

package/vitest.config.ts

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

package/vitest.setup.ts

@@ -1,30 +0,0 @@
-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([]),
-            }),
-        }),
-    }),
-}));