@rigour-labs/cli 2.22.0 → 3.0.1

package/README.md

@@ -35,6 +35,7 @@ Agent writes code → Rigour checks → FAIL? → Fix Packet → Agent retries
 
 ## ⚙️ Quality Gates
 
+### Structural & Security Gates
 | Gate | Description |
 |:---|:---|
 | **File Size** | Max lines per file (default: 300-500) |
@@ -42,9 +43,21 @@ Agent writes code → Rigour checks → FAIL? → Fix Packet → Agent retries
 | **Complexity** | Cyclomatic complexity limits (AST-based) |
 | **Required Docs** | SPEC.md, ARCH.md, README must exist |
 | **File Guard** | Protected paths, max files changed |
-| **Security Patterns** | XSS, SQL injection, hardcoded secrets, command injection (enabled by default) |
+| **Security Patterns** | XSS, SQL injection, hardcoded secrets, command injection |
 | **Context Alignment** | Prevents drift by anchoring on project patterns |
 
+### AI-Native Drift Detection (v2.16+)
+| Gate | Description |
+|:---|:---|
+| **Duplication Drift** | Near-identical functions across files — AI re-invents what it forgot |
+| **Hallucinated Imports** | Imports referencing modules that don't exist (JS/TS, Python, Go, Ruby, C#) |
+| **Inconsistent Error Handling** | Same error type handled differently across agent sessions |
+| **Context Window Artifacts** | Quality degradation within a file — clean top, messy bottom |
+| **Async & Error Safety** | Unsafe async/promise patterns, unhandled errors across 6 languages |
+
+### Multi-Language Support
+All gates support **TypeScript, JavaScript, Python, Go, Ruby, and C#/.NET**.
+
 ## 🛠️ Commands
 
 | Command | Purpose |

package/dist/cli.js

@@ -8,6 +8,9 @@ import { guideCommand } from './commands/guide.js';
 import { setupCommand } from './commands/setup.js';
 import { indexCommand } from './commands/index.js';
 import { studioCommand } from './commands/studio.js';
+import { exportAuditCommand } from './commands/export-audit.js';
+import { demoCommand } from './commands/demo.js';
+import { hooksInitCommand } from './commands/hooks.js';
 import { checkForUpdates } from './utils/version.js';
 import chalk from 'chalk';
 const CLI_VERSION = '2.0.0';
@@ -29,7 +32,7 @@ program
 program
     .command('init')
     .description('Initialize Rigour in the current directory')
-    .option('-p, --preset <name>', 'Project preset (ui, api, infra, data)')
+    .option('-p, --preset <name>', 'Project preset (ui, api, infra, data, healthcare, fintech, government)')
     .option('--paradigm <name>', 'Coding paradigm (oop, functional, minimal)')
     .option('--ide <name>', 'Target IDE (cursor, vscode, all). Auto-detects if not specified.')
     .option('--dry-run', 'Show detected configuration without writing files')
@@ -37,10 +40,12 @@ program
     .option('-f, --force', 'Force re-initialization, overwriting existing rigour.yml')
     .addHelpText('after', `
 Examples:
-  $ rigour init                        # Auto-discover role & paradigm
-  $ rigour init --preset api --explain # Force API role and show why
-  $ rigour init --ide vscode           # Only create VS Code compatible files
-  $ rigour init --ide all              # Create files for all IDEs
+  $ rigour init                            # Auto-discover role & paradigm
+  $ rigour init --preset api --explain     # Force API role and show why
+  $ rigour init --preset healthcare        # HIPAA-compliant quality gates
+  $ rigour init --preset fintech           # SOC2/PCI-DSS quality gates
+  $ rigour init --preset government        # FedRAMP/NIST quality gates
+  $ rigour init --ide all                  # Create files for all IDEs
     `)
     .action(async (options) => {
     await initCommand(process.cwd(), options);
@@ -91,6 +96,43 @@ Examples:
         failFast: !!options.failFast
     });
 });
