@rigour-labs/cli 2.22.0 → 3.0.1

package/dist/commands/hooks.test.js

@@ -0,0 +1,77 @@
+/**
+ * Tests for hooks init command.
+ */
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { hooksInitCommand } from './hooks.js';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import yaml from 'yaml';
+describe('hooksInitCommand', () => {
+    let testDir;
+    beforeEach(() => {
+        testDir = fs.mkdtempSync(path.join(os.tmpdir(), 'hooks-test-'));
+        // Write minimal rigour.yml
+        fs.writeFileSync(path.join(testDir, 'rigour.yml'), yaml.stringify({
+            version: 1,
+            gates: { max_file_lines: 500 },
+        }));
+        vi.spyOn(console, 'log').mockImplementation(() => { });
+        vi.spyOn(console, 'error').mockImplementation(() => { });
+    });
+    afterEach(() => {
+        fs.rmSync(testDir, { recursive: true, force: true });
+        vi.restoreAllMocks();
+    });
+    it('should generate Claude hooks', async () => {
+        await hooksInitCommand(testDir, { tool: 'claude' });
+        const settingsPath = path.join(testDir, '.claude', 'settings.json');
+        expect(fs.existsSync(settingsPath)).toBe(true);
+        const settings = JSON.parse(fs.readFileSync(settingsPath, 'utf-8'));
+        expect(settings.hooks).toBeDefined();
+        expect(settings.hooks.PostToolUse).toBeDefined();
+    });
+    it('should generate Cursor hooks', async () => {
+        await hooksInitCommand(testDir, { tool: 'cursor' });
+        const hooksPath = path.join(testDir, '.cursor', 'hooks.json');
+        expect(fs.existsSync(hooksPath)).toBe(true);
+        const hooks = JSON.parse(fs.readFileSync(hooksPath, 'utf-8'));
+        expect(hooks.hooks).toBeDefined();
+    });
+    it('should generate Cline hooks', async () => {
+        await hooksInitCommand(testDir, { tool: 'cline' });
+        const hookPath = path.join(testDir, '.clinerules', 'hooks', 'PostToolUse');
+        expect(fs.existsSync(hookPath)).toBe(true);
+    });
+    it('should generate Windsurf hooks', async () => {
+        await hooksInitCommand(testDir, { tool: 'windsurf' });
+        const hooksPath = path.join(testDir, '.windsurf', 'hooks.json');
+        expect(fs.existsSync(hooksPath)).toBe(true);
+    });
+    it('should support dry-run mode', async () => {
+        await hooksInitCommand(testDir, { tool: 'claude', dryRun: true });
+        // Dry run should NOT create files
+        const settingsPath = path.join(testDir, '.claude', 'settings.json');
+        expect(fs.existsSync(settingsPath)).toBe(false);
+    });
+    it('should not overwrite without --force', async () => {
+        // Create existing file
+        const claudeDir = path.join(testDir, '.claude');
+        fs.mkdirSync(claudeDir, { recursive: true });
+        fs.writeFileSync(path.join(claudeDir, 'settings.json'), '{"existing": true}');
+        await hooksInitCommand(testDir, { tool: 'claude' });
+        // Should keep existing content
+        const content = fs.readFileSync(path.join(claudeDir, 'settings.json'), 'utf-8');
+        expect(content).toContain('existing');
+    });
+    it('should overwrite with --force', async () => {
+        // Create existing file
+        const claudeDir = path.join(testDir, '.claude');
+        fs.mkdirSync(claudeDir, { recursive: true });
+        fs.writeFileSync(path.join(claudeDir, 'settings.json'), '{"existing": true}');
+        await hooksInitCommand(testDir, { tool: 'claude', force: true });
+        // Should have new hooks content
+        const content = fs.readFileSync(path.join(claudeDir, 'settings.json'), 'utf-8');
+        expect(content).toContain('PostToolUse');
+    });
+});

package/dist/commands/init.js

@@ -4,6 +4,7 @@ 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';
+import { hooksInitCommand } from './hooks.js';
 import { randomUUID } from 'crypto';
 // Helper to log events for Rigour Studio
 async function logStudioEvent(cwd, event) {
@@ -322,7 +323,9 @@ ${ruleContent}`;
             console.log(chalk.green('✔ Initialized Windsurf Handshake (.windsurfrules)'));
         }
     }
-    // 3. Update .gitignore
+    // 3. Auto-initialize hooks for detected AI coding tools
+    await initHooksForDetectedTools(cwd, detectedIDE);
+    // 4. Update .gitignore
     const gitignorePath = path.join(cwd, '.gitignore');
     const ignorePatterns = ['rigour-report.json', 'rigour-fix-packet.json', '.rigour/'];
     try {
@@ -368,3 +371,24 @@ ${ruleContent}`;
         content: [{ type: "text", text: `Rigour Governance Initialized` }]
     });
 }
+// Maps detected IDE to hook tool name
+const IDE_TO_HOOK_TOOL = {
+    claude: 'claude',
+    cursor: 'cursor',
+    cline: 'cline',
+    windsurf: 'windsurf',
+};
+async function initHooksForDetectedTools(cwd, detectedIDE) {
+    const hookTool = IDE_TO_HOOK_TOOL[detectedIDE];
+    if (!hookTool) {
+        return; // Unknown IDE or no hook support (vscode, gemini, codex)
+    }
+    try {
+        console.log(chalk.dim(`\n   Setting up real-time hooks for ${detectedIDE}...`));
+        await hooksInitCommand(cwd, { tool: hookTool });
+    }
+    catch {
+        // Non-fatal — hooks are a bonus, not a requirement
+        console.log(chalk.dim(`   (Hooks setup skipped — run 'rigour hooks init' manually)`));
+    }
+}

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

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

package/dist/commands/init.test.js

@@ -0,0 +1,97 @@
+/**
+ * Tests for init command — IDE detection, config generation, auto-hook integration.
+ */
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { initCommand } from './init.js';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+describe('initCommand', () => {
+    let testDir;
+    beforeEach(() => {
+        testDir = fs.mkdtempSync(path.join(os.tmpdir(), 'init-test-'));
+        // Minimal package.json for discovery
+        fs.writeFileSync(path.join(testDir, 'package.json'), JSON.stringify({
+            name: 'test-project',
+            dependencies: { express: '^4.0.0' },
+        }));
+        vi.spyOn(console, 'log').mockImplementation(() => { });
+        vi.spyOn(console, 'error').mockImplementation(() => { });
+    });
+    afterEach(() => {
+        fs.rmSync(testDir, { recursive: true, force: true });
+        vi.restoreAllMocks();
+    });
+    it('should create rigour.yml', async () => {
+        await initCommand(testDir);
+        const configPath = path.join(testDir, 'rigour.yml');
+        expect(fs.existsSync(configPath)).toBe(true);
+        const content = fs.readFileSync(configPath, 'utf-8');
+        expect(content).toContain('version');
+    });
+    it('should create docs/AGENT_INSTRUCTIONS.md', async () => {
+        await initCommand(testDir);
+        const docsPath = path.join(testDir, 'docs', 'AGENT_INSTRUCTIONS.md');
+        expect(fs.existsSync(docsPath)).toBe(true);
+        const content = fs.readFileSync(docsPath, 'utf-8');
+        expect(content).toContain('Rigour');
+    });
+    it('should support dry-run mode', async () => {
+        await initCommand(testDir, { dryRun: true });
+        // Dry run should NOT create rigour.yml
+        expect(fs.existsSync(path.join(testDir, 'rigour.yml'))).toBe(false);
+    });
+    it('should not overwrite without --force', async () => {
+        // Create existing rigour.yml
+        fs.writeFileSync(path.join(testDir, 'rigour.yml'), 'version: 1\nexisting: true\n');
+        await initCommand(testDir);
+        const content = fs.readFileSync(path.join(testDir, 'rigour.yml'), 'utf-8');
+        expect(content).toContain('existing');
+    });
+    it('should overwrite with --force', async () => {
+        // Create existing rigour.yml
+        fs.writeFileSync(path.join(testDir, 'rigour.yml'), 'version: 1\nexisting: true\n');
+        await initCommand(testDir, { force: true });
+        // Should create backup
+        expect(fs.existsSync(path.join(testDir, 'rigour.yml.bak'))).toBe(true);
+        // New config should not contain 'existing'
+        const content = fs.readFileSync(path.join(testDir, 'rigour.yml'), 'utf-8');
+        expect(content).not.toContain('existing: true');
+    });
+    it('should detect Claude IDE and create hooks', async () => {
+        // Create Claude marker
+        fs.mkdirSync(path.join(testDir, '.claude'), { recursive: true });
+        await initCommand(testDir);
+        // Should have created .claude/settings.json (hooks)
+        const settingsPath = path.join(testDir, '.claude', 'settings.json');
+        expect(fs.existsSync(settingsPath)).toBe(true);
+    });
+    it('should detect Cursor IDE and create hooks', async () => {
+        // Create Cursor marker
+        fs.mkdirSync(path.join(testDir, '.cursor'), { recursive: true });
+        await initCommand(testDir);
+        // Should have created .cursor/hooks.json
+        const hooksPath = path.join(testDir, '.cursor', 'hooks.json');
+        expect(fs.existsSync(hooksPath)).toBe(true);
+    });
+    it('should update .gitignore with rigour patterns', async () => {
+        await initCommand(testDir);
+        const gitignorePath = path.join(testDir, '.gitignore');
+        expect(fs.existsSync(gitignorePath)).toBe(true);
+        const content = fs.readFileSync(gitignorePath, 'utf-8');
+        expect(content).toContain('rigour-report.json');
+        expect(content).toContain('.rigour/');
+    });
+    it('should create .rigour/memory.json for Studio', async () => {
+        await initCommand(testDir);
+        const memPath = path.join(testDir, '.rigour', 'memory.json');
+        expect(fs.existsSync(memPath)).toBe(true);
+        const mem = JSON.parse(fs.readFileSync(memPath, 'utf-8'));
+        expect(mem.memories.project_boot).toBeDefined();
+    });
+    it('should support --ide flag to target specific IDE', async () => {
+        await initCommand(testDir, { ide: 'windsurf' });
+        // Should create windsurf rules
+        expect(fs.existsSync(path.join(testDir, '.windsurfrules'))).toBe(true);
+    });
+});

package/dist/init-rules.test.js

@@ -1,12 +1,13 @@
 import { describe, it, expect, beforeEach, afterEach } from 'vitest';
 import fs from 'fs-extra';
 import path from 'path';
+import os from 'os';
 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');
+    const testDir = path.join(os.tmpdir(), 'rigour-temp-init-rules-test-' + process.pid);
     beforeEach(async () => {
         await fs.ensureDir(testDir);
     });

package/dist/smoke.test.js

@@ -1,12 +1,13 @@
 import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
 import fs from 'fs-extra';
 import path from 'path';
+import os from 'os';
 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');
+    const testDir = path.join(os.tmpdir(), 'rigour-temp-smoke-test-' + process.pid);
     beforeEach(async () => {
         await fs.ensureDir(testDir);
         // @ts-ignore

package/package.json

@@ -1,6 +1,22 @@
 {
   "name": "@rigour-labs/cli",
-  "version": "2.22.0",
+  "version": "3.0.1",
+  "description": "CLI quality gates for AI-generated code. Forces AI agents (Claude, Cursor, Copilot) to meet strict engineering standards with PASS/FAIL enforcement.",
+  "license": "MIT",
+  "homepage": "https://rigour.run",
+  "keywords": [
+    "quality-gates",
+    "ai-code-quality",
+    "cli",
+    "linter",
+    "static-analysis",
+    "claude",
+    "cursor",
+    "copilot",
+    "mcp",
+    "code-review",
+    "ci-cd"
+  ],
   "type": "module",
   "bin": {
     "rigour": "dist/cli.js"
@@ -28,7 +44,7 @@
     "inquirer": "9.2.16",
     "ora": "^8.0.1",
     "yaml": "^2.8.2",
-    "@rigour-labs/core": "2.22.0"
+    "@rigour-labs/core": "3.0.1"
   },
   "devDependencies": {
     "@types/fs-extra": "^11.0.4",