@rigour-labs/cli 4.0.5 → 4.1.1

package/README.md

@@ -7,15 +7,15 @@
 **Local-first quality gates for AI-generated code.**  
 Rigour forces AI agents to meet strict engineering standards before marking tasks "Done".
 
-> **Zero cloud. Zero telemetry. PASS/FAIL is always free.**
+> Core gates run locally. Deep analysis can run local or cloud provider mode.
 
 ## 🚀 Quick Start
 
 ```bash
-npx rigour scan     # Zero-config scan (auto-detect stack)
-npx rigour init     # Initialize quality gates
-npx rigour check    # Verify code quality
-npx rigour run -- claude "Build feature X"  # Agent loop
+npx @rigour-labs/cli scan     # Zero-config scan (auto-detect stack)
+npx @rigour-labs/cli init     # Initialize quality gates
+npx @rigour-labs/cli check    # Verify code quality
+npx @rigour-labs/cli run -- claude "Build feature X"  # Agent loop
 ```
 
 ## 🍺 Homebrew
@@ -74,6 +74,8 @@ All gates support **TypeScript, JavaScript, Python, Go, Ruby, and C#/.NET**.
 | `rigour init` | Setup Rigour in your project |
 | `rigour check` | Validate code against quality gates |
 | `rigour check --ci` | CI mode with appropriate output |
+| `rigour hooks init` | Install real-time hooks for supported tools |
+| `rigour hooks check --files ...` | Run fast hook gates on specific files |
 | `rigour explain` | Detailed explanation of validation results |
 | `rigour run` | Supervisor loop for iterative refinement |
 | `rigour studio` | Dashboard for monitoring |
@@ -98,7 +100,7 @@ All gates support **TypeScript, JavaScript, Python, Go, Ruby, and C#/.NET**.
 ## 🧪 CI Integration
 
 ```yaml
-- run: npx rigour check --ci
+- run: npx @rigour-labs/cli check --ci
 ```
 
 ## 📜 License

package/dist/cli.js

@@ -11,8 +11,9 @@ import { indexCommand } from './commands/index.js';
 import { studioCommand } from './commands/studio.js';
 import { exportAuditCommand } from './commands/export-audit.js';
 import { demoCommand } from './commands/demo.js';
-import { hooksInitCommand } from './commands/hooks.js';
+import { hooksInitCommand, hooksCheckCommand } from './commands/hooks.js';
 import { settingsShowCommand, settingsSetKeyCommand, settingsRemoveKeyCommand, settingsSetCommand, settingsGetCommand, settingsResetCommand, settingsPathCommand } from './commands/settings.js';
+import { doctorCommand } from './commands/doctor.js';
 import { checkForUpdates } from './utils/version.js';
 import { getCliVersion } from './utils/cli-version.js';
 import chalk from 'chalk';
@@ -176,6 +177,12 @@ program
     .action(async () => {
     await setupCommand();
 });
+program
+    .command('doctor')
+    .description('Diagnose install conflicts and deep-mode readiness')
+    .action(async () => {
+    await doctorCommand();
+});
 const hooksCmd = program
     .command('hooks')
     .description('Manage AI coding tool hook integrations');
@@ -197,6 +204,22 @@ Examples:
     .action(async (options) => {
     await hooksInitCommand(process.cwd(), options);
 });
+hooksCmd
+    .command('check')
+    .description('Run fast hook checks for one or more files')
+    .option('--files <paths>', 'Comma-separated file paths')
+    .option('--stdin', 'Read hook payload from stdin (Cursor/Windsurf/Cline format)')
+    .option('--block', 'Exit code 2 on failures (for blocking hooks)')
+    .option('--timeout <ms>', 'Timeout in milliseconds (default: 5000)')
+    .addHelpText('after', `
+Examples:
+  $ rigour hooks check --files src/app.ts
+  $ rigour hooks check --files src/a.ts,src/b.ts --block
+  $ echo '{"file_path":"src/app.ts"}' | rigour hooks check --stdin
+    `)
+    .action(async (options) => {
+    await hooksCheckCommand(process.cwd(), options);
+});
 // Settings management (like Claude Code's settings.json)
 const settingsCmd = program
     .command('settings')

package/dist/commands/check.js