+program
+    .command('export-audit')
+    .description('Generate a compliance audit package from the last check')
+    .option('-f, --format <type>', 'Output format: json or md', 'json')
+    .option('-o, --output <path>', 'Custom output file path')
+    .option('--run', 'Run a fresh rigour check before exporting')
+    .addHelpText('after', `
+Examples:
+  $ rigour export-audit                      # Export JSON audit package
+  $ rigour export-audit --format md          # Export Markdown report
+  $ rigour export-audit --run                # Run check first, then export
+  $ rigour export-audit -o audit.json        # Custom output path
+    `)
+    .action(async (options) => {
+    await exportAuditCommand(process.cwd(), options);
+});
+program
+    .command('demo')
+    .description('Run a live demo — see Rigour catch AI drift, security issues, and structural violations')
+    .option('--cinematic', 'Screen-recording mode: typewriter effects, simulated AI agent, before/after scores')
+    .option('--hooks', 'Focus on real-time hooks catching issues as AI writes code')
+    .option('--speed <speed>', 'Pacing: fast, normal, slow (default: normal)', 'normal')
+    .addHelpText('after', `
+Examples:
+  $ rigour demo                          # Run the flagship demo
+  $ rigour demo --cinematic              # Screen-recording optimized (great for GIFs)
+  $ rigour demo --cinematic --speed slow # Slower pacing for presentations
+  $ rigour demo --hooks                  # Focus on hooks catching issues
+  $ npx @rigour-labs/cli demo            # Try without installing
+    `)
+    .action(async (options) => {
+    await demoCommand({
+        cinematic: !!options.cinematic,
+        hooks: !!options.hooks,
+        speed: options.speed || 'normal',
+    });
+});
 program
     .command('guide')
     .description('Show the interactive engineering guide')
@@ -103,6 +145,27 @@ program
     .action(async () => {
     await setupCommand();
 });
