@rigour-labs/mcp 2.21.2 → 3.0.0

package/dist/tools/quality-handlers.js

@@ -0,0 +1,116 @@
+// ─── Score / Severity Formatters ──────────────────────────────────
+function formatScoreText(stats) {
+    let text = '';
+    if (stats.score !== undefined) {
+        text = `\nScore: ${stats.score}/100`;
+        if (stats.ai_health_score !== undefined)
+            text += ` | AI Health: ${stats.ai_health_score}/100`;
+        if (stats.structural_score !== undefined)
+            text += ` | Structural: ${stats.structural_score}/100`;
+    }
+    return text;
+}
+function formatSeverityText(stats) {
+    if (!stats.severity_breakdown)
+        return '';
+    const parts = Object.entries(stats.severity_breakdown).filter(([, c]) => c > 0).map(([s, c]) => `${s}: ${c}`);
+    return parts.length > 0 ? `\nSeverity: ${parts.join(', ')}` : '';
+}
+// ─── Handlers ─────────────────────────────────────────────────────
+export async function handleCheck(runner, cwd) {
+    const report = await runner.run(cwd);
+    const scoreText = formatScoreText(report.stats);
+    const sevText = formatSeverityText(report.stats);
+    const result = {
+        content: [{
+                type: "text",
+                text: `RIGOUR AUDIT RESULT: ${report.status}${scoreText}${sevText}\n\nSummary:\n${Object.entries(report.summary).map(([k, v]) => `- ${k}: ${v}`).join("\n")}`,
+            }],
+    };
+    result._rigour_report = report;
+    return result;
+}
+export async function handleExplain(runner, cwd) {
+    const report = await runner.run(cwd);
+    if (report.status === "PASS") {
+        const passScore = report.stats.score !== undefined ? ` Score: ${report.stats.score}/100.` : '';
+        return {
+            content: [{ type: "text", text: `ALL QUALITY GATES PASSED.${passScore} No failures to explain.` }],
+        };
+    }
+    let header = 'RIGOUR EXPLAIN:';
+    header += formatScoreText(report.stats);
+    header += formatSeverityText(report.stats);
+    const bullets = report.failures.map((f, i) => {
+        const sev = (f.severity || 'medium').toUpperCase();
+        const prov = f.provenance ? ` (${f.provenance})` : '';
+        return `${i + 1}. [${sev}] [${f.id.toUpperCase()}]${prov} ${f.title}: ${f.details}${f.hint ? ` (Hint: ${f.hint})` : ''}`;
+    }).join("\n");
+    return { content: [{ type: "text", text: `${header}\n\n${bullets}` }] };
+}
+export async function handleStatus(runner, cwd) {
+    const report = await runner.run(cwd);
+    return {
+        content: [{
+                type: "text",
+                text: JSON.stringify({
+                    status: report.status,
+                    summary: report.summary,
+                    failureCount: report.failures.length,
+                    score: report.stats.score,
+                    ai_health_score: report.stats.ai_health_score,
+                    structural_score: report.stats.structural_score,
+                    severity_breakdown: report.stats.severity_breakdown,
+                    provenance_breakdown: report.stats.provenance_breakdown,
+                    durationMs: report.stats.duration_ms,
+                }, null, 2),
+            }],
+    };
+}
+export async function handleGetFixPacket(runner, cwd, config) {
+    const report = await runner.run(cwd);
+    if (report.status === "PASS") {
+        const passScore = report.stats.score !== undefined ? ` Score: ${report.stats.score}/100.` : '';
+        return {
+            content: [{ type: "text", text: `ALL QUALITY GATES PASSED.${passScore} The current state meets the required engineering standards.` }],
+        };
+    }
+    const { FixPacketService } = await import("@rigour-labs/core");
+    const fixPacketService = new FixPacketService();
+    const fixPacket = fixPacketService.generate(report, config);
+    const packet = fixPacket.violations.map((v, i) => {
+        const sevTag = `[${(v.severity || 'medium').toUpperCase()}]`;
+        const catTag = v.category ? `(${v.category})` : '';
+        let text = `FIX TASK ${i + 1}: ${sevTag} ${catTag} [${v.id.toUpperCase()}] ${v.title}\n`;
+        text += `   - CONTEXT: ${v.details}\n`;
+        if (v.files?.length > 0)
+            text += `   - TARGET FILES: ${v.files.join(", ")}\n`;
+        if (v.hint)
+            text += `   - REFACTORING GUIDANCE: ${v.hint}\n`;
+        return text;
+    }).join("\n---\n");
+    let scoreHeader = formatScoreText(report.stats).trim();
+    if (scoreHeader)
+        scoreHeader += '\n';
+    return {
+        content: [{
+                type: "text",
+                text: `ENGINEERING REFINEMENT REQUIRED:\n${scoreHeader}\nThe project state violated ${report.failures.length} quality gates. You MUST address these failures before declaring the task complete (critical issues first):\n\n${packet}`,
+            }],
+    };
+}
+export function handleListGates(config) {
+    return {
+        content: [{
+                type: "text",
+                text: `ACTIVE QUALITY GATES:\n\n${Object.entries(config.gates).map(([k, v]) => {
+                    if (typeof v === 'object' && v !== null)
+                        return `- ${k}: ${JSON.stringify(v)}`;
+                    return `- ${k}: ${v}`;
+                }).join("\n")}`,
+            }],
+    };
+}
+export function handleGetConfig(config) {
+    return { content: [{ type: "text", text: JSON.stringify(config, null, 2) }] };
+}

package/dist/tools/review-handler.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Code Review Tool Handler
+ *
+ * Handler for: rigour_review
+ *
+ * @since v2.17.0 — extracted from monolithic index.ts
+ */
+import { GateRunner } from "@rigour-labs/core";
+type ToolResult = {
+    content: {
+        type: string;
+        text: string;
+    }[];
+};
+export declare function handleReview(runner: GateRunner, cwd: string, diff: string, changedFiles?: string[]): Promise<ToolResult>;
+export {};

package/dist/tools/review-handler.js

@@ -0,0 +1,42 @@
+import { parseDiff } from '../utils/config.js';
+export async function handleReview(runner, cwd, diff, changedFiles) {
+    // 1. Map diff to line numbers for filtering
+    const diffMapping = parseDiff(diff);
+    const targetFiles = changedFiles || Object.keys(diffMapping);
+    // 2. Run high-fidelity analysis on changed files
+    const report = await runner.run(cwd, targetFiles);
+    // 3. Filter failures to only those on changed lines (or global gate failures)
+    const filteredFailures = report.failures.filter(failure => {
+        if (!failure.files || failure.files.length === 0)
+            return true;
+        return failure.files.some(file => {
+            const fileModifiedLines = diffMapping[file];
+            if (!fileModifiedLines)
+                return false;
+            if (failure.line !== undefined)
+                return fileModifiedLines.has(failure.line);
+            return true;
+        });
+    });
+    return {
+        content: [{
+                type: "text",
+                text: JSON.stringify({
+                    status: filteredFailures.length > 0 ? "FAIL" : "PASS",
+                    score: report.stats.score,
+                    ai_health_score: report.stats.ai_health_score,
+                    structural_score: report.stats.structural_score,
+                    failures: filteredFailures.map(f => ({
+                        id: f.id,
+                        gate: f.title,
+                        severity: f.severity || 'medium',
+                        provenance: f.provenance || 'traditional',
+                        message: f.details,
+                        file: f.files?.[0] || "",
+                        line: f.line || 1,
+                        suggestion: f.hint,
+                    })),
+                }),
+            }],
+    };
+}

package/dist/utils/config.d.ts

@@ -0,0 +1,146 @@
+export declare function loadConfig(cwd: string): Promise<{
+    ignore: string[];
+    version: number;
+    commands: {
+        format?: string | undefined;
+        lint?: string | undefined;
+        typecheck?: string | undefined;
+        test?: string | undefined;
+    };
+    gates: {
+        max_file_lines: number;
+        forbid_todos: boolean;
+        forbid_fixme: boolean;
+        forbid_paths: string[];
+        required_files: string[];
+        ast: {
+            complexity: number;
+            max_methods: number;
+            max_params: number;
+            max_nesting: number;
+            max_inheritance_depth: number;
+            max_class_dependencies: number;
+            max_function_lines: number;
+        };
+        staleness: {
+            enabled: boolean;
+            rules: Record<string, boolean>;
+        };
+        dependencies: {
+            forbid: string[];
+            trusted_registry?: string | undefined;
+        };
+        architecture: {
+            boundaries: {
+                from: string;
+                to: string;
+                mode: "allow" | "deny";
+            }[];
+        };
+        safety: {
+            max_files_changed_per_cycle: number;
+            protected_paths: string[];
+        };
+        context: {
+            enabled: boolean;
+            sensitivity: number;
+            mining_depth: number;
+            ignored_patterns: string[];
+            cross_file_patterns: boolean;
+            naming_consistency: boolean;
+            import_relationships: boolean;
+            max_cross_file_depth: number;
+        };
+        environment: {
+            enabled: boolean;
+            enforce_contracts: boolean;
+            tools: Record<string, string>;
+            required_env: string[];
+        };
+        retry_loop_breaker: {
+            enabled: boolean;
+            max_retries: number;
+            auto_classify: boolean;
+            doc_sources: Record<string, string>;
+        };
+        agent_team: {
+            enabled: boolean;
+            max_concurrent_agents: number;
+            cross_agent_pattern_check: boolean;
+            handoff_verification: boolean;
+            task_ownership: "strict" | "collaborative";
+        };
+        checkpoint: {
+            enabled: boolean;
+            interval_minutes: number;
+            quality_threshold: number;
+            drift_detection: boolean;
+            auto_save_on_failure: boolean;
+        };
+        security: {
+            enabled: boolean;
+            sql_injection: boolean;
+            xss: boolean;
+            path_traversal: boolean;
+            hardcoded_secrets: boolean;
+            insecure_randomness: boolean;
+            command_injection: boolean;
+            block_on_severity: "critical" | "high" | "medium" | "low";
+        };
+        adaptive: {
+            enabled: boolean;
+            base_coverage_threshold: number;
+            base_quality_threshold: number;
+            auto_detect_tier: boolean;
+            forced_tier?: "hobby" | "startup" | "enterprise" | undefined;
+        };
+        duplication_drift: {
+            enabled: boolean;
+            similarity_threshold: number;
+            min_body_lines: number;
+        };
+        hallucinated_imports: {
+            enabled: boolean;
+            check_relative: boolean;
+            check_packages: boolean;
+            ignore_patterns: string[];
+        };
+        inconsistent_error_handling: {
+            enabled: boolean;
+            max_strategies_per_type: number;
+            min_occurrences: number;
+            ignore_empty_catches: boolean;
+        };
+        context_window_artifacts: {
+            enabled: boolean;
+            min_file_lines: number;
+            degradation_threshold: number;
+            signals_required: number;
+        };
+        promise_safety: {
+            enabled: boolean;
+            ignore_patterns: string[];
+            check_unhandled_then: boolean;
+            check_unsafe_parse: boolean;
+            check_async_without_await: boolean;
+            check_unsafe_fetch: boolean;
+        };
+    };
+    output: {
+        report_path: string;
+    };
+    planned: string[];
+    preset?: string | undefined;
+    paradigm?: string | undefined;
+}>;
+export interface MemoryStore {
+    memories: Record<string, {
+        value: string;
+        timestamp: string;
+    }>;
+}
+export declare function getMemoryPath(cwd: string): Promise<string>;
+export declare function loadMemory(cwd: string): Promise<MemoryStore>;
+export declare function saveMemory(cwd: string, store: MemoryStore): Promise<void>;
+export declare function logStudioEvent(cwd: string, event: any): Promise<void>;
+export declare function parseDiff(diff: string): Record<string, Set<number>>;

package/dist/utils/config.js

@@ -0,0 +1,93 @@
+/**
+ * Configuration & Utility Helpers
+ *
+ * Shared utilities for config loading, memory persistence,
+ * Studio event logging, and diff parsing.
+ *
+ * @since v2.17.0 — extracted from monolithic index.ts
+ */
+import fs from "fs-extra";
+import path from "path";
+import yaml from "yaml";
+import { randomUUID } from "crypto";
+import { ConfigSchema } from "@rigour-labs/core";
+// ─── Config Loading ───────────────────────────────────────────────
+export async function loadConfig(cwd) {
+    const configPath = path.join(cwd, "rigour.yml");
+    if (!(await fs.pathExists(configPath))) {
+        console.error(`[RIGOUR] rigour.yml not found in ${cwd}, auto-initializing...`);
+        const { execa } = await import("execa");
+        try {
+            await execa("npx", ["rigour", "init"], { cwd, shell: true });
+            console.error(`[RIGOUR] Auto-initialization complete.`);
+        }
+        catch (initError) {
+            throw new Error(`Rigour auto-initialization failed: ${initError.message}. Please run 'npx rigour init' manually.`);
+        }
+    }
+    const configContent = await fs.readFile(configPath, "utf-8");
+    return ConfigSchema.parse(yaml.parse(configContent));
+}
+export async function getMemoryPath(cwd) {
+    const rigourDir = path.join(cwd, ".rigour");
+    await fs.ensureDir(rigourDir);
+    return path.join(rigourDir, "memory.json");
+}
+export async function loadMemory(cwd) {
+    const memPath = await getMemoryPath(cwd);
+    if (await fs.pathExists(memPath)) {
+        const content = await fs.readFile(memPath, "utf-8");
+        return JSON.parse(content);
+    }
+    return { memories: {} };
+}
+export async function saveMemory(cwd, store) {
+    const memPath = await getMemoryPath(cwd);
+    await fs.writeFile(memPath, JSON.stringify(store, null, 2));
+}
+// ─── Studio Event Logging ─────────────────────────────────────────
+export async function logStudioEvent(cwd, event) {
+    try {
+        const rigourDir = path.join(cwd, ".rigour");
+        await fs.ensureDir(rigourDir);
+        const eventsPath = path.join(rigourDir, "events.jsonl");
+        const logEntry = JSON.stringify({
+            id: randomUUID(),
+            timestamp: new Date().toISOString(),
+            ...event,
+        }) + "\n";
+        await fs.appendFile(eventsPath, logEntry);
+    }
+    catch {
+        // Silent fail — Studio logging is non-blocking and zero-telemetry
+    }
+}
+// ─── Diff Parsing ─────────────────────────────────────────────────
+export function parseDiff(diff) {
+    const lines = diff.split("\n");
+    const mapping = {};
+    let currentFile = "";
+    let currentLine = 0;
+    for (const line of lines) {
+        if (line.startsWith("+++ b/")) {
+            currentFile = line.slice(6);
+            mapping[currentFile] = new Set();
+        }
+        else if (line.startsWith("@@")) {
+            const match = line.match(/\+(\d+)/);
+            if (match) {
+                currentLine = parseInt(match[1], 10);
+            }
+        }
+        else if (line.startsWith("+") && !line.startsWith("+++")) {
+            if (currentFile) {
+                mapping[currentFile].add(currentLine);
+            }
+            currentLine++;
+        }
+        else if (!line.startsWith("-")) {
+            currentLine++;
+        }
+    }
+    return mapping;
+}

package/package.json

@@ -1,9 +1,27 @@
 {
   "name": "@rigour-labs/mcp",
-  "version": "2.21.2",
+  "version": "3.0.0",
+  "description": "MCP server for AI code quality gates. Integrates with Claude Desktop, Cursor, Cline, and VS Code to enforce engineering standards in real-time.",
+  "license": "MIT",
+  "homepage": "https://rigour.run",
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "quality-gates",
+    "ai-code-quality",
+    "claude",
+    "cursor",
+    "cline",
+    "code-review",
+    "static-analysis",
+    "agent-governance"
+  ],
   "type": "module",
   "mcpName": "io.github.rigour-labs/rigour",
-  "description": "Quality gates for AI-generated code. Forces AI agents to meet strict engineering standards with PASS/FAIL enforcement.",
+  "files": [
+    "dist",
+    "README.md"
+  ],
   "bin": {
     "rigour-mcp": "dist/index.js"
   },
@@ -20,7 +38,7 @@
     "execa": "^8.0.1",
     "fs-extra": "^11.2.0",
     "yaml": "^2.8.2",
-    "@rigour-labs/core": "2.21.2"
+    "@rigour-labs/core": "3.0.0"
   },
   "devDependencies": {
     "@types/node": "^25.0.3",

package/.claude-plugin/SKILL.md

@@ -1,51 +0,0 @@
-# Rigour Governance Skills
-
-Rigour provides meta-cognitive governance tools to ensure AI agents stay aligned with engineering standards, project context, and brand identity during long-running coworking tasks.
-
-## Skills
-
-### `rigour_checkpoint`
-Record a quality checkpoint during long-running agent execution. Use periodically (every 15-30 min) to enable drift detection and quality monitoring. Essential for coworking mode.
-
-**Parameters:**
-- `cwd` (string, required): Absolute path to the project root.
-- `progressPct` (number, required): Estimated progress percentage (0-100).
-- `summary` (string, required): Brief description of work done since last checkpoint.
-- `qualityScore` (number, required): Self-assessed quality score (0-100).
-- `filesChanged` (array of strings): List of files modified since last checkpoint.
-
----
-
-### `rigour_agent_register`
-Register an agent in a multi-agent session. Use this at the START of agent execution to claim task scope and enable cross-agent conflict detection.
-
-**Parameters:**
-- `cwd` (string, required): Absolute path to the project root.
-- `agentId` (string, required): Unique identifier for this agent (e.g., 'marketing-pro', 'sales-bot').
-- `taskScope` (array of strings, required): Glob patterns defining the files/directories this agent will work on.
-
----
-
-### `rigour_check`
-Run all configured quality gates (Lint, Test, AST, etc.) on the project. Call this before completing a task to verify overall quality.
-
-**Parameters:**
-- `cwd` (string, required): Absolute path to the project root.
-
----
-
-### `rigour_get_fix_packet`
-If gates fail, call this to retrieve a prioritized 'Fix Packet' containing detailed instructions on how to resolve the violations.
-
-**Parameters:**
-- `cwd` (string, required): Absolute path to the project root.
-
----
-
-### `rigour_remember`
-Persist critical instructions or project-specific conventions that should be remembered across sessions.
-
-**Parameters:**
-- `cwd` (string, required): Absolute path to the project root.
-- `key` (string, required): Unique key for the memory.
-- `value` (string, required): The instruction or context to remember.

package/.claude-plugin/marketplace.json

@@ -1,21 +0,0 @@
-{
-    "$schema": "https://claude.com/schemas/marketplace.schema.json",
-    "name": "Rigour Governance",
-    "version": "2.14.0",
-    "description": "Meta-cognitive governance for AI agents. Monitor drift, manage agent teams, and enforce quality gates during long-running coworking tasks.",
-    "owner": {
-        "name": "Rigour Labs",
-        "email": "support@rigour.dev"
-    },
-    "plugins": [
-        {
-            "name": "rigour-governance",
-            "description": "Quality gate checks, checkpoint supervision, and multi-agent governance for Claude Cowork mode.",
-            "version": "2.14.0",
-            "source": {
-                "type": "npm",
-                "package": "@rigour-labs/mcp"
-            }
-        }
-    ]
-}

package/.claude-plugin/plugin.json

@@ -1,17 +0,0 @@
-{
-    "name": "Rigour Quality Governance",
-    "version": "2.14.0",
-    "description": "Meta-cognitive governance for AI agents. Monitor drift, manage agent teams, and enforce quality gates during long-running coworking tasks.",
-    "author": "Rigour Labs",
-    "capabilities": {
-        "mcp": {
-            "enabled": true
-        }
-    },
-    "entrypoint": "../dist/index.js",
-    "icon": "🛡️",
-    "categories": [
-        "Productivity",
-        "Developer Tools"
-    ]
-}

package/server.json

@@ -1,21 +0,0 @@
-{
-    "$schema": "https://static.modelcontextprotocol.io/schemas/2025-12-11/server.schema.json",
-    "name": "io.github.rigour-labs/rigour",
-    "description": "Quality gates for AI agents. Lint, test, build checks with memory persistence.",
-    "repository": {
-        "url": "https://github.com/rigour-labs/rigour",
-        "source": "github"
-    },
-    "version": "2.12.0",
-    "packages": [
-        {
-            "registryType": "npm",
-            "identifier": "@rigour-labs/mcp",
-            "version": "2.12.0",
-            "transport": {
-                "type": "stdio"
-            },
-            "runtime": "node"
-        }
-    ]
-}