@@ -91,6 +91,18 @@ export async function checkCommand(cwd, files = [], options = {}) {
                 isLocal: !hasApiKey || deepOpts.provider === 'local',
                 provider: deepOpts.provider || 'cloud',
             };
+            if (!isSilent) {
+                if (!resolvedDeepMode.isLocal && !options.provider && !options.apiKey) {
+                    console.log(chalk.yellow(`Deep execution defaulted to cloud (${resolvedDeepMode.provider}) from settings.`));
+                    console.log(chalk.dim('Use `--provider local` to force local sidecar execution.\n'));
+                }
+                else if (options.provider === 'local' && hasApiKey) {
+                    console.log(chalk.green('Deep execution forced to local (`--provider local`) even though an API key is configured.\n'));
+                }
+                else if (options.provider && options.provider !== 'local' && !hasApiKey) {
+                    console.log(chalk.yellow(`Provider "${options.provider}" requested, but no API key was resolved. Falling back to local execution.\n`));
+                }
+            }
         }
         const report = await runner.run(cwd, files.length > 0 ? files : undefined, deepOpts);
         // Write machine report
@@ -228,7 +240,7 @@ export async function checkCommand(cwd, files = [], options = {}) {
  */
 function renderDeepOutput(report, config, options, resolvedDeepMode) {
     const stats = report.stats;
-    const isLocal = stats.deep?.tier ? stats.deep.tier !== 'cloud' : (resolvedDeepMode?.isLocal ?? !options.apiKey);
+    const isLocal = resolvedDeepMode?.isLocal ?? (stats.deep?.tier ? stats.deep.tier !== 'cloud' : !options.apiKey);
     const provider = resolvedDeepMode?.provider || options.provider || 'cloud';
     console.log('');
     if (report.status === 'PASS') {
@@ -245,10 +257,10 @@ function renderDeepOutput(report, config, options, resolvedDeepMode) {
     console.log('');
     // Privacy badge — this IS the marketing
     if (isLocal) {
-        console.log(chalk.green('  🔒 100% local. Your code never left this machine.'));
+        console.log(chalk.green('  🔒 Local sidecar/model execution. Code remains on this machine.'));
     }
     else {
-        console.log(chalk.yellow(`  ☁️  Code was sent to ${provider} API.`));
+        console.log(chalk.yellow(`  ☁️  Cloud provider execution. Code context may be sent to ${provider} API.`));
     }
     // Deep stats
     if (stats.deep) {

package/dist/commands/demo-scenarios.js

@@ -285,16 +285,16 @@ export function loadData(raw: unknown) {
     return parsed;
 }
 `.trim());
-    // Issue 4: TODO markers
+    // Issue 4: Placeholder markers
     await fs.writeFile(path.join(dir, 'src', 'utils.ts'), `
-// TODO: Claude suggested this but I need to review
-// FIXME: This function has edge cases
+// NOTE: Claude suggested this but I need to review
+// NOTE: This function has edge cases
 export function formatDate(date: Date): string {
     return date.toISOString().split('T')[0];
 }
 
 export function sanitizeInput(input: string): string {
-    // TODO: Add proper sanitization
+    // NOTE: Add proper sanitization
     return input.trim();
 }
 `.trim());

package/dist/commands/doctor.d.ts

@@ -0,0 +1,3 @@
+export declare function detectInstallKind(binaryPath: string): string;
+export declare function hasVersionShadowing(versions: string[]): boolean;
+export declare function doctorCommand(): Promise<void>;

package/dist/commands/doctor.js

@@ -0,0 +1,127 @@
+import chalk from 'chalk';
+import os from 'os';
+import path from 'path';
+import fs from 'fs';
+import { execFileSync } from 'child_process';
+import { loadSettings, resolveDeepOptions, isModelCached, createProvider } from '@rigour-labs/core';
+function runText(command, args) {
+    try {
+        return execFileSync(command, args, { encoding: 'utf-8', stdio: ['ignore', 'pipe', 'ignore'] }).trim();
+    }
+    catch {
+        return '';
+    }
+}
+function listRigourPaths() {
+    if (process.platform === 'win32') {
+        const output = runText('where', ['rigour']);
+        return output.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+    }
+    const output = runText('which', ['-a', 'rigour']);
+    return output.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+}
+function getRigourVersionFromPath(binaryPath) {
+    try {
+        const output = execFileSync(binaryPath, ['--version'], { encoding: 'utf-8', stdio: ['ignore', 'pipe', 'ignore'] }).trim();
+        return output.split(/\r?\n/)[0]?.trim() || 'unknown';
+    }
+    catch {
+        return 'unknown';
+    }
+}
+export function detectInstallKind(binaryPath) {
+    const normalizedInput = binaryPath.replace(/\\/g, '/');
+    let resolved = binaryPath;
+    try {
+        resolved = fs.realpathSync(binaryPath);
+    }
+    catch {
+        // Keep original path
+    }
+    const normalizedResolved = resolved.replace(/\\/g, '/');
+    const homebrewSignals = [
+        '/Cellar/rigour/',
+        '/opt/rigour/',
+        '/opt/homebrew/bin/rigour',
+        '/usr/local/bin/rigour',
+    ];
+    if (homebrewSignals.some((signal) => normalizedInput.includes(signal) || normalizedResolved.includes(signal))) {
+        return 'homebrew';
+    }
+    if (normalizedInput.includes('@rigour-labs') || normalizedInput.includes('node_modules') ||
+        normalizedResolved.includes('@rigour-labs') || normalizedResolved.includes('node_modules')) {
+        return 'npm';
+    }
+    return 'unknown';
+}
+export function hasVersionShadowing(versions) {
+    const normalized = versions.map((v) => v.trim()).filter((v) => v.length > 0);
+    return new Set(normalized).size > 1;
+}
+export async function doctorCommand() {
+    console.log(chalk.bold.cyan('\nRigour Doctor\n'));
+    const paths = Array.from(new Set(listRigourPaths()));
+    if (paths.length === 0) {
+        console.log(chalk.red('✘ rigour not found in PATH'));
+        console.log(chalk.dim('  Install with: npm i -g @rigour-labs/cli OR brew install rigour-labs/tap/rigour\n'));
+        return;
+    }
+    console.log(chalk.bold('CLI Path Check'));
+    const entries = paths.map((p) => ({
+        path: p,
+        version: getRigourVersionFromPath(p),
+        kind: detectInstallKind(p),
+    }));
+    entries.forEach((entry, index) => {
+        const active = index === 0 ? chalk.green(' (active)') : '';
+        console.log(`  - ${entry.path} ${chalk.dim(`[${entry.kind}] v${entry.version}`)}${active}`);
+    });
+    const distinctVersions = Array.from(new Set(entries.map((entry) => entry.version)));
+    if (entries.length > 1 && hasVersionShadowing(distinctVersions)) {
+        console.log(chalk.yellow('\n⚠ Multiple rigour binaries with different versions detected.'));
+        console.log(chalk.dim('  This can shadow upgrades and cause "still old version" confusion.'));
+        if (process.platform === 'win32') {
+            console.log(chalk.dim('  Run: where rigour'));
+        }
+        else {
+            console.log(chalk.dim('  Run: which -a rigour'));
+        }
+        console.log(chalk.dim('  Keep one install channel active (brew or npm global), then relink PATH order.\n'));
+    }
+    else {
+        console.log(chalk.green('  ✓ PATH order/version state looks consistent.\n'));
+    }
+    console.log(chalk.bold('Deep Mode Readiness'));
+    const settings = loadSettings();
+    const resolved = resolveDeepOptions({});
+    const defaultProvider = resolved.provider || settings.deep?.defaultProvider || 'anthropic';
+    const defaultIsCloud = !!resolved.apiKey && defaultProvider !== 'local';
+    const hasAnyApiKey = !!(settings.providers && Object.keys(settings.providers).some((k) => !!settings.providers?.[k]));
+    console.log(`  - API keys configured: ${hasAnyApiKey ? chalk.green('yes') : chalk.yellow('no')}`);
+    console.log(`  - Deep default provider: ${chalk.cyan(defaultProvider)}`);
+    if (defaultIsCloud) {
+        console.log(chalk.yellow(`  ⚠ Deep defaults to cloud (${defaultProvider}) when you run \`rigour check --deep\`.`));
+        console.log(chalk.dim('    Force local any time with: rigour check --deep --provider local'));
+    }
+    else {
+        console.log(chalk.green('  ✓ Deep defaults to local execution.'));
+    }
+    const provider = createProvider({ enabled: true, provider: 'local' });
+    const sidecarAvailable = await provider.isAvailable();
+    provider.dispose();
+    const deepModelCached = await isModelCached('deep');
+    const proModelCached = await isModelCached('pro');
+    console.log(`  - Local inference binary: ${sidecarAvailable ? chalk.green('ready') : chalk.yellow('missing')}`);
+    console.log(`  - Local deep model cache: ${deepModelCached ? chalk.green('ready') : chalk.yellow('not cached')}`);
+    console.log(`  - Local pro model cache: ${proModelCached ? chalk.green('ready') : chalk.dim('not cached')}`);
+    if (!sidecarAvailable || !deepModelCached) {
+        console.log(chalk.dim('\n  Local bootstrap command: rigour check --deep --provider local'));
+    }
+    const rigourHome = path.join(os.homedir(), '.rigour');
+    console.log(chalk.dim(`  Rigour home: ${rigourHome}\n`));
+    console.log(chalk.bold('Recommended Baseline'));
+    console.log(chalk.dim('  1) rigour doctor'));
+    console.log(chalk.dim('  2) rigour check --deep --provider local'));
+    console.log(chalk.dim('  3) rigour check --deep -k <KEY> --provider <name>'));
+    console.log('');
+}

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

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

package/dist/commands/doctor.test.js

@@ -0,0 +1,20 @@
+import { describe, expect, it } from 'vitest';
+import { detectInstallKind, hasVersionShadowing } from './doctor.js';
+describe('doctor helpers', () => {
+    it('classifies Homebrew paths', () => {
+        expect(detectInstallKind('/opt/homebrew/bin/rigour')).toBe('homebrew');
+        expect(detectInstallKind('/usr/local/bin/rigour')).toBe('homebrew');
+        expect(detectInstallKind('/opt/homebrew/Cellar/rigour/4.0.5/bin/rigour')).toBe('homebrew');
+    });
+    it('classifies npm/global node_modules paths', () => {
+        expect(detectInstallKind('/opt/homebrew/lib/node_modules/@rigour-labs/cli/dist/cli.js')).toBe('npm');
+        expect(detectInstallKind('/Users/test/.nvm/versions/node/v22.0.0/lib/node_modules/@rigour-labs/cli/dist/cli.js')).toBe('npm');
+    });
+    it('returns unknown for unrelated paths', () => {
+        expect(detectInstallKind('/usr/bin/rigour')).toBe('unknown');
+    });
+    it('detects version shadowing only when versions differ', () => {
+        expect(hasVersionShadowing(['4.0.5', '4.0.5'])).toBe(false);
+        expect(hasVersionShadowing(['4.0.5', '2.0.0'])).toBe(true);
+    });
+});

package/dist/commands/guide.d.ts

@@ -1 +1 @@
-export declare function guideCommand(): Promise<void>;
+export declare function guideCommand(): void;

package/dist/commands/guide.js

@@ -1,5 +1,5 @@
 import chalk from 'chalk';
-export async function guideCommand() {
+export function guideCommand() {
     console.log(chalk.bold.cyan('\n🛡️ Rigour Labs | The Engineering Guide\n'));
     console.log(chalk.bold('Getting Started:'));
     console.log(chalk.dim('  1. Run ') + chalk.cyan('rigour init') + chalk.dim(' to detect your project role and apply standards.'));

package/dist/commands/hooks.d.ts

@@ -19,4 +19,11 @@ export interface HooksOptions {
     force?: boolean;
     block?: boolean;
 }
+export interface HooksCheckOptions {
+    files?: string;
+    stdin?: boolean;
+    block?: boolean;
+    timeout?: string;
+}
 export declare function hooksInitCommand(cwd: string, options?: HooksOptions): Promise<void>;
+export declare function hooksCheckCommand(cwd: string, options?: HooksCheckOptions): Promise<void>;

package/dist/commands/hooks.js

@@ -17,6 +17,7 @@ import fs from 'fs-extra';
 import path from 'path';
 import chalk from 'chalk';
 import { randomUUID } from 'crypto';
+import { runHookChecker } from '@rigour-labs/core';
 // ── Studio event logging ─────────────────────────────────────────────
 async function logStudioEvent(cwd, event) {
     try {
@@ -53,12 +54,21 @@ function detectTools(cwd) {
     }
     return detected;
 }
-function resolveCheckerPath(cwd) {
+function resolveCheckerCommand(cwd) {
     const localPath = path.join(cwd, 'node_modules', '@rigour-labs', 'core', 'dist', 'hooks', 'standalone-checker.js');
     if (fs.existsSync(localPath)) {
-        return localPath;
+        return { command: 'node', args: [localPath] };
     }
-    return 'npx rigour-hook-check';
+    return { command: 'rigour', args: ['hooks', 'check'] };
+}
+function shellEscape(arg) {
+    if (/^[A-Za-z0-9_/@%+=:,.-]+$/.test(arg)) {
+        return arg;
+    }
+    return `'${arg.replace(/'/g, `'\\''`)}'`;
+}
+function checkerToShellCommand(spec) {
+    return [spec.command, ...spec.args].map(shellEscape).join(' ');
 }
 // ── Tool resolution (from --tool flag or auto-detect) ────────────────
 const ALL_TOOLS = ['claude', 'cursor', 'cline', 'windsurf'];
@@ -86,15 +96,16 @@ function resolveTools(cwd, toolFlag) {
     return detected;
 }
 // ── Per-tool hook generators ─────────────────────────────────────────
-function generateClaudeHooks(checkerPath, block) {
+function generateClaudeHooks(checker, block) {
     const blockFlag = block ? ' --block' : '';
+    const checkerCommand = checkerToShellCommand(checker);
     const settings = {
         hooks: {
             PostToolUse: [{
                     matcher: "Write|Edit|MultiEdit",
                     hooks: [{
                             type: "command",
-                            command: `node ${checkerPath} --files "$TOOL_INPUT_file_path"${blockFlag}`,
+                            command: `${checkerCommand} --files "$TOOL_INPUT_file_path"${blockFlag}`,
                         }]
                 }]
         }
@@ -105,10 +116,12 @@ function generateClaudeHooks(checkerPath, block) {
             description: 'Claude Code PostToolUse hook',
         }];
 }
-function generateCursorHooks(checkerPath, _block) {
+function generateCursorHooks(checker, block) {
+    const blockFlag = block ? ' --block' : '';
+    const checkerCommand = checkerToShellCommand(checker);
     const hooks = {
         version: 1,
-        hooks: { afterFileEdit: [{ command: `node ${checkerPath} --stdin` }] }
+        hooks: { afterFileEdit: [{ command: `${checkerCommand} --stdin${blockFlag}` }] }
     };
     return [{
             path: '.cursor/hooks.json',
@@ -116,8 +129,8 @@ function generateCursorHooks(checkerPath, _block) {
             description: 'Cursor afterFileEdit hook config',
         }];
 }
-function generateClineHooks(checkerPath, _block) {
-    const script = buildClineScript(checkerPath);
+function generateClineHooks(checker, block) {
+    const script = buildClineScript(checker, block);
     return [{
             path: '.clinerules/hooks/PostToolUse',
             content: script,
@@ -125,7 +138,8 @@ function generateClineHooks(checkerPath, _block) {
             description: 'Cline PostToolUse executable hook',
         }];
 }
-function buildClineScript(checkerPath) {
+function buildClineScript(checker, block) {
+    const blockArgLiteral = block ? `, '--block'` : '';
     return `#!/usr/bin/env node
 /**
  * Cline PostToolUse hook for Rigour.
@@ -148,11 +162,21 @@ process.stdin.on('end', async () => {
             return;
         }
 
-        const { execSync } = require('child_process');
-        const raw = execSync(
-            \`node ${checkerPath} --files "\${filePath}"\`,
+        const { spawnSync } = require('child_process');
+        const command = ${JSON.stringify(checker.command)};
+        const baseArgs = ${JSON.stringify(checker.args)};
+        const proc = spawnSync(
+            command,
+            [...baseArgs, '--files', filePath${blockArgLiteral}],
             { encoding: 'utf-8', timeout: 5000 }
         );
+        if (proc.error) {
+            throw proc.error;
+        }
+        const raw = (proc.stdout || '').trim();
+        if (!raw) {
+            throw new Error(proc.stderr || 'Rigour hook checker returned no output');
+        }
         const result = JSON.parse(raw);
         if (result.status === 'fail') {
             const msgs = result.failures
@@ -171,10 +195,12 @@ process.stdin.on('end', async () => {
 });
 `;
 }
-function generateWindsurfHooks(checkerPath, _block) {
+function generateWindsurfHooks(checker, block) {
+    const blockFlag = block ? ' --block' : '';
+    const checkerCommand = checkerToShellCommand(checker);
     const hooks = {
         version: 1,
-        hooks: { post_write_code: [{ command: `node ${checkerPath} --stdin` }] }
+        hooks: { post_write_code: [{ command: `${checkerCommand} --stdin${blockFlag}` }] }
     };
     return [{
             path: '.windsurf/hooks.json',
@@ -245,12 +271,12 @@ export async function hooksInitCommand(cwd, options = {}) {
         arguments: { tool: options.tool, dryRun: options.dryRun },
     });
     const tools = resolveTools(cwd, options.tool);
-    const checkerPath = resolveCheckerPath(cwd);
+    const checker = resolveCheckerCommand(cwd);
     const block = !!options.block;
     // Collect generated files from all tools
     const allFiles = [];
     for (const tool of tools) {
-        allFiles.push(...GENERATORS[tool](checkerPath, block));
+        allFiles.push(...GENERATORS[tool](checker, block));
     }
     if (options.dryRun) {
         printDryRun(allFiles);
@@ -272,3 +298,59 @@ export async function hooksInitCommand(cwd, options = {}) {
         content: [{ type: 'text', text: `Generated hooks for: ${tools.join(', ')}` }],
     });
 }
+async function readStdin() {
+    const chunks = [];
+    for await (const chunk of process.stdin) {
+        chunks.push(chunk);
+    }
+    return Buffer.concat(chunks).toString('utf-8').trim();
+}
+function parseStdinFiles(input) {
+    if (!input) {
+        return [];
+    }
+    try {
+        const payload = JSON.parse(input);
+        if (Array.isArray(payload.files)) {
+            return payload.files;
+        }
+        if (payload.file_path) {
+            return [payload.file_path];
+        }
+        if (payload.toolInput?.path) {
+            return [payload.toolInput.path];
+        }
+        if (payload.toolInput?.file_path) {
+            return [payload.toolInput.file_path];
+        }
+        return [];
+    }
+    catch {
+        return input.split('\n').map(l => l.trim()).filter(Boolean);
+    }
+}
+export async function hooksCheckCommand(cwd, options = {}) {
+    const timeout = options.timeout ? Number(options.timeout) : 5000;
+    const files = options.stdin
+        ? parseStdinFiles(await readStdin())
+        : (options.files ?? '').split(',').map(f => f.trim()).filter(Boolean);
+    if (files.length === 0) {
+        process.stdout.write(JSON.stringify({ status: 'pass', failures: [], duration_ms: 0 }));
+        return;
+    }
+    const result = await runHookChecker({
+        cwd,
+        files,
+        timeout_ms: Number.isFinite(timeout) ? timeout : 5000,
+    });
+    process.stdout.write(JSON.stringify(result));
+    if (result.status === 'fail') {
+        for (const failure of result.failures) {
+            const loc = failure.line ? `:${failure.line}` : '';
+            process.stderr.write(`[rigour/${failure.gate}] ${failure.file}${loc}: ${failure.message}\n`);
+        }
+        if (options.block) {
+            process.exitCode = 2;
+        }
+    }
+}

package/dist/commands/hooks.test.js

@@ -2,7 +2,7 @@
  * Tests for hooks init command.
  */
 import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { hooksInitCommand } from './hooks.js';
+import { hooksInitCommand, hooksCheckCommand } from './hooks.js';
 import * as fs from 'fs';
 import * as path from 'path';
 import * as os from 'os';
@@ -30,6 +30,7 @@ describe('hooksInitCommand', () => {
         const settings = JSON.parse(fs.readFileSync(settingsPath, 'utf-8'));
         expect(settings.hooks).toBeDefined();
         expect(settings.hooks.PostToolUse).toBeDefined();
+        expect(settings.hooks.PostToolUse[0].hooks[0].command).toContain('rigour hooks check');
     });
     it('should generate Cursor hooks', async () => {
         await hooksInitCommand(testDir, { tool: 'cursor' });
@@ -74,4 +75,48 @@ describe('hooksInitCommand', () => {
         const content = fs.readFileSync(path.join(claudeDir, 'settings.json'), 'utf-8');
         expect(content).toContain('PostToolUse');
     });
+    it('should propagate --block to generated hook commands', async () => {
+        await hooksInitCommand(testDir, { tool: 'all', force: true, block: true });
+        const claude = JSON.parse(fs.readFileSync(path.join(testDir, '.claude', 'settings.json'), 'utf-8'));
+        const cursor = JSON.parse(fs.readFileSync(path.join(testDir, '.cursor', 'hooks.json'), 'utf-8'));
+        const windsurf = JSON.parse(fs.readFileSync(path.join(testDir, '.windsurf', 'hooks.json'), 'utf-8'));
+        const clineScript = fs.readFileSync(path.join(testDir, '.clinerules', 'hooks', 'PostToolUse'), 'utf-8');
+        expect(claude.hooks.PostToolUse[0].hooks[0].command).toContain('--block');
+        expect(cursor.hooks.afterFileEdit[0].command).toContain('--block');
+        expect(windsurf.hooks.post_write_code[0].command).toContain('--block');
+        expect(clineScript).toContain('--block');
+    });
+});
+describe('hooksCheckCommand', () => {
+    let testDir;
+    beforeEach(() => {
+        testDir = fs.mkdtempSync(path.join(os.tmpdir(), 'hooks-check-test-'));
+        vi.spyOn(console, 'log').mockImplementation(() => { });
+        vi.spyOn(console, 'error').mockImplementation(() => { });
+    });
+    afterEach(() => {
+        fs.rmSync(testDir, { recursive: true, force: true });
+        vi.restoreAllMocks();
+    });
+    it('should return pass JSON when file is clean', async () => {
+        const filePath = path.join(testDir, 'ok.ts');
+        fs.writeFileSync(filePath, 'export const x = 1;\n');
+        const stdoutSpy = vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
+        await hooksCheckCommand(testDir, { files: 'ok.ts' });
+        const output = stdoutSpy.mock.calls.map(call => String(call[0])).join('');
+        expect(output).toContain('"status":"pass"');
+    });
+    it('should return fail JSON and set exit code 2 in block mode', async () => {
+        const filePath = path.join(testDir, 'bad.ts');
+        fs.writeFileSync(filePath, "const password = 'abcdefghijklmnopqrstuvwxyz12345';\n");
+        const stdoutSpy = vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
+        const stderrSpy = vi.spyOn(process.stderr, 'write').mockImplementation(() => true);
+        const originalExitCode = process.exitCode;
+        await hooksCheckCommand(testDir, { files: 'bad.ts', block: true });
+        const output = stdoutSpy.mock.calls.map(call => String(call[0])).join('');
+        expect(output).toContain('"status":"fail"');
+        expect(stderrSpy).toHaveBeenCalled();
+        expect(process.exitCode).toBe(2);
+        process.exitCode = originalExitCode;
+    });
 });

package/dist/commands/init.js

@@ -393,8 +393,8 @@ async function checkPrerequisites() {
         console.log(chalk.yellow('  ○ No API keys configured'));
     }
     // Check 2: Local model availability
-    const hasDeepModel = isModelCached('deep');
-    const hasProModel = isModelCached('pro');
+    const hasDeepModel = await isModelCached('deep');
+    const hasProModel = await isModelCached('pro');
     if (hasDeepModel || hasProModel) {
         const models = [];
         if (hasDeepModel)

package/dist/commands/settings.d.ts

@@ -4,10 +4,10 @@
  * Like Claude Code's settings.json or Gemini CLI's config.
  * Stores API keys, default provider, multi-agent config, CLI preferences.
  */
-export declare function settingsShowCommand(): Promise<void>;
-export declare function settingsSetKeyCommand(provider: string, apiKey: string): Promise<void>;
-export declare function settingsRemoveKeyCommand(provider: string): Promise<void>;
-export declare function settingsSetCommand(key: string, value: string): Promise<void>;
-export declare function settingsGetCommand(key: string): Promise<void>;
-export declare function settingsResetCommand(): Promise<void>;
-export declare function settingsPathCommand(): Promise<void>;
+export declare function settingsShowCommand(): void;
+export declare function settingsSetKeyCommand(provider: string, apiKey: string): void;
+export declare function settingsRemoveKeyCommand(provider: string): void;
+export declare function settingsSetCommand(key: string, value: string): void;
+export declare function settingsGetCommand(key: string): void;
+export declare function settingsResetCommand(): void;
+export declare function settingsPathCommand(): void;