+const hooksCmd = program
+    .command('hooks')
+    .description('Manage AI coding tool hook integrations');
+hooksCmd
+    .command('init')
+    .description('Generate hook configs for AI coding tools (Claude, Cursor, Cline, Windsurf)')
+    .option('-t, --tool <name>', 'Target tool(s): claude, cursor, cline, windsurf, all. Auto-detects if not specified.')
+    .option('--dry-run', 'Show what files would be created without writing them')
+    .option('-f, --force', 'Overwrite existing hook files')
+    .option('--block', 'Configure hooks to block on failure (exit code 2)')
+    .addHelpText('after', `
+Examples:
+  $ rigour hooks init                    # Auto-detect tools, generate hooks
+  $ rigour hooks init --tool claude      # Generate Claude Code hooks only
+  $ rigour hooks init --tool all         # Generate hooks for all tools
+  $ rigour hooks init --dry-run          # Preview without writing files
+  $ rigour hooks init --tool cursor -f   # Force overwrite Cursor hooks
+    `)
+    .action(async (options) => {
+    await hooksInitCommand(process.cwd(), options);
+});
 // Check for updates before parsing (non-blocking)
 (async () => {
     try {

package/dist/commands/check.js

@@ -2,7 +2,7 @@ import fs from 'fs-extra';
 import path from 'path';
 import chalk from 'chalk';
 import yaml from 'yaml';
-import { GateRunner, ConfigSchema } from '@rigour-labs/core';
+import { GateRunner, ConfigSchema, recordScore, getScoreTrend } from '@rigour-labs/core';
 import inquirer from 'inquirer';
 import { randomUUID } from 'crypto';
 // Exit codes per spec
@@ -57,6 +57,8 @@ export async function checkCommand(cwd, files = [], options = {}) {
         // Write machine report
         const reportPath = path.join(cwd, config.output.report_path);
         await fs.writeJson(reportPath, report, { spaces: 2 });
+        // Record score for trend tracking
+        recordScore(cwd, report);
         await logStudioEvent(cwd, {
             type: "tool_response",
             requestId,
@@ -81,15 +83,18 @@ export async function checkCommand(cwd, files = [], options = {}) {
             });
             return; // Wait for write callback
         }
-        // CI mode: minimal output
+        // CI mode: minimal output with score
         if (options.ci) {
             if (report.status === 'PASS') {
-                console.log('PASS');
+                const scoreStr = report.stats.score !== undefined ? ` (${report.stats.score}/100)` : '';
+                console.log(`PASS${scoreStr}`);
             }
             else {
-                console.log(`FAIL: ${report.failures.length} violation(s)`);
+                const scoreStr = report.stats.score !== undefined ? ` Score: ${report.stats.score}/100` : '';
+                console.log(`FAIL: ${report.failures.length} violation(s)${scoreStr}`);
                 report.failures.forEach((f) => {
-                    console.log(`  - [${f.id}] ${f.title}`);
+                    const sev = (f.severity || 'medium').toUpperCase();
+                    console.log(`  - [${sev}] [${f.id}] ${f.title}`);
                 });
             }
             process.exit(report.status === 'PASS' ? EXIT_PASS : EXIT_FAIL);
@@ -104,21 +109,73 @@ export async function checkCommand(cwd, files = [], options = {}) {
         }
         else {
             console.log(chalk.red.bold('✘ FAIL - Quality gate violations found.\n'));
+            // Score summary line
+            const stats = report.stats;
+            const scoreParts = [];
+            if (stats.score !== undefined)
+                scoreParts.push(`Score: ${stats.score}/100`);
+            if (stats.ai_health_score !== undefined)
+                scoreParts.push(`AI Health: ${stats.ai_health_score}/100`);
+            if (stats.structural_score !== undefined)
+                scoreParts.push(`Structural: ${stats.structural_score}/100`);
+            if (scoreParts.length > 0) {
+                console.log(chalk.bold(scoreParts.join(' | ')) + '\n');
+            }
+            // Severity breakdown
+            if (stats.severity_breakdown) {
+                const parts = Object.entries(stats.severity_breakdown)
+                    .filter(([, count]) => count > 0)
+                    .map(([sev, count]) => {
+                    const color = sev === 'critical' ? chalk.red.bold : sev === 'high' ? chalk.red : sev === 'medium' ? chalk.yellow : chalk.dim;
+                    return color(`${sev}: ${count}`);
+                });
+                if (parts.length > 0) {
+                    console.log('Severity: ' + parts.join(', ') + '\n');
+                }
+            }
+            // Group failures by provenance
+            const severityIcon = (s) => {
+                switch (s) {
+                    case 'critical': return chalk.red.bold('CRIT');
+                    case 'high': return chalk.red('HIGH');
+                    case 'medium': return chalk.yellow('MED ');
+                    case 'low': return chalk.dim('LOW ');
+                    case 'info': return chalk.dim('INFO');
+                    default: return chalk.yellow('MED ');
+                }
+            };
             for (const failure of report.failures) {
-                console.log(chalk.red(`[${failure.id}] ${failure.title}`));
-                console.log(chalk.dim(`  Details: ${failure.details}`));
+                const sev = severityIcon(failure.severity);
+                const prov = failure.provenance ? chalk.dim(`[${failure.provenance}]`) : '';
+                console.log(`${sev} ${prov} ${chalk.red(`[${failure.id}]`)} ${failure.title}`);
+                console.log(chalk.dim(`      Details: ${failure.details}`));
                 if (failure.files && failure.files.length > 0) {
-                    console.log(chalk.dim('  Files:'));
-                    failure.files.forEach((f) => console.log(chalk.dim(`    - ${f}`)));
+                    console.log(chalk.dim('      Files:'));
+                    failure.files.forEach((f) => console.log(chalk.dim(`        - ${f}`)));
                 }
                 if (failure.hint) {
-                    console.log(chalk.cyan(`  Hint: ${failure.hint}`));
+                    console.log(chalk.cyan(`      Hint: ${failure.hint}`));
                 }
                 console.log('');
             }
             console.log(chalk.yellow(`See ${config.output.report_path} for full details.`));
         }
-        console.log(chalk.dim(`\nFinished in ${report.stats.duration_ms}ms`));
+        // Score trend display
+        const trend = getScoreTrend(cwd);
+        if (trend && trend.recentScores.length >= 3) {
+            const arrow = trend.direction === 'improving' ? chalk.green('↑') :
+                trend.direction === 'degrading' ? chalk.red('↓') : chalk.dim('→');
+            const trendColor = trend.direction === 'improving' ? chalk.green :
+                trend.direction === 'degrading' ? chalk.red : chalk.dim;
+            const scoresStr = trend.recentScores.map(s => String(s)).join(' → ');
+            console.log(trendColor(`\nScore Trend: ${scoresStr} (${trend.direction} ${arrow})`));
+        }
+        // Stats footer
+        const footerParts = [`Finished in ${report.stats.duration_ms}ms`];
+        if (report.status === 'PASS' && report.stats.score !== undefined) {
+            footerParts.push(`Score: ${report.stats.score}/100`);
+        }
+        console.log(chalk.dim('\n' + footerParts.join(' | ')));
         process.exit(report.status === 'PASS' ? EXIT_PASS : EXIT_FAIL);
     }
     catch (error) {

package/dist/commands/demo.d.ts

@@ -0,0 +1,23 @@
+/**
+ * rigour demo
+ *
+ * Creates a temp project with intentional AI-generated code issues,
+ * runs Rigour against it, and shows the full experience.
+ *
+ * Modes:
+ *   Default:    Fast demo — scaffold → check → results
+ *   --cinematic: Screen-recording optimized — typewriter effects, pauses,
+ *                simulated AI agent writing code, hooks catching issues
+ *   --hooks:     Focus on the real-time hooks experience
+ *   --speed:     Control pacing (fast / normal / slow)
+ *
+ * The "flagship demo" — one command to understand Rigour.
+ *
+ * @since v2.17.0 (extended v3.0.0)
+ */
+export interface DemoOptions {
+    cinematic?: boolean;
+    hooks?: boolean;
+    speed?: 'fast' | 'normal' | 'slow';
+}
+export declare function demoCommand(options?: DemoOptions): Promise<void>;