@rigour-labs/cli 2.0.0 → 2.1.0

package/dist/cli.js

@@ -43,17 +43,20 @@ Examples:
 program
     .command('check')
     .description('Run quality gate checks')
+    .argument('[files...]', 'Specific files or directories to check')
     .option('--ci', 'CI mode (minimal output, non-zero exit on fail)')
     .option('--json', 'Output report in JSON format')
     .option('-i, --interactive', 'Run in interactive mode with rich output')
     .addHelpText('after', `
 Examples:
   $ rigour check                       # Run standard check
+  $ rigour check ./src                 # Check only the src directory
+  $ rigour check ./src/app.ts          # Check only app.ts
   $ rigour check --interactive         # Run with rich, interactive output
   $ rigour check --ci                  # Run in CI environment
     `)
-    .action(async (options) => {
-    await (0, check_js_1.checkCommand)(process.cwd(), options);
+    .action(async (files, options) => {
+    await (0, check_js_1.checkCommand)(process.cwd(), files, options);
 });
 program
     .command('explain')

package/dist/commands/check.d.ts

@@ -3,4 +3,4 @@ export interface CheckOptions {
     json?: boolean;
     interactive?: boolean;
 }
-export declare function checkCommand(cwd: string, options?: CheckOptions): Promise<void>;
+export declare function checkCommand(cwd: string, files?: string[], options?: CheckOptions): Promise<void>;

package/dist/commands/check.js

@@ -14,7 +14,7 @@ const EXIT_PASS = 0;
 const EXIT_FAIL = 1;
 const EXIT_CONFIG_ERROR = 2;
 const EXIT_INTERNAL_ERROR = 3;
-async function checkCommand(cwd, options = {}) {
+async function checkCommand(cwd, files = [], options = {}) {
     const configPath = path_1.default.join(cwd, 'rigour.yml');
     if (!(await fs_extra_1.default.pathExists(configPath))) {
         if (options.json) {
@@ -33,7 +33,7 @@ async function checkCommand(cwd, options = {}) {
             console.log(chalk_1.default.blue('Running Rigour checks...\n'));
         }
         const runner = new core_1.GateRunner(config);
-        const report = await runner.run(cwd);
+        const report = await runner.run(cwd, files.length > 0 ? files : undefined);
         // Write machine report
         const reportPath = path_1.default.join(cwd, config.output.report_path);
         await fs_extra_1.default.writeJson(reportPath, report, { spaces: 2 });

package/dist/smoke.test.js

@@ -1,8 +1,63 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 const vitest_1 = require("vitest");
+const check_js_1 = require("./commands/check.js");
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
 (0, vitest_1.describe)('CLI Smoke Test', () => {
-    (0, vitest_1.it)('should pass', async () => {
-        (0, vitest_1.expect)(true).toBe(true);
+    const testDir = path_1.default.join(process.cwd(), 'temp-smoke-test');
+    (0, vitest_1.beforeEach)(async () => {
+        await fs_extra_1.default.ensureDir(testDir);
+        // @ts-ignore
+        vitest_1.vi.spyOn(process, 'exit').mockImplementation(() => { });
+    });
+    (0, vitest_1.afterEach)(async () => {
+        await fs_extra_1.default.remove(testDir);
+        vitest_1.vi.restoreAllMocks();
+    });
+    (0, vitest_1.it)('should respect ignore patterns and avoid EPERM', async () => {
+        const restrictedDir = path_1.default.join(testDir, '.restricted');
+        await fs_extra_1.default.ensureDir(restrictedDir);
+        await fs_extra_1.default.writeFile(path_1.default.join(restrictedDir, 'secret.js'), 'TODO: leak');
+        await fs_extra_1.default.writeFile(path_1.default.join(testDir, 'rigour.yml'), `
+version: 1
+ignore:
+  - ".restricted/**"
+gates:
+  forbid_todos: true
+  required_files: []
+`);
+        // Simulate EPERM by changing permissions
+        await fs_extra_1.default.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
+            await (0, vitest_1.expect)((0, check_js_1.checkCommand)(testDir, [], { ci: true })).resolves.not.toThrow();
+        }
+        finally {
+            await fs_extra_1.default.chmod(restrictedDir, 0o777);
+        }
+    });
+    (0, vitest_1.it)('should check specific files when provided', async () => {
+        await fs_extra_1.default.writeFile(path_1.default.join(testDir, 'bad.js'), 'TODO: fixme');
+        await fs_extra_1.default.writeFile(path_1.default.join(testDir, 'good.js'), 'console.log("hello")');
+        await fs_extra_1.default.writeFile(path_1.default.join(testDir, 'rigour.yml'), `
+version: 1
+gates:
+  forbid_todos: true
+  required_files: []
+`);
+        // If we check ONLY good.js, it should PASS (exit PASS)
+        await (0, check_js_1.checkCommand)(testDir, [path_1.default.join(testDir, 'good.js')], { ci: true });
+        (0, vitest_1.expect)(process.exit).toHaveBeenCalledWith(0);
+        // If we check bad.js, it should FAIL (exit FAIL)
+        vitest_1.vi.clearAllMocks();
+        await (0, check_js_1.checkCommand)(testDir, [path_1.default.join(testDir, 'bad.js')], { ci: true });
+        (0, vitest_1.expect)(process.exit).toHaveBeenCalledWith(1);
     });
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rigour-labs/cli",
-  "version": "2.0.0",
+  "version": "2.1.0",
   "bin": {
     "rigour": "dist/cli.js"
   },
@@ -20,7 +20,7 @@
     "fs-extra": "^11.2.0",
     "globby": "^14.0.1",
     "yaml": "^2.8.2",
-    "@rigour-labs/core": "2.0.0"
+    "@rigour-labs/core": "2.1.0"
   },
   "devDependencies": {
     "@types/fs-extra": "^11.0.4",

package/src/cli.ts

@@ -42,17 +42,20 @@ Examples:
 program
     .command('check')
     .description('Run quality gate checks')
+    .argument('[files...]', 'Specific files or directories to check')
     .option('--ci', 'CI mode (minimal output, non-zero exit on fail)')
     .option('--json', 'Output report in JSON format')
     .option('-i, --interactive', 'Run in interactive mode with rich output')
     .addHelpText('after', `
 Examples:
   $ rigour check                       # Run standard check
+  $ rigour check ./src                 # Check only the src directory
+  $ rigour check ./src/app.ts          # Check only app.ts
   $ rigour check --interactive         # Run with rich, interactive output
   $ rigour check --ci                  # Run in CI environment
     `)
-    .action(async (options: any) => {
-        await checkCommand(process.cwd(), options);
+    .action(async (files: string[], options: any) => {
+        await checkCommand(process.cwd(), files, options);
     });
 
 program

package/src/commands/check.ts

@@ -16,7 +16,7 @@ export interface CheckOptions {
     interactive?: boolean;
 }
 
-export async function checkCommand(cwd: string, options: CheckOptions = {}) {
+export async function checkCommand(cwd: string, files: string[] = [], options: CheckOptions = {}) {
     const configPath = path.join(cwd, 'rigour.yml');
 
     if (!(await fs.pathExists(configPath))) {
@@ -38,7 +38,7 @@ export async function checkCommand(cwd: string, options: CheckOptions = {}) {
         }
 
         const runner = new GateRunner(config);
-        const report = await runner.run(cwd);
+        const report = await runner.run(cwd, files.length > 0 ? files : undefined);
 
         // Write machine report
         const reportPath = path.join(cwd, config.output.report_path);

package/src/smoke.test.ts

@@ -1,7 +1,68 @@
-import { describe, it, expect } from 'vitest';
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { checkCommand } from './commands/check.js';
+import fs from 'fs-extra';
+import path from 'path';
 
 describe('CLI Smoke Test', () => {
-    it('should pass', async () => {
-        expect(true).toBe(true);
+    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
+            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)
+        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();
+        await checkCommand(testDir, [path.join(testDir, 'bad.js')], { ci: true });
+        expect(process.exit).toHaveBeenCalledWith(1);
     });
 });