@rigour-labs/cli 2.10.0 → 2.12.0

package/src/commands/init.ts

@@ -1,366 +0,0 @@
-import fs from 'fs-extra';
-import path from 'path';
-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';
-
-export interface InitOptions {
-    preset?: string;
-    paradigm?: string;
-    ide?: 'cursor' | 'vscode' | 'cline' | 'claude' | 'gemini' | 'codex' | 'windsurf' | 'all';
-    dryRun?: boolean;
-    explain?: boolean;
-}
-
-type DetectedIDE = 'cursor' | 'vscode' | 'cline' | 'claude' | 'gemini' | 'codex' | 'windsurf' | 'unknown';
-
-function detectIDE(cwd: string): DetectedIDE {
-    // Check for Claude Code markers
-    if (fs.existsSync(path.join(cwd, 'CLAUDE.md')) || fs.existsSync(path.join(cwd, '.claude'))) {
-        return 'claude';
-    }
-
-    // Check for Gemini Code Assist markers
-    if (fs.existsSync(path.join(cwd, '.gemini'))) {
-        return 'gemini';
-    }
-
-    // Check for Codex/Aider AGENTS.md (universal standard)
-    if (fs.existsSync(path.join(cwd, 'AGENTS.md'))) {
-        return 'codex';
-    }
-
-    // Check for Windsurf markers
-    if (fs.existsSync(path.join(cwd, '.windsurfrules')) || fs.existsSync(path.join(cwd, '.windsurf'))) {
-        return 'windsurf';
-    }
-
-    // Check for Cline-specific markers
-    if (fs.existsSync(path.join(cwd, '.clinerules'))) {
-        return 'cline';
-    }
-
-    // Check for Cursor-specific markers
-    if (fs.existsSync(path.join(cwd, '.cursor'))) {
-        return 'cursor';
-    }
-
-    // Check for VS Code markers
-    if (fs.existsSync(path.join(cwd, '.vscode'))) {
-        return 'vscode';
-    }
-
-    // Check environment variables that IDEs/Agents set
-    const termProgram = process.env.TERM_PROGRAM || '';
-    const terminal = process.env.TERMINAL_EMULATOR || '';
-    const appName = process.env.APP_NAME || '';
-
-    if (termProgram.toLowerCase().includes('cursor') || terminal.toLowerCase().includes('cursor')) {
-        return 'cursor';
-    }
-
-    if (termProgram.toLowerCase().includes('cline') || appName.toLowerCase().includes('cline')) {
-        return 'cline';
-    }
-
-    if (termProgram.toLowerCase().includes('vscode') || process.env.VSCODE_INJECTION) {
-        return 'vscode';
-    }
-
-    // Check for Claude Code environment
-    if (process.env.CLAUDE_CODE || process.env.ANTHROPIC_API_KEY) {
-        return 'claude';
-    }
-
-    // Check for Gemini environment
-    if (process.env.GEMINI_API_KEY || process.env.GOOGLE_CLOUD_PROJECT) {
-        return 'gemini';
-    }
-
-    return 'unknown';
-}
-
-
-export async function initCommand(cwd: string, options: InitOptions = {}) {
-    const discovery = new DiscoveryService();
-    const result = await discovery.discover(cwd);
-    let recommendedConfig = result.config;
-
-    // Override with user options if provided and re-apply template logic if necessary
-    if (options.preset || options.paradigm) {
-        const core = await import('@rigour-labs/core');
-
-        let customBase = { ...core.UNIVERSAL_CONFIG };
-
-        if (options.preset) {
-            const t = core.TEMPLATES.find((t: any) => t.name === options.preset);
-            if (t) customBase = (discovery as any).mergeConfig(customBase, t.config);
-        } else if (recommendedConfig.preset) {
-            const t = core.TEMPLATES.find((t: any) => t.name === recommendedConfig.preset);
-            if (t) customBase = (discovery as any).mergeConfig(customBase, t.config);
-        }
-
-        if (options.paradigm) {
-            const t = core.PARADIGM_TEMPLATES.find((t: any) => t.name === options.paradigm);
-            if (t) customBase = (discovery as any).mergeConfig(customBase, t.config);
-        } else if (recommendedConfig.paradigm) {
-            const t = core.PARADIGM_TEMPLATES.find((t: any) => t.name === recommendedConfig.paradigm);
-            if (t) customBase = (discovery as any).mergeConfig(customBase, t.config);
-        }
-
-        recommendedConfig = customBase;
-        if (options.preset) recommendedConfig.preset = options.preset;
-        if (options.paradigm) recommendedConfig.paradigm = options.paradigm;
-    }
-
-    if (options.dryRun || options.explain) {
-        console.log(chalk.bold.blue('\n🔍 Rigour Auto-Discovery (Dry Run):'));
-        if (recommendedConfig.preset) {
-            console.log(chalk.cyan(`   Role: `) + chalk.bold(recommendedConfig.preset.toUpperCase()));
-            if (options.explain && result.matches.preset) {
-                console.log(chalk.dim(`         (Marker found: ${result.matches.preset.marker})`));
-            }
-        }
-        if (recommendedConfig.paradigm) {
-            console.log(chalk.cyan(`   Paradigm: `) + chalk.bold(recommendedConfig.paradigm.toUpperCase()));
-            if (options.explain && result.matches.paradigm) {
-                console.log(chalk.dim(`             (Marker found: ${result.matches.paradigm.marker})`));
-            }
-        }
-        console.log(chalk.yellow('\n[DRY RUN] No files will be written.'));
-        return;
-    }
-
-    const configPath = path.join(cwd, 'rigour.yml');
-
-    if (await fs.pathExists(configPath)) {
-        console.log(chalk.yellow('rigour.yml already exists. Skipping initialization.'));
-        return;
-    }
-
-    console.log(chalk.bold.blue('\n🔍 Rigour Auto-Discovery:'));
-    if (recommendedConfig.preset) {
-        console.log(chalk.cyan(`   Role: `) + chalk.bold(recommendedConfig.preset.toUpperCase()));
-    }
-    if (recommendedConfig.paradigm) {
-        console.log(chalk.cyan(`   Paradigm: `) + chalk.bold(recommendedConfig.paradigm.toUpperCase()));
-    }
-    console.log('');
-
-    const yamlHeader = `# ⚠️ TEAM STANDARD - DO NOT MODIFY WITHOUT TEAM APPROVAL
-# AI Assistants: Adjust YOUR code to meet these standards, not the other way around.
-# Modifying thresholds or adding ignores to pass checks defeats the purpose of Rigour.
-# See: docs/AGENT_INSTRUCTIONS.md for the correct workflow.
-
-`;
-    await fs.writeFile(configPath, yamlHeader + yaml.stringify(recommendedConfig));
-    console.log(chalk.green('✔ Created rigour.yml'));
-
-    // Create required directories and files
-    const requireddocs = recommendedConfig.gates.required_files || [];
-    for (const file of requireddocs) {
-        const filePath = path.join(cwd, file);
-        if (!(await fs.pathExists(filePath))) {
-            await fs.ensureFile(filePath);
-            console.log(chalk.dim(`  - Created ${file}`));
-        }
-    }
-
-    // Agent Handshake (Universal / AntiGravity / Cursor)
-    const rigourDocsDir = path.join(cwd, 'docs');
-    await fs.ensureDir(rigourDocsDir);
-    const instructionsPath = path.join(rigourDocsDir, 'AGENT_INSTRUCTIONS.md');
-
-    const ruleContent = `# 🛡️ Rigour: Engineering Excellence Protocol
-
-You are an Elite Software Engineer. You do not just write code that "works"; you write code that is **modular, maintainable, and rigorously verified.**
-
-## 🚦 The Rigour Loop (Mandatory)
-Before claiming "Done" for any task, you MUST follow this loop:
-
-1.  **Check**: Run \`npx @rigour-labs/cli check\` to verify compliance.
-2.  **Analyze**: If it fails, read \`rigour-fix-packet.json\` (V2 High-Fidelity) for exact failure points and constraints.
-3.  **Refactor**: Apply **SOLID** and **DRY** principles to resolve the violations according to constraints.
-4.  **Repeat**: Continue until \`npx @rigour-labs/cli check\` returns **PASS**.
-
-## 🛠️ Commands
-\`\`\`bash
-# Verify current state
-npx @rigour-labs/cli check
-
-# Self-healing agent loop
-npx @rigour-labs/cli run -- <agent-command>
-\`\`\`
-
-${AGNOSTIC_AI_INSTRUCTIONS}
-${CODE_QUALITY_RULES}
-
-${DEBUGGING_RULES}
-
-${COLLABORATION_RULES}
-`;
-
-    // 1. Create Universal Instructions
-    if (!(await fs.pathExists(instructionsPath))) {
-        await fs.writeFile(instructionsPath, ruleContent);
-        console.log(chalk.green('✔ Initialized Universal Agent Handshake (docs/AGENT_INSTRUCTIONS.md)'));
-    }
-
-    // 2. Create IDE-Specific Rules based on detection or user preference
-    const detectedIDE = detectIDE(cwd);
-    const targetIDE = options.ide || (detectedIDE !== 'unknown' ? detectedIDE : 'all');
-
-    if (detectedIDE !== 'unknown' && !options.ide) {
-        console.log(chalk.dim(`   (Auto-detected IDE: ${detectedIDE})`));
-    }
-
-    if (targetIDE === 'cursor' || targetIDE === 'all') {
-        const cursorRulesDir = path.join(cwd, '.cursor', 'rules');
-        await fs.ensureDir(cursorRulesDir);
-        const mdcPath = path.join(cursorRulesDir, 'rigour.mdc');
-        const mdcContent = `---
-description: Enforcement of Rigour quality gates and best practices.
-globs: **/*
----
-
-${ruleContent}`;
-
-        if (!(await fs.pathExists(mdcPath))) {
-            await fs.writeFile(mdcPath, mdcContent);
-            console.log(chalk.green('✔ Initialized Cursor Handshake (.cursor/rules/rigour.mdc)'));
-        }
-    }
-
-    if (targetIDE === 'vscode' || targetIDE === 'all') {
-        // VS Code users use the universal AGENT_INSTRUCTIONS.md (already created above)
-        // We could also add .vscode/settings.json or snippets here if needed
-        console.log(chalk.green('✔ VS Code mode - using Universal Handshake (docs/AGENT_INSTRUCTIONS.md)'));
-    }
-
-    if (targetIDE === 'cline' || targetIDE === 'all') {
-        const clineRulesPath = path.join(cwd, '.clinerules');
-        if (!(await fs.pathExists(clineRulesPath))) {
-            await fs.writeFile(clineRulesPath, ruleContent);
-            console.log(chalk.green('✔ Initialized Cline Handshake (.clinerules)'));
-        }
-    }
-
-    // Claude Code (CLAUDE.md)
-    if (targetIDE === 'claude' || targetIDE === 'all') {
-        const claudePath = path.join(cwd, 'CLAUDE.md');
-        const claudeContent = `# CLAUDE.md - Project Instructions for Claude Code
-
-This file provides Claude Code with context about this project.
-
-## Project Overview
-
-This project uses Rigour for quality gates. Always run \`npx @rigour-labs/cli check\` before marking tasks complete.
-
-## Commands
-
-\`\`\`bash
-# Verify quality gates
-npx @rigour-labs/cli check
-
-# Get fix packet for failures
-npx @rigour-labs/cli explain
-
-# Self-healing agent loop
-npx @rigour-labs/cli run -- claude "<task>"
-\`\`\`
-
-${ruleContent}`;
-
-        if (!(await fs.pathExists(claudePath))) {
-            await fs.writeFile(claudePath, claudeContent);
-            console.log(chalk.green('✔ Initialized Claude Code Handshake (CLAUDE.md)'));
-        }
-    }
-
-    // Gemini Code Assist (.gemini/styleguide.md)
-    if (targetIDE === 'gemini' || targetIDE === 'all') {
-        const geminiDir = path.join(cwd, '.gemini');
-        await fs.ensureDir(geminiDir);
-        const geminiStylePath = path.join(geminiDir, 'styleguide.md');
-        const geminiContent = `# Gemini Code Assist Style Guide
-
-This project uses Rigour for quality gates.
-
-## Required Before Completion
-
-Always run \`npx @rigour-labs/cli check\` before marking any task complete.
-
-${ruleContent}`;
-
-        if (!(await fs.pathExists(geminiStylePath))) {
-            await fs.writeFile(geminiStylePath, geminiContent);
-            console.log(chalk.green('✔ Initialized Gemini Handshake (.gemini/styleguide.md)'));
-        }
-    }
-
-    // OpenAI Codex / Aider (AGENTS.md - Universal Standard)
-    if (targetIDE === 'codex' || targetIDE === 'all') {
-        const agentsPath = path.join(cwd, 'AGENTS.md');
-        const agentsContent = `# AGENTS.md - Universal AI Agent Instructions
-
-This file provides instructions for AI coding agents (Codex, Aider, and others).
-
-## Setup
-
-\`\`\`bash
-npm install
-npm run dev
-npm test
-\`\`\`
-
-## Quality Gates
-
-This project uses Rigour. Before completing any task:
-
-\`\`\`bash
-npx @rigour-labs/cli check
-\`\`\`
-
-${ruleContent}`;
-
-        if (!(await fs.pathExists(agentsPath))) {
-            await fs.writeFile(agentsPath, agentsContent);
-            console.log(chalk.green('✔ Initialized Universal Agent Handshake (AGENTS.md)'));
-        }
-    }
-
-    // Windsurf (.windsurfrules)
-    if (targetIDE === 'windsurf' || targetIDE === 'all') {
-        const windsurfPath = path.join(cwd, '.windsurfrules');
-        if (!(await fs.pathExists(windsurfPath))) {
-            await fs.writeFile(windsurfPath, ruleContent);
-            console.log(chalk.green('✔ Initialized Windsurf Handshake (.windsurfrules)'));
-        }
-    }
-
-    // 3. Update .gitignore
-    const gitignorePath = path.join(cwd, '.gitignore');
-    const ignorePatterns = ['rigour-report.json', 'rigour-fix-packet.json', '.rigour/'];
-    try {
-        let content = '';
-        if (await fs.pathExists(gitignorePath)) {
-            content = await fs.readFile(gitignorePath, 'utf-8');
-        }
-
-        const toAdd = ignorePatterns.filter(p => !content.includes(p));
-        if (toAdd.length > 0) {
-            const separator = content.endsWith('\n') ? '' : '\n';
-            const newContent = `${content}${separator}\n# Rigour Artifacts\n${toAdd.join('\n')}\n`;
-            await fs.writeFile(gitignorePath, newContent);
-            console.log(chalk.green('✔ Updated .gitignore'));
-        }
-    } catch (e) {
-        // Failing to update .gitignore isn't fatal
-    }
-
-    console.log(chalk.blue('\nRigour is ready. Run `npx @rigour-labs/cli check` to verify your project.'));
-    console.log(chalk.dim('\n💡 Tip: Planning to use a framework like Next.js?'));
-    console.log(chalk.dim('   Run its scaffolding tool (e.g., npx create-next-app) BEFORE rigour init,'));
-    console.log(chalk.dim('   or move rigour.yml and docs/ aside temporarily to satisfy empty-directory checks.'));
-}

package/src/commands/run.ts

@@ -1,135 +0,0 @@
-import fs from 'fs-extra';
-import path from 'path';
-import chalk from 'chalk';
-import yaml from 'yaml';
-import { execa } from 'execa';
-import { GateRunner, ConfigSchema } from '@rigour-labs/core';
-
-// Exit codes per spec
-const EXIT_PASS = 0;
-const EXIT_FAIL = 1;
-const EXIT_CONFIG_ERROR = 2;
-const EXIT_INTERNAL_ERROR = 3;
-
-export async function runLoop(cwd: string, agentArgs: string[], options: { iterations: number, failFast?: boolean }) {
-    const configPath = path.join(cwd, 'rigour.yml');
-
-    if (!(await fs.pathExists(configPath))) {
-        console.error(chalk.red('Error: rigour.yml not found. Run `rigour init` first.'));
-        process.exit(EXIT_CONFIG_ERROR);
-    }
-
-    try {
-        const configContent = await fs.readFile(configPath, 'utf-8');
-        const rawConfig = yaml.parse(configContent);
-        const config = ConfigSchema.parse(rawConfig);
-        const runner = new GateRunner(config);
-
-        let iteration = 0;
-        const maxIterations = options.iterations;
-
-        while (iteration < maxIterations) {
-            iteration++;
-            console.log(chalk.bold.blue(`\n══════════════════════════════════════════════════════════════════`));
-            console.log(chalk.bold.blue(`  RIGOUR LOOP: Iteration ${iteration}/${maxIterations}`));
-            console.log(chalk.bold.blue(`══════════════════════════════════════════════════════════════════`));
-
-            // 1. Prepare Command
-            let currentArgs = [...agentArgs];
-            if (iteration > 1 && agentArgs.length > 0) {
-                // Iteration contract: In later cycles, we focus strictly on the fix packet
-                console.log(chalk.yellow(`\n🔄 REFINEMENT CYCLE - Instructing agent to fix specific violations...`));
-                // We keep the first part of the command (the agent) but can append or wrap
-                // For simplicity, we assume the agent can read the JSON file we generate
-            }
-
-            const getTrackedChanges = async () => {
-                try {
-                    const { stdout } = await execa('git', ['status', '--porcelain'], { cwd });
-                    return stdout.split('\n')
-                        .filter(l => l.trim())
-                        .filter(line => /M|A|D|R/.test(line.slice(0, 2)))
-                        .map(l => l.slice(3).trim());
-                } catch (e) {
-                    return [];
-                }
-            };
-
-            // Snapshot changed files before agent runs
-            const beforeFiles = await getTrackedChanges();
-
-            // 2. Run the agent command
-            if (currentArgs.length > 0) {
-                console.log(chalk.cyan(`\n🚀 DEPLOYING AGENT:`));
-                console.log(chalk.dim(`   Command: ${currentArgs.join(' ')}`));
-                try {
-                    await execa(currentArgs[0], currentArgs.slice(1), { shell: true, stdio: 'inherit', cwd });
-                } catch (error: any) {
-                    console.warn(chalk.yellow(`\n⚠️  Agent command finished with non-zero exit code. Rigour will now verify state...`));
-                }
-            }
-
-            // Snapshot changed files after agent runs
-            const afterFiles = await getTrackedChanges();
-
-            const changedThisCycle = afterFiles.filter(f => !beforeFiles.includes(f));
-            const maxFiles = config.gates.safety?.max_files_changed_per_cycle || 10;
-
-            if (changedThisCycle.length > maxFiles) {
-                console.log(chalk.red.bold(`\n🛑 SAFETY RAIL ABORT: Agent changed ${changedThisCycle.length} files (max: ${maxFiles}).`));
-                console.log(chalk.red(`   This looks like explosive behavior. Check your agent's instructions.`));
-                process.exit(EXIT_FAIL);
-            }
-
-            // 3. Run Rigour Check
-            console.log(chalk.magenta('\n🔍 AUDITING QUALITY GATES...'));
-            const report = await runner.run(cwd);
-
-            // Write report
-            const reportPath = path.join(cwd, config.output.report_path);
-            await fs.writeJson(reportPath, report, { spaces: 2 });
-
-            if (report.status === 'PASS') {
-                console.log(chalk.green.bold('\n✨ PASS - All quality gates satisfied.'));
-                console.log(chalk.green(`   Your solution meets the required Engineering Rigour criteria.\n`));
-                return;
-            }
-
-            // 4. Generate Fix Packet v2
-            const { FixPacketService } = await import('@rigour-labs/core');
-            const fixPacketService = new FixPacketService();
-            const fixPacket = fixPacketService.generate(report, config);
-            const fixPacketPath = path.join(cwd, 'rigour-fix-packet.json');
-            await fs.writeJson(fixPacketPath, fixPacket, { spaces: 2 });
-
-            console.log(chalk.red.bold(`\n🛑 FAIL - Found ${report.failures.length} engineering violations.`));
-            console.log(chalk.dim(`   Fix Packet generated: rigour-fix-packet.json`));
-
-            if (options.failFast) {
-                console.log(chalk.red.bold(`\n🛑 FAIL-FAST: Aborting loop as requested.`));
-                process.exit(EXIT_FAIL);
-            }
-
-            // Print summary
-            const summary = report.failures.map((f, i) => {
-                return chalk.white(`${i + 1}. `) + chalk.bold.red(`[${f.id.toUpperCase()}] `) + chalk.white(f.title);
-            }).join('\n');
-            console.log(chalk.bold.white('\n📋 VIOLATIONS SUMMARY:'));
-            console.log(summary);
-
-            if (iteration === maxIterations) {
-                console.log(chalk.red.bold(`\n❌ CRITICAL: Reached maximum iterations (${maxIterations}).`));
-                console.log(chalk.red(`   Quality gates remain unfulfilled. Refactor manually or check agent logs.`));
-                process.exit(EXIT_FAIL);
-            }
-
-            console.log(chalk.dim('\nReturning control to agent for the next refinement cycle...'));
-        }
-    } catch (error: any) {
-        console.error(chalk.red(`\n❌ FATAL ERROR: ${error.message}`));
-        if (error.issues) {
-            console.error(chalk.dim(JSON.stringify(error.issues, null, 2)));
-        }
-        process.exit(EXIT_INTERNAL_ERROR);
-    }
-}

package/src/commands/setup.ts

@@ -1,28 +0,0 @@
-import chalk from 'chalk';
-
-export async function setupCommand() {
-    console.log(chalk.bold.cyan('\n🛠️ Rigour Labs | Setup & Installation\n'));
-
-    console.log(chalk.bold('1. Global Installation (Recommended)'));
-    console.log(chalk.dim('   To use Rigour anywhere in your terminal:'));
-    console.log(chalk.green('   $ npm install -g @rigour-labs/cli\n'));
-
-    console.log(chalk.bold('2. Project-Local installation'));
-    console.log(chalk.dim('   To keep Rigour versioned with your project:'));
-    console.log(chalk.green('   $ npm install --save-dev @rigour-labs/cli\n'));
-
-    console.log(chalk.bold('3. Standalone Binaries (Zero-Install)'));
-    console.log(chalk.dim('   If you do not want to use Node.js:'));
-    console.log(chalk.dim('   • macOS: ') + chalk.cyan('https://github.com/erashu212/rigour/releases/latest/download/rigour-macos'));
-    console.log(chalk.dim('   • Linux: ') + chalk.cyan('https://github.com/erashu212/rigour/releases/latest/download/rigour-linux'));
-    console.log(chalk.dim('   • Windows: ') + chalk.cyan('https://github.com/erashu212/rigour/releases/latest/download/rigour-windows.exe\n'));
-
-    console.log(chalk.bold('4. MCP Integration (for AI Agents)'));
-    console.log(chalk.dim('   To let Cursor or Claude use Rigour natively:'));
-    console.log(chalk.dim('   Path to MCP: ') + chalk.cyan('packages/rigour-mcp/dist/index.js'));
-    console.log(chalk.dim('   Add this to your Cursor/Claude settings.\n'));
-
-    console.log(chalk.bold('Update Guidance:'));
-    console.log(chalk.dim('   Keep Rigour sharp by updating regularly:'));
-    console.log(chalk.green('   $ npm install -g @rigour-labs/cli@latest\n'));
-}

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: Engineering Excellence 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);
-    });
-});