@rigour-labs/cli 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Rigour Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,33 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const init_js_1 = require("./commands/init.js");
+const check_js_1 = require("./commands/check.js");
+const run_js_1 = require("./commands/run.js");
+const program = new commander_1.Command();
+program
+    .name('rigour')
+    .description('A quality gate loop controller for AI-assisted coding')
+    .version('1.0.0');
+program
+    .command('init')
+    .description('Initialize VibeGuard in the current directory')
+    .action(async () => {
+    await (0, init_js_1.initCommand)(process.cwd());
+});
+program
+    .command('check')
+    .description('Run quality gate checks')
+    .action(async () => {
+    await (0, check_js_1.checkCommand)(process.cwd());
+});
+program
+    .command('run')
+    .description('Execute an agent command in a loop until quality gates pass')
+    .argument('[command...]', 'The agent command to run (e.g., cursor-agent ...)')
+    .option('-i, --iterations <number>', 'Maximum number of loop iterations', '3')
+    .action(async (args, options) => {
+    await (0, run_js_1.runLoop)(process.cwd(), args, { iterations: parseInt(options.iterations) });
+});
+program.parse();

package/dist/commands/check.d.ts

@@ -0,0 +1 @@
+export declare function checkCommand(cwd: string): Promise<void>;

package/dist/commands/check.js

@@ -0,0 +1,51 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkCommand = checkCommand;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+const chalk_1 = __importDefault(require("chalk"));
+const yaml_1 = __importDefault(require("yaml"));
+const core_1 = require("@rigour-labs/core");
+async function checkCommand(cwd) {
+    const configPath = path_1.default.join(cwd, 'rigour.yml');
+    if (!(await fs_extra_1.default.pathExists(configPath))) {
+        console.error(chalk_1.default.red('Error: rigour.yml not found. Run `rigour init` first.'));
+        process.exit(1);
+    }
+    const configContent = await fs_extra_1.default.readFile(configPath, 'utf-8');
+    const rawConfig = yaml_1.default.parse(configContent);
+    const config = core_1.ConfigSchema.parse(rawConfig);
+    console.log(chalk_1.default.blue('Running Rigour checks...\n'));
+    const runner = new core_1.GateRunner(config);
+    const report = await runner.run(cwd);
+    // Write machine report
+    const reportPath = path_1.default.join(cwd, config.output.report_path);
+    await fs_extra_1.default.writeJson(reportPath, report, { spaces: 2 });
+    // Print human summary
+    if (report.status === 'PASS') {
+        console.log(chalk_1.default.green.bold('✔ PASS - All quality gates satisfied.'));
+    }
+    else {
+        console.log(chalk_1.default.red.bold('✘ FAIL - Quality gate violations found.\n'));
+        for (const failure of report.failures) {
+            console.log(chalk_1.default.red(`[${failure.id}] ${failure.title}`));
+            console.log(chalk_1.default.dim(`  Details: ${failure.details}`));
+            if (failure.files && failure.files.length > 0) {
+                console.log(chalk_1.default.dim('  Files:'));
+                failure.files.forEach((f) => console.log(chalk_1.default.dim(`    - ${f}`)));
+            }
+            if (failure.hint) {
+                console.log(chalk_1.default.cyan(`  Hint: ${failure.hint}`));
+            }
+            console.log('');
+        }
+        console.log(chalk_1.default.yellow(`See ${config.output.report_path} for full details.`));
+    }
+    console.log(chalk_1.default.dim(`\nFinished in ${report.stats.duration_ms}ms`));
+    if (report.status !== 'PASS') {
+        process.exit(1);
+    }
+}

package/dist/commands/init.d.ts

@@ -0,0 +1 @@
+export declare function initCommand(cwd: string): Promise<void>;

package/dist/commands/init.js

@@ -0,0 +1,60 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initCommand = initCommand;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+const chalk_1 = __importDefault(require("chalk"));
+const yaml_1 = __importDefault(require("yaml"));
+const core_1 = require("@rigour-labs/core");
+async function initCommand(cwd) {
+    const discovery = new core_1.DiscoveryService();
+    const recommendedConfig = await discovery.discover(cwd);
+    const configPath = path_1.default.join(cwd, 'rigour.yml');
+    if (await fs_extra_1.default.pathExists(configPath)) {
+        console.log(chalk_1.default.yellow('rigour.yml already exists. Skipping initialization.'));
+        return;
+    }
+    await fs_extra_1.default.writeFile(configPath, yaml_1.default.stringify(recommendedConfig));
+    console.log(chalk_1.default.green('✔ Created rigour.yml'));
+    // Create required directories and files
+    const requireddocs = recommendedConfig.gates.required_files || [];
+    for (const file of requireddocs) {
+        const filePath = path_1.default.join(cwd, file);
+        if (!(await fs_extra_1.default.pathExists(filePath))) {
+            await fs_extra_1.default.ensureFile(filePath);
+            console.log(chalk_1.default.dim(`  - Created ${file}`));
+        }
+    }
+    // Agent Handshake (Cursor/AntiGravity)
+    const cursorRulesDir = path_1.default.join(cwd, '.cursor', 'rules');
+    await fs_extra_1.default.ensureDir(cursorRulesDir);
+    const rulePath = path_1.default.join(cursorRulesDir, 'rigour.mdc');
+    const ruleContent = `---
+description: Enforcement of Rigour quality gates and best practices.
+globs: **/*
+---
+
+# Rigour Enforcement
+
+You are operating under Rigour engineering discipline.
+
+## Core Rules
+- **Never claim done** until you run \`rigour check\` and it returns PASS.
+- If checks FAIL, fix **only** the listed failures. Do not add new features or refactor unrelated code.
+- Maintain project memory in \`docs/SPEC.md\`, \`docs/ARCH.md\`, and \`docs/DECISIONS.md\`.
+- Keep files modular. If a file exceeds 500 lines, you MUST break it into smaller components.
+- No \`TODO\` or \`FIXME\` comments allowed in the final submission.
+
+## Workflow
+1. Write/Modify code.
+2. Run \`rigour check\`.
+3. If FAIL: Read \`rigour-report.json\` for exact failure points and fix them.
+4. If PASS: You may claim task completion.
+`;
+    await fs_extra_1.default.writeFile(rulePath, ruleContent);
+    console.log(chalk_1.default.green('✔ Initialized Agent Handshake (.cursor/rules/rigour.mdc)'));
+    console.log(chalk_1.default.blue('\nRigour is ready. Run `rigour check` to verify your project.'));
+}

package/dist/commands/run.d.ts

@@ -0,0 +1,3 @@
+export declare function runLoop(cwd: string, agentArgs: string[], options: {
+    iterations: number;
+}): Promise<void>;

package/dist/commands/run.js

@@ -0,0 +1,76 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runLoop = runLoop;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+const chalk_1 = __importDefault(require("chalk"));
+const yaml_1 = __importDefault(require("yaml"));
+const execa_1 = require("execa");
+const core_1 = require("@rigour-labs/core");
+async function runLoop(cwd, agentArgs, options) {
+    const configPath = path_1.default.join(cwd, 'rigour.yml');
+    if (!(await fs_extra_1.default.pathExists(configPath))) {
+        console.error(chalk_1.default.red('Error: rigour.yml not found. Run `rigour init` first.'));
+        process.exit(1);
+    }
+    try {
+        const configContent = await fs_extra_1.default.readFile(configPath, 'utf-8');
+        const rawConfig = yaml_1.default.parse(configContent);
+        const config = core_1.ConfigSchema.parse(rawConfig);
+        const runner = new core_1.GateRunner(config);
+        let iteration = 0;
+        const maxIterations = options.iterations;
+        while (iteration < maxIterations) {
+            iteration++;
+            console.log(chalk_1.default.bold.blue(`\n══════════════════════════════════════════════════════════════════`));
+            console.log(chalk_1.default.bold.blue(`  RIGOUR LOOP: Iteration ${iteration}/${maxIterations}`));
+            console.log(chalk_1.default.bold.blue(`══════════════════════════════════════════════════════════════════`));
+            // 1. Run the agent command
+            if (agentArgs.length > 0) {
+                console.log(chalk_1.default.cyan(`\n🚀 DEPLOYING AGENT:`));
+                console.log(chalk_1.default.dim(`   Command: ${agentArgs.join(' ')}`));
+                try {
+                    await (0, execa_1.execa)(agentArgs[0], agentArgs.slice(1), { shell: true, stdio: 'inherit', cwd });
+                }
+                catch (error) {
+                    console.warn(chalk_1.default.yellow(`\n⚠️  Agent command finished with non-zero exit code. Rigour will now verify state...`));
+                }
+            }
+            // 2. Run Rigour Check
+            console.log(chalk_1.default.magenta('\n🔍 AUDITING QUALITY GATES...'));
+            const report = await runner.run(cwd);
+            if (report.status === 'PASS') {
+                console.log(chalk_1.default.green.bold('\n✨ PASS - All quality gates satisfied.'));
+                console.log(chalk_1.default.green(`   Your solution meets the required Engineering Rigour criteria.\n`));
+                return;
+            }
+            // 3. Generate and print Fix Packet for next iteration
+            console.log(chalk_1.default.red.bold(`\n🛑 FAIL - Found ${report.failures.length} engineering violations.`));
+            const fixPacket = report.failures.map((f, i) => {
+                let msg = chalk_1.default.white(`${i + 1}. `) + chalk_1.default.bold.red(`[${f.id.toUpperCase()}] `) + chalk_1.default.white(f.title);
+                msg += `\n   ├─ ` + chalk_1.default.dim(`Details: ${f.details}`);
+                if (f.hint)
+                    msg += `\n   └─ ` + chalk_1.default.yellow(`FIX: ${f.hint}`);
+                return msg;
+            }).join('\n\n');
+            console.log(chalk_1.default.bold.white('\n📋 ACTIONABLE FIX PACKET:'));
+            console.log(fixPacket);
+            console.log(chalk_1.default.dim('\nReturning control to agent for the next refinement cycle...'));
+            if (iteration === maxIterations) {
+                console.log(chalk_1.default.red.bold(`\n❌ CRITICAL: Reached maximum iterations (${maxIterations}).`));
+                console.log(chalk_1.default.red(`   Quality gates remain unfulfilled. Refactor manually or check agent logs.`));
+                process.exit(1);
+            }
+        }
+    }
+    catch (error) {
+        console.error(chalk_1.default.red(`\n❌ FATAL ERROR: ${error.message}`));
+        if (error.issues) {
+            console.error(chalk_1.default.dim(JSON.stringify(error.issues, null, 2)));
+        }
+        process.exit(1);
+    }
+}

package/dist/smoke.test.d.ts

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

package/dist/smoke.test.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+(0, vitest_1.describe)('CLI Smoke Test', () => {
+    (0, vitest_1.it)('should pass', async () => {
+        (0, vitest_1.expect)(true).toBe(true);
+    });
+});

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@rigour-labs/cli",
+  "version": "1.0.0",
+  "bin": {
+    "rigour": "dist/cli.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/erashu212/rigour"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "dependencies": {
+    "chalk": "^5.3.0",
+    "commander": "^12.0.0",
+    "cosmiconfig": "^9.0.0",
+    "execa": "^8.0.1",
+    "fs-extra": "^11.2.0",
+    "globby": "^14.0.1",
+    "yaml": "^2.8.2",
+    "@rigour-labs/core": "1.0.0"
+  },
+  "devDependencies": {
+    "@types/fs-extra": "^11.0.4",
+    "@types/node": "^25.0.3"
+  },
+  "scripts": {
+    "build": "tsc",
+    "test": "vitest run"
+  }
+}

package/src/cli.ts

@@ -0,0 +1,37 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import { initCommand } from './commands/init.js';
+import { checkCommand } from './commands/check.js';
+import { runLoop } from './commands/run.js';
+
+const program = new Command();
+
+program
+    .name('rigour')
+    .description('A quality gate loop controller for AI-assisted coding')
+    .version('1.0.0');
+
+program
+    .command('init')
+    .description('Initialize VibeGuard in the current directory')
+    .action(async () => {
+        await initCommand(process.cwd());
+    });
+
+program
+    .command('check')
+    .description('Run quality gate checks')
+    .action(async () => {
+        await checkCommand(process.cwd());
+    });
+
+program
+    .command('run')
+    .description('Execute an agent command in a loop until quality gates pass')
+    .argument('[command...]', 'The agent command to run (e.g., cursor-agent ...)')
+    .option('-i, --iterations <number>', 'Maximum number of loop iterations', '3')
+    .action(async (args, options) => {
+        await runLoop(process.cwd(), args, { iterations: parseInt(options.iterations) });
+    });
+
+program.parse();

package/src/commands/check.ts

@@ -0,0 +1,55 @@
+import fs from 'fs-extra';
+import path from 'path';
+import chalk from 'chalk';
+import yaml from 'yaml';
+import { GateRunner, ConfigSchema, Failure } from '@rigour-labs/core';
+
+export async function checkCommand(cwd: string) {
+    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(1);
+    }
+
+    const configContent = await fs.readFile(configPath, 'utf-8');
+    const rawConfig = yaml.parse(configContent);
+    const config = ConfigSchema.parse(rawConfig);
+
+    console.log(chalk.blue('Running Rigour checks...\n'));
+
+    const runner = new GateRunner(config);
+    const report = await runner.run(cwd);
+
+    // Write machine report
+    const reportPath = path.join(cwd, config.output.report_path);
+    await fs.writeJson(reportPath, report, { spaces: 2 });
+
+    // Print human summary
+    if (report.status === 'PASS') {
+        console.log(chalk.green.bold('✔ PASS - All quality gates satisfied.'));
+    } else {
+        console.log(chalk.red.bold('✘ FAIL - Quality gate violations found.\n'));
+
+        for (const failure of report.failures as Failure[]) {
+            console.log(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: string) => console.log(chalk.dim(`    - ${f}`)));
+            }
+            if (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`));
+
+    if (report.status !== 'PASS') {
+        process.exit(1);
+    }
+}

package/src/commands/init.ts

@@ -0,0 +1,63 @@
+import fs from 'fs-extra';
+import path from 'path';
+import chalk from 'chalk';
+import yaml from 'yaml';
+import { DiscoveryService } from '@rigour-labs/core';
+
+export async function initCommand(cwd: string) {
+    const discovery = new DiscoveryService();
+    const recommendedConfig = await discovery.discover(cwd);
+
+    const configPath = path.join(cwd, 'rigour.yml');
+
+    if (await fs.pathExists(configPath)) {
+        console.log(chalk.yellow('rigour.yml already exists. Skipping initialization.'));
+        return;
+    }
+
+    await fs.writeFile(configPath, 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 (Cursor/AntiGravity)
+    const cursorRulesDir = path.join(cwd, '.cursor', 'rules');
+    await fs.ensureDir(cursorRulesDir);
+    const rulePath = path.join(cursorRulesDir, 'rigour.mdc');
+
+    const ruleContent = `---
+description: Enforcement of Rigour quality gates and best practices.
+globs: **/*
+---
+
+# Rigour Enforcement
+
+You are operating under Rigour engineering discipline.
+
+## Core Rules
+- **Never claim done** until you run \`rigour check\` and it returns PASS.
+- If checks FAIL, fix **only** the listed failures. Do not add new features or refactor unrelated code.
+- Maintain project memory in \`docs/SPEC.md\`, \`docs/ARCH.md\`, and \`docs/DECISIONS.md\`.
+- Keep files modular. If a file exceeds 500 lines, you MUST break it into smaller components.
+- No \`TODO\` or \`FIXME\` comments allowed in the final submission.
+
+## Workflow
+1. Write/Modify code.
+2. Run \`rigour check\`.
+3. If FAIL: Read \`rigour-report.json\` for exact failure points and fix them.
+4. If PASS: You may claim task completion.
+`;
+
+    await fs.writeFile(rulePath, ruleContent);
+    console.log(chalk.green('✔ Initialized Agent Handshake (.cursor/rules/rigour.mdc)'));
+
+    console.log(chalk.blue('\nRigour is ready. Run `rigour check` to verify your project.'));
+}

package/src/commands/run.ts

@@ -0,0 +1,79 @@
+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';
+
+export async function runLoop(cwd: string, agentArgs: string[], options: { iterations: number }) {
+    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(1);
+    }
+
+    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. Run the agent command
+            if (agentArgs.length > 0) {
+                console.log(chalk.cyan(`\n🚀 DEPLOYING AGENT:`));
+                console.log(chalk.dim(`   Command: ${agentArgs.join(' ')}`));
+                try {
+                    await execa(agentArgs[0], agentArgs.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...`));
+                }
+            }
+
+            // 2. Run Rigour Check
+            console.log(chalk.magenta('\n🔍 AUDITING QUALITY GATES...'));
+            const report = await runner.run(cwd);
+
+            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;
+            }
+
+            // 3. Generate and print Fix Packet for next iteration
+            console.log(chalk.red.bold(`\n🛑 FAIL - Found ${report.failures.length} engineering violations.`));
+
+            const fixPacket = report.failures.map((f, i) => {
+                let msg = chalk.white(`${i + 1}. `) + chalk.bold.red(`[${f.id.toUpperCase()}] `) + chalk.white(f.title);
+                msg += `\n   ├─ ` + chalk.dim(`Details: ${f.details}`);
+                if (f.hint) msg += `\n   └─ ` + chalk.yellow(`FIX: ${f.hint}`);
+                return msg;
+            }).join('\n\n');
+
+            console.log(chalk.bold.white('\n📋 ACTIONABLE FIX PACKET:'));
+            console.log(fixPacket);
+            console.log(chalk.dim('\nReturning control to agent for the next refinement cycle...'));
+
+            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(1);
+            }
+        }
+    } 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(1);
+    }
+}

package/src/smoke.test.ts

@@ -0,0 +1,7 @@
+import { describe, it, expect } from 'vitest';
+
+describe('CLI Smoke Test', () => {
+    it('should pass', async () => {
+        expect(true).toBe(true);
+    });
+});

package/src/templates/handshake.mdc

@@ -0,0 +1,39 @@
+---
+description: Engineering Rigour Protocol - Enforces high software standards (SOLID, DRY, Patterns) via automated quality gates.
+globs: **/*
+---
+
+# 🛡️ 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 `rigour_check_status` (via MCP) or `rigour check` (via CLI).
+2.  **Analyze**: If it fails, run `rigour_get_fix_packet` to understand the engineering violations.
+3.  **Refactor**: Apply **SOLID** and **DRY** principles to resolve the violations.
+4.  **Repeat**: Continue until `rigour_check_status` returns **PASS**.
+
+## 🧩 Engineering Standards
+Your code will be judged against these gates:
+
+### 1. SOLID Principles
+- **Single Responsibility**: Keep files small and focused.
+- **Open/Closed**: Design for extension, not modification.
+- **Interface Segregation**: Don't force dependencies on unused methods.
+
+### 2. DRY (Don't Repeat Yourself)
+- Extract common logic into utilities or shared services.
+- If Rigour detects duplication, you must refactor immediately.
+
+### 3. "Done is Done"
+- No `TODO` or `FIXME` comments are allowed in the final state.
+- Every placeholder is a failure of rigour.
+
+## 🛠️ Tools at your disposal
+- `rigour_check_status`: Get the current PASS/FAIL state.
+- `rigour_get_fix_packet`: Get actionable instructions for failures.
+- `rigour run "<command>"`: Use this CLI command to run yourself in a loop until you pass (Experimental).
+
+**Remember:** Rigour is not just a tool; it is your engineering conscience. Hold yourself to the highest standard.

package/tsconfig.json

@@ -0,0 +1,10 @@
+{
+    "extends": "../../tsconfig.json",
+    "compilerOptions": {
+        "outDir": "dist",
+        "rootDir": "src"
+    },
+    "include": [
+        "src/**/*"
+    ]
+}