@rigour-labs/mcp 2.22.0 → 3.0.1

package/dist/tools/definitions.js

@@ -0,0 +1,249 @@
+/**
+ * MCP Tool Definitions
+ *
+ * Schema definitions for all Rigour MCP tools.
+ * Each tool has a name, description, and JSON Schema for its input.
+ *
+ * @since v2.17.0 — extracted from monolithic index.ts
+ */
+function cwdParam() {
+    return {
+        cwd: {
+            type: "string",
+            description: "Absolute path to the project root.",
+        },
+    };
+}
+export const TOOL_DEFINITIONS = [
+    // ─── Core Quality Gates ───────────────────────────────
+    {
+        name: "rigour_check",
+        description: "Run quality gate checks on the project. Matches the CLI 'check' command.",
+        inputSchema: {
+            type: "object",
+            properties: cwdParam(),
+            required: ["cwd"],
+        },
+    },
+    {
+        name: "rigour_explain",
+        description: "Explain the last quality gate failures with actionable bullets. Matches the CLI 'explain' command.",
+        inputSchema: {
+            type: "object",
+            properties: cwdParam(),
+            required: ["cwd"],
+        },
+    },
+    {
+        name: "rigour_status",
+        description: "Quick PASS/FAIL check with JSON-friendly output for polling current project state.",
+        inputSchema: {
+            type: "object",
+            properties: cwdParam(),
+            required: ["cwd"],
+        },
+    },
+    {
+        name: "rigour_get_fix_packet",
+        description: "Retrieves a prioritized 'Fix Packet' (v2 schema) containing detailed machine-readable diagnostic data.",
+        inputSchema: {
+            type: "object",
+            properties: cwdParam(),
+            required: ["cwd"],
+        },
+    },
+    {
+        name: "rigour_list_gates",
+        description: "Lists all configured quality gates and their thresholds for the current project.",
+        inputSchema: {
+            type: "object",
+            properties: cwdParam(),
+            required: ["cwd"],
+        },
+    },
+    {
+        name: "rigour_get_config",
+        description: "Returns the current Rigour configuration (rigour.yml) for agent reasoning.",
+        inputSchema: {
+            type: "object",
+            properties: cwdParam(),
+            required: ["cwd"],
+        },
+    },
+    // ─── Memory Persistence ───────────────────────────────
+    {
+        name: "rigour_remember",
+        description: "Store a persistent instruction or context that the AI should remember across sessions. Use this to persist user preferences, project conventions, or critical instructions.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                ...cwdParam(),
+                key: { type: "string", description: "A unique key for this memory (e.g., 'user_preferences', 'coding_style')." },
+                value: { type: "string", description: "The instruction or context to remember." },
+            },
+            required: ["cwd", "key", "value"],
+        },
+    },
+    {
+        name: "rigour_recall",
+        description: "Retrieve stored instructions or context. Call this at the start of each session to restore memory. Returns all stored memories if no key specified.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                ...cwdParam(),
+                key: { type: "string", description: "Optional. Key of specific memory to retrieve." },
+            },
+            required: ["cwd"],
+        },
+    },
+    {
+        name: "rigour_forget",
+        description: "Remove a stored memory by key.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                ...cwdParam(),
+                key: { type: "string", description: "Key of the memory to remove." },
+            },
+            required: ["cwd", "key"],
+        },
+    },
+    // ─── Pattern Intelligence ─────────────────────────────
+    {
+        name: "rigour_check_pattern",
+        description: "Checks if a proposed code pattern (function, component, etc.) already exists, is stale, or has security vulnerabilities (CVEs). CALL THIS BEFORE CREATING NEW CODE.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                ...cwdParam(),
+                name: { type: "string", description: "The name of the function, class, or component you want to create." },
+                type: { type: "string", description: "The type of pattern (e.g., 'function', 'component', 'hook', 'type')." },
+                intent: { type: "string", description: "What the code is for (e.g., 'format dates', 'user authentication')." },
+            },
+            required: ["cwd", "name"],
+        },
+    },
+    {
+        name: "rigour_security_audit",
+        description: "Runs a live security audit (CVE check) on the project dependencies.",
+        inputSchema: {
+            type: "object",
+            properties: cwdParam(),
+            required: ["cwd"],
+        },
+    },
+    // ─── Execution & Supervision ──────────────────────────
+    {
+        name: "rigour_run",
+        description: "Execute a command under Rigour supervision. This tool can be INTERCEPTED and ARBITRATED by the Governance Studio.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                ...cwdParam(),
+                command: { type: "string", description: "The command to run (e.g., 'npm test', 'pytest')." },
+                silent: { type: "boolean", description: "If true, hides the command output from the agent." },
+            },
+            required: ["cwd", "command"],
+        },
+    },
+    {
+        name: "rigour_run_supervised",
+        description: "Run a command under FULL Supervisor Mode. Iteratively executes the command, checks quality gates, and returns fix packets until PASS or max retries reached. Use this for self-healing agent loops.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                ...cwdParam(),
+                command: { type: "string", description: "The agent command to run (e.g., 'claude \"fix the bug\"', 'aider --message \"refactor auth\"')." },
+                maxRetries: { type: "number", description: "Maximum retry iterations (default: 3)." },
+                dryRun: { type: "boolean", description: "If true, simulates the loop without executing the command. Useful for testing gate checks." },
+            },
+            required: ["cwd", "command"],
+        },
+    },
+    // ─── Multi-Agent Governance (v2.14+) ──────────────────
+    {
+        name: "rigour_agent_register",
+        description: "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. Required for Agent Team Governance.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                ...cwdParam(),
+                agentId: { type: "string", description: "Unique identifier for this agent (e.g., 'agent-a', 'opus-frontend')." },
+                taskScope: { type: "array", items: { type: "string" }, description: "Glob patterns defining the files/directories this agent will work on (e.g., ['src/api/**', 'tests/api/**'])." },
+            },
+            required: ["cwd", "agentId", "taskScope"],
+        },
+    },
+    {
+        name: "rigour_checkpoint",
+        description: "Record a quality checkpoint during long-running agent execution. Use periodically (every 15-30 min) to enable drift detection and quality monitoring. Essential for GPT-5.3 coworking mode.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                ...cwdParam(),
+                progressPct: { type: "number", description: "Estimated progress percentage (0-100)." },
+                filesChanged: { type: "array", items: { type: "string" }, description: "List of files modified since last checkpoint." },
+                summary: { type: "string", description: "Brief description of work done since last checkpoint." },
+                qualityScore: { type: "number", description: "Self-assessed quality score (0-100). Be honest - artificially high scores trigger drift detection." },
+            },
+            required: ["cwd", "progressPct", "summary", "qualityScore"],
+        },
+    },
+    {
+        name: "rigour_handoff",
+        description: "Handoff task to another agent in a multi-agent workflow. Use when delegating a subtask or completing your scope. Enables verified handoff governance.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                ...cwdParam(),
+                fromAgentId: { type: "string", description: "ID of the agent initiating the handoff." },
+                toAgentId: { type: "string", description: "ID of the agent receiving the handoff." },
+                taskDescription: { type: "string", description: "Description of the task being handed off." },
+                filesInScope: { type: "array", items: { type: "string" }, description: "Files relevant to the handoff." },
+                context: { type: "string", description: "Additional context for the receiving agent." },
+            },
+            required: ["cwd", "fromAgentId", "toAgentId", "taskDescription"],
+        },
+    },
+    {
+        name: "rigour_agent_deregister",
+        description: "Deregister an agent from the multi-agent session. Use when an agent completes its work or needs to release its scope for another agent.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                ...cwdParam(),
+                agentId: { type: "string", description: "ID of the agent to deregister." },
+            },
+            required: ["cwd", "agentId"],
+        },
+    },
+    {
+        name: "rigour_handoff_accept",
+        description: "Accept a pending handoff from another agent. Use to formally acknowledge receipt of a task and verify you are the intended recipient.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                ...cwdParam(),
+                handoffId: { type: "string", description: "ID of the handoff to accept." },
+                agentId: { type: "string", description: "ID of the accepting agent (must match toAgentId in the handoff)." },
+            },
+            required: ["cwd", "handoffId", "agentId"],
+        },
+    },
+    // ─── Code Review ──────────────────────────────────────
+    {
+        name: "rigour_review",
+        description: "Perform a high-fidelity code review on a pull request diff. Analyzes changed files using all active quality gates.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                ...cwdParam(),
+                repository: { type: "string", description: "Full repository name (e.g., 'owner/repo')." },
+                branch: { type: "string", description: "The branch containing the changes." },
+                diff: { type: "string", description: "The git diff content to analyze." },
+                files: { type: "array", items: { type: "string" }, description: "List of filenames that were changed." },
+            },
+            required: ["cwd", "diff"],
+        },
+    },
+];

package/dist/tools/execution-handlers.d.ts

@@ -0,0 +1,11 @@
+import { GateRunner } from "@rigour-labs/core";
+type ToolResult = {
+    content: {
+        type: string;
+        text: string;
+    }[];
+    isError?: boolean;
+};
+export declare function handleRun(cwd: string, command: string, requestId: string): Promise<ToolResult>;
+export declare function handleRunSupervised(runner: GateRunner, cwd: string, command: string, maxRetries: number, dryRun: boolean, requestId: string): Promise<ToolResult>;
+export {};

package/dist/tools/execution-handlers.js

@@ -0,0 +1,134 @@
+/**
+ * Execution & Supervision Tool Handlers
+ *
+ * Handlers for: rigour_run, rigour_run_supervised
+ *
+ * @since v2.17.0 — extracted from monolithic index.ts
+ */
+import fs from "fs-extra";
+import path from "path";
+import { logStudioEvent } from '../utils/config.js';
+export async function handleRun(cwd, command, requestId) {
+    // 1. Log Interceptable Event
+    await logStudioEvent(cwd, {
+        type: "interception_requested",
+        requestId,
+        tool: "rigour_run",
+        command,
+    });
+    // 2. Poll for Human Arbitration (Max 60s wait)
+    console.error(`[RIGOUR] Waiting for human arbitration for command: ${command}`);
+    const decision = await pollArbitration(cwd, requestId, 60000);
+    if (decision === 'reject') {
+        return {
+            content: [{ type: "text", text: `❌ COMMAND REJECTED BY GOVERNOR: The execution of "${command}" was blocked by a human operator in the Governance Studio.` }],
+            isError: true,
+        };
+    }
+    // Execute
+    const { execa } = await import("execa");
+    try {
+        const { stdout, stderr } = await execa(command, { shell: true, cwd });
+        return {
+            content: [{ type: "text", text: `✅ COMMAND EXECUTED (Approved by Governor):\n\nSTDOUT:\n${stdout}\n\nSTDERR:\n${stderr}` }],
+        };
+    }
+    catch (e) {
+        return {
+            content: [{ type: "text", text: `❌ COMMAND FAILED:\n\n${e.message}` }],
+            isError: true,
+        };
+    }
+}
+export async function handleRunSupervised(runner, cwd, command, maxRetries, dryRun, requestId) {
+    const { execa } = await import("execa");
+    let iteration = 0;
+    let lastReport = null;
+    let result = null;
+    const iterations = [];
+    await logStudioEvent(cwd, {
+        type: "supervisor_started",
+        requestId,
+        command,
+        maxRetries,
+        dryRun,
+    });
+    while (iteration < maxRetries) {
+        iteration++;
+        if (!dryRun) {
+            try {
+                await execa(command, { shell: true, cwd });
+            }
+            catch (e) {
+                console.error(`[RIGOUR] Iteration ${iteration} command error: ${e.message}`);
+            }
+        }
+        else {
+            console.error(`[RIGOUR] Iteration ${iteration} (DRY RUN - skipping command execution)`);
+        }
+        lastReport = await runner.run(cwd);
+        iterations.push({ iteration, status: lastReport.status, failures: lastReport.failures.length });
+        await logStudioEvent(cwd, {
+            type: "supervisor_iteration",
+            requestId,
+            iteration,
+            status: lastReport.status,
+            failures: lastReport.failures.length,
+        });
+        if (lastReport.status === "PASS") {
+            result = {
+                content: [{
+                        type: "text",
+                        text: `✅ SUPERVISOR MODE: PASSED on iteration ${iteration}/${maxRetries}\n\nIterations:\n${iterations.map(i => `  ${i.iteration}. ${i.status} (${i.failures} failures)`).join("\n")}\n\nAll quality gates have been satisfied.`,
+                    }],
+            };
+            break;
+        }
+        if (iteration >= maxRetries) {
+            const fixPacket = lastReport.failures.map((f, i) => {
+                const sevTag = `[${(f.severity || 'medium').toUpperCase()}]`;
+                const provTag = f.provenance ? `(${f.provenance})` : '';
+                let text = `FIX TASK ${i + 1}: ${sevTag} ${provTag} [${f.id.toUpperCase()}] ${f.title}\n`;
+                text += `   - CONTEXT: ${f.details}\n`;
+                if (f.files && f.files.length > 0)
+                    text += `   - TARGET FILES: ${f.files.join(", ")}\n`;
+                if (f.hint)
+                    text += `   - REFACTORING GUIDANCE: ${f.hint}\n`;
+                return text;
+            }).join("\n---\n");
+            result = {
+                content: [{
+                        type: "text",
+                        text: `❌ SUPERVISOR MODE: FAILED after ${iteration} iterations\n\nIterations:\n${iterations.map(i => `  ${i.iteration}. ${i.status} (${i.failures} failures)`).join("\n")}\n\nFINAL FIX PACKET:\n${fixPacket}`,
+                    }],
+                isError: true,
+            };
+        }
+    }
+    await logStudioEvent(cwd, {
+        type: "supervisor_completed",
+        requestId,
+        finalStatus: lastReport?.status || "UNKNOWN",
+        totalIterations: iteration,
+    });
+    return result;
+}
+// ─── Private Helpers ──────────────────────────────────────────────
+async function pollArbitration(cwd, rid, timeout) {
+    const start = Date.now();
+    const eventsPath = path.join(cwd, '.rigour/events.jsonl');
+    while (Date.now() - start < timeout) {
+        if (await fs.pathExists(eventsPath)) {
+            const content = await fs.readFile(eventsPath, 'utf-8');
+            const lines = content.split('\n').filter(l => l.trim());
+            for (const line of lines.reverse()) {
+                const event = JSON.parse(line);
+                if (event.tool === 'human_arbitration' && event.requestId === rid) {
+                    return event.decision;
+                }
+            }
+        }
+        await new Promise(r => setTimeout(r, 1000));
+    }
+    return "approve"; // Default auto-approve if no human response
+}

package/dist/tools/memory-handlers.d.ts

@@ -0,0 +1,10 @@
+type ToolResult = {
+    content: {
+        type: string;
+        text: string;
+    }[];
+};
+export declare function handleRemember(cwd: string, key: string, value: string): Promise<ToolResult>;
+export declare function handleRecall(cwd: string, key?: string): Promise<ToolResult>;
+export declare function handleForget(cwd: string, key: string): Promise<ToolResult>;
+export {};

package/dist/tools/memory-handlers.js

@@ -0,0 +1,52 @@
+/**
+ * Memory Persistence Tool Handlers
+ *
+ * Handlers for: rigour_remember, rigour_recall, rigour_forget
+ *
+ * @since v2.17.0 — extracted from monolithic index.ts
+ */
+import { loadMemory, saveMemory } from '../utils/config.js';
+export async function handleRemember(cwd, key, value) {
+    const store = await loadMemory(cwd);
+    store.memories[key] = { value, timestamp: new Date().toISOString() };
+    await saveMemory(cwd, store);
+    return {
+        content: [{
+                type: "text",
+                text: `MEMORY STORED: "${key}" has been saved. This instruction will persist across sessions.\n\nStored value: ${value}`,
+            }],
+    };
+}
+export async function handleRecall(cwd, key) {
+    const store = await loadMemory(cwd);
+    if (key) {
+        const memory = store.memories[key];
+        if (!memory) {
+            return { content: [{ type: "text", text: `NO MEMORY FOUND for key "${key}". Use rigour_remember to store instructions.` }] };
+        }
+        return { content: [{ type: "text", text: `RECALLED MEMORY [${key}]:\n${memory.value}\n\n(Stored: ${memory.timestamp})` }] };
+    }
+    const keys = Object.keys(store.memories);
+    if (keys.length === 0) {
+        return { content: [{ type: "text", text: "NO MEMORIES STORED. Use rigour_remember to persist important instructions." }] };
+    }
+    const allMemories = keys.map(k => {
+        const mem = store.memories[k];
+        return `## ${k}\n${mem.value}\n(Stored: ${mem.timestamp})`;
+    }).join("\n\n---\n\n");
+    return {
+        content: [{
+                type: "text",
+                text: `RECALLED ALL MEMORIES (${keys.length} items):\n\n${allMemories}\n\n---\nIMPORTANT: Follow these stored instructions throughout this session.`,
+            }],
+    };
+}
+export async function handleForget(cwd, key) {
+    const store = await loadMemory(cwd);
+    if (!store.memories[key]) {
+        return { content: [{ type: "text", text: `NO MEMORY FOUND for key "${key}". Nothing to forget.` }] };
+    }
+    delete store.memories[key];
+    await saveMemory(cwd, store);
+    return { content: [{ type: "text", text: `MEMORY DELETED: "${key}" has been removed.` }] };
+}

package/dist/tools/pattern-handlers.d.ts

@@ -0,0 +1,9 @@
+type ToolResult = {
+    content: {
+        type: string;
+        text: string;
+    }[];
+};
+export declare function handleCheckPattern(cwd: string, patternName: string, type?: string, intent?: string): Promise<ToolResult>;
+export declare function handleSecurityAudit(cwd: string): Promise<ToolResult>;
+export {};

package/dist/tools/pattern-handlers.js

@@ -0,0 +1,72 @@
+/**
+ * Pattern Intelligence Tool Handlers
+ *
+ * Handlers for: rigour_check_pattern, rigour_security_audit
+ *
+ * @since v2.17.0 — extracted from monolithic index.ts
+ */
+import { PatternMatcher, loadPatternIndex, getDefaultIndexPath, StalenessDetector, SecurityDetector, } from "@rigour-labs/core/pattern-index";
+export async function handleCheckPattern(cwd, patternName, type, intent) {
+    const indexPath = getDefaultIndexPath(cwd);
+    const index = await loadPatternIndex(indexPath);
+    let resultText = "";
+    // 1. Check for Reinvention
+    if (index) {
+        const matcher = new PatternMatcher(index);
+        const matchResult = await matcher.match({ name: patternName, type, intent });
+        if (matchResult.status === "FOUND_SIMILAR") {
+            resultText += `🚨 PATTERN REINVENTION DETECTED\n`;
+            resultText += `Similar pattern already exists: "${matchResult.matches[0].pattern.name}" in ${matchResult.matches[0].pattern.file}\n`;
+            resultText += `SUGGESTION: ${matchResult.suggestion}\n\n`;
+        }
+    }
+    else {
+        resultText += `⚠️ Pattern index not found. Run 'rigour index' to enable reinvention detection.\n\n`;
+    }
+    // 2. Check for Staleness/Best Practices
+    const detector = new StalenessDetector(cwd);
+    const staleness = await detector.checkStaleness(`${type || 'function'} ${patternName} {}`);
+    if (staleness.status !== "FRESH") {
+        resultText += `⚠️ STALENESS/ANTI-PATTERN WARNING\n`;
+        for (const issue of staleness.issues) {
+            resultText += `- ${issue.reason}\n  REPLACEMENT: ${issue.replacement}\n`;
+        }
+        resultText += `\n`;
+    }
+    // 3. Check Security for this library (if it's an import)
+    if (intent && intent.includes('import')) {
+        const security = new SecurityDetector(cwd);
+        const audit = await security.runAudit();
+        const relatedVulns = audit.vulnerabilities.filter(v => patternName.toLowerCase().includes(v.packageName.toLowerCase()) ||
+            intent.toLowerCase().includes(v.packageName.toLowerCase()));
+        if (relatedVulns.length > 0) {
+            resultText += `🛡️ SECURITY/CVE WARNING\n`;
+            for (const v of relatedVulns) {
+                resultText += `- [${v.severity.toUpperCase()}] ${v.packageName}: ${v.title} (${v.url})\n`;
+            }
+            resultText += `\n`;
+        }
+    }
+    if (!resultText) {
+        resultText = `✅ Pattern "${patternName}" is fresh, secure, and unique to the codebase.\n\nRECOMMENDED ACTION: Proceed with implementation.`;
+    }
+    else {
+        let recommendation = "Proceed with caution, addressing the warnings above.";
+        if (resultText.includes("🚨 PATTERN REINVENTION")) {
+            recommendation = "STOP and REUSE the existing pattern mentioned above. Do not create a duplicate.";
+        }
+        else if (resultText.includes("🛡️ SECURITY/CVE WARNING")) {
+            recommendation = "STOP and update your dependencies or find an alternative library. Do not proceed with vulnerable code.";
+        }
+        else if (resultText.includes("⚠️ STALENESS")) {
+            recommendation = "Follow the replacement suggestion to ensure best practices.";
+        }
+        resultText += `\nRECOMMENDED ACTION: ${recommendation}`;
+    }
+    return { content: [{ type: "text", text: resultText }] };
+}
+export async function handleSecurityAudit(cwd) {
+    const security = new SecurityDetector(cwd);
+    const summary = await security.getSecuritySummary();
+    return { content: [{ type: "text", text: summary }] };
+}

package/dist/tools/quality-handlers.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Quality Gate Tool Handlers
+ *
+ * Handlers for: rigour_check, rigour_explain, rigour_status,
+ * rigour_get_fix_packet, rigour_list_gates, rigour_get_config
+ *
+ * @since v2.17.0 — extracted from monolithic index.ts
+ */
+import { GateRunner, Report } from "@rigour-labs/core";
+import type { Config } from "@rigour-labs/core";
+type ToolResult = {
+    content: {
+        type: string;
+        text: string;
+    }[];
+    isError?: boolean;
+    _rigour_report?: Report;
+};
+export declare function handleCheck(runner: GateRunner, cwd: string): Promise<ToolResult>;
+export declare function handleExplain(runner: GateRunner, cwd: string): Promise<ToolResult>;
+export declare function handleStatus(runner: GateRunner, cwd: string): Promise<ToolResult>;
+export declare function handleGetFixPacket(runner: GateRunner, cwd: string, config: Config): Promise<ToolResult>;
+export declare function handleListGates(config: Config): ToolResult;
+export declare function handleGetConfig(config: Config): ToolResult;
+export {};