@rigour-labs/mcp 2.17.2 → 2.18.0

package/dist/index.js

@@ -273,6 +273,32 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                     },
                     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: {
+                        cwd: {
+                            type: "string",
+                            description: "Absolute path to the project root.",
+                        },
+                        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"],
+                },
             }
         ],
     };
@@ -661,6 +687,93 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 }
                 break;
             }
+            case "rigour_run_supervised": {
+                const { command, maxRetries = 3, dryRun = false } = args;
+                const { execa } = await import("execa");
+                let iteration = 0;
+                let lastReport = null;
+                const iterations = [];
+                await logStudioEvent(cwd, {
+                    type: "supervisor_started",
+                    requestId,
+                    command,
+                    maxRetries,
+                    dryRun
+                });
+                while (iteration < maxRetries) {
+                    iteration++;
+                    // 1. Execute the agent command (skip in dryRun mode)
+                    if (!dryRun) {
+                        try {
+                            await execa(command, { shell: true, cwd });
+                        }
+                        catch (e) {
+                            // Command failure is OK - agent might have partial progress
+                            console.error(`[RIGOUR] Iteration ${iteration} command error: ${e.message}`);
+                        }
+                    }
+                    else {
+                        console.error(`[RIGOUR] Iteration ${iteration} (DRY RUN - skipping command execution)`);
+                    }
+                    // 2. Check quality gates
+                    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
+                    });
+                    // 3. If PASS, we're done
+                    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;
+                    }
+                    // 4. If not at max retries, continue the loop (agent will use fix packet next iteration)
+                    if (iteration >= maxRetries) {
+                        // Final failure - return fix packet
+                        const fixPacket = lastReport.failures.map((f, i) => {
+                            let text = `FIX TASK ${i + 1}: [${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
+                });
+                break;
+            }
             default:
                 throw new Error(`Unknown tool: ${name}`);
         }

package/dist/supervisor.test.d.ts

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

package/dist/supervisor.test.js

@@ -0,0 +1,128 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import fs from 'fs-extra';
+import path from 'path';
+import os from 'os';
+// Integration-style tests for rigour_run_supervised
+// These test the exported functionality indirectly since MCP server is complex to mock
+describe('rigour_run_supervised', () => {
+    let testDir;
+    beforeEach(async () => {
+        testDir = path.join(os.tmpdir(), `rigour-test-${Date.now()}`);
+        await fs.ensureDir(testDir);
+        // Create a minimal rigour.yml
+        await fs.writeFile(path.join(testDir, 'rigour.yml'), `
+version: 1
+preset: api
+gates:
+  max_file_lines: 500
+  forbid_todos: true
+  required_files: []
+ignore: []
+`);
+        // Create .rigour directory for events
+        await fs.ensureDir(path.join(testDir, '.rigour'));
+    });
+    afterEach(async () => {
+        await fs.remove(testDir);
+    });
+    it('should have correct tool schema', () => {
+        // Verify the tool schema includes all required fields
+        const expectedProperties = ['cwd', 'command', 'maxRetries', 'dryRun'];
+        const requiredProperties = ['cwd', 'command'];
+        // This is a schema validation test - in real MCP, the server validates this
+        expect(expectedProperties).toContain('dryRun');
+        expect(requiredProperties).not.toContain('dryRun'); // dryRun should be optional
+    });
+    it('should log supervisor_started event', async () => {
+        // Simulate what the handler does
+        const eventsPath = path.join(testDir, '.rigour', 'events.jsonl');
+        const event = {
+            id: 'test-id',
+            timestamp: new Date().toISOString(),
+            type: 'supervisor_started',
+            requestId: 'req-123',
+            command: 'echo "test"',
+            maxRetries: 3,
+            dryRun: true
+        };
+        await fs.appendFile(eventsPath, JSON.stringify(event) + '\n');
+        const content = await fs.readFile(eventsPath, 'utf-8');
+        const logged = JSON.parse(content.trim());
+        expect(logged.type).toBe('supervisor_started');
+        expect(logged.dryRun).toBe(true);
+        expect(logged.maxRetries).toBe(3);
+    });
+    it('should log supervisor_iteration events', async () => {
+        const eventsPath = path.join(testDir, '.rigour', 'events.jsonl');
+        // Simulate iteration logging
+        const iterations = [
+            { iteration: 1, status: 'FAIL', failures: 2 },
+            { iteration: 2, status: 'FAIL', failures: 1 },
+            { iteration: 3, status: 'PASS', failures: 0 },
+        ];
+        for (const iter of iterations) {
+            const event = {
+                id: `iter-${iter.iteration}`,
+                timestamp: new Date().toISOString(),
+                type: 'supervisor_iteration',
+                requestId: 'req-123',
+                ...iter
+            };
+            await fs.appendFile(eventsPath, JSON.stringify(event) + '\n');
+        }
+        const content = await fs.readFile(eventsPath, 'utf-8');
+        const lines = content.trim().split('\n').map(l => JSON.parse(l));
+        expect(lines.length).toBe(3);
+        expect(lines[0].iteration).toBe(1);
+        expect(lines[2].status).toBe('PASS');
+    });
+    it('should log supervisor_completed event with final status', async () => {
+        const eventsPath = path.join(testDir, '.rigour', 'events.jsonl');
+        const event = {
+            id: 'completed-1',
+            timestamp: new Date().toISOString(),
+            type: 'supervisor_completed',
+            requestId: 'req-123',
+            finalStatus: 'PASS',
+            totalIterations: 2
+        };
+        await fs.appendFile(eventsPath, JSON.stringify(event) + '\n');
+        const content = await fs.readFile(eventsPath, 'utf-8');
+        const logged = JSON.parse(content.trim());
+        expect(logged.type).toBe('supervisor_completed');
+        expect(logged.finalStatus).toBe('PASS');
+        expect(logged.totalIterations).toBe(2);
+    });
+    it('should track iteration history correctly', () => {
+        const iterations = [];
+        // Simulate the supervisor loop
+        iterations.push({ iteration: 1, status: 'FAIL', failures: 3 });
+        iterations.push({ iteration: 2, status: 'FAIL', failures: 1 });
+        iterations.push({ iteration: 3, status: 'PASS', failures: 0 });
+        const summary = iterations.map(i => `  ${i.iteration}. ${i.status} (${i.failures} failures)`).join('\n');
+        expect(summary).toContain('1. FAIL (3 failures)');
+        expect(summary).toContain('3. PASS (0 failures)');
+        expect(iterations.length).toBe(3);
+    });
+    it('should generate fix packet for failures', () => {
+        const failures = [
+            { id: 'max_lines', title: 'File too long', details: 'src/index.ts has 600 lines', files: ['src/index.ts'], hint: 'Split into modules' },
+            { id: 'forbid_todos', title: 'TODO found', details: 'Found TODO comment', files: ['src/utils.ts'] },
+        ];
+        const fixPacket = failures.map((f, i) => {
+            let text = `FIX TASK ${i + 1}: [${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');
+        expect(fixPacket).toContain('[MAX_LINES]');
+        expect(fixPacket).toContain('[FORBID_TODOS]');
+        expect(fixPacket).toContain('Split into modules');
+        expect(fixPacket).toContain('src/index.ts');
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rigour-labs/mcp",
-  "version": "2.17.2",
+  "version": "2.18.0",
   "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.",
@@ -20,7 +20,7 @@
     "execa": "^8.0.1",
     "fs-extra": "^11.2.0",
     "yaml": "^2.8.2",
-    "@rigour-labs/core": "2.17.2"
+    "@rigour-labs/core": "2.18.0"
   },
   "devDependencies": {
     "@types/node": "^25.0.3"

package/src/index.ts

@@ -299,6 +299,32 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                     },
                     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: {
+                        cwd: {
+                            type: "string",
+                            description: "Absolute path to the project root.",
+                        },
+                        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"],
+                },
             }
         ],
     };
@@ -716,6 +742,104 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 break;
             }
 
+            case "rigour_run_supervised": {
+                const { command, maxRetries = 3, dryRun = false } = args as any;
+                const { execa } = await import("execa");
+
+                let iteration = 0;
+                let lastReport: Report | null = null;
+                const iterations: { iteration: number; status: string; failures: number }[] = [];
+
+                await logStudioEvent(cwd, {
+                    type: "supervisor_started",
+                    requestId,
+                    command,
+                    maxRetries,
+                    dryRun
+                });
+
+                while (iteration < maxRetries) {
+                    iteration++;
+
+                    // 1. Execute the agent command (skip in dryRun mode)
+                    if (!dryRun) {
+                        try {
+                            await execa(command, { shell: true, cwd });
+                        } catch (e: any) {
+                            // Command failure is OK - agent might have partial progress
+                            console.error(`[RIGOUR] Iteration ${iteration} command error: ${e.message}`);
+                        }
+                    } else {
+                        console.error(`[RIGOUR] Iteration ${iteration} (DRY RUN - skipping command execution)`);
+                    }
+
+
+                    // 2. Check quality gates
+                    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
+                    });
+
+                    // 3. If PASS, we're done
+                    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;
+                    }
+
+                    // 4. If not at max retries, continue the loop (agent will use fix packet next iteration)
+                    if (iteration >= maxRetries) {
+                        // Final failure - return fix packet
+                        const fixPacket = lastReport.failures.map((f, i) => {
+                            let text = `FIX TASK ${i + 1}: [${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
+                });
+
+                break;
+            }
+
             default:
                 throw new Error(`Unknown tool: ${name}`);
         }

package/src/supervisor.test.ts

@@ -0,0 +1,158 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import fs from 'fs-extra';
+import path from 'path';
+import os from 'os';
+
+// Integration-style tests for rigour_run_supervised
+// These test the exported functionality indirectly since MCP server is complex to mock
+
+describe('rigour_run_supervised', () => {
+    let testDir: string;
+
+    beforeEach(async () => {
+        testDir = path.join(os.tmpdir(), `rigour-test-${Date.now()}`);
+        await fs.ensureDir(testDir);
+
+        // Create a minimal rigour.yml
+        await fs.writeFile(path.join(testDir, 'rigour.yml'), `
+version: 1
+preset: api
+gates:
+  max_file_lines: 500
+  forbid_todos: true
+  required_files: []
+ignore: []
+`);
+
+        // Create .rigour directory for events
+        await fs.ensureDir(path.join(testDir, '.rigour'));
+    });
+
+    afterEach(async () => {
+        await fs.remove(testDir);
+    });
+
+    it('should have correct tool schema', () => {
+        // Verify the tool schema includes all required fields
+        const expectedProperties = ['cwd', 'command', 'maxRetries', 'dryRun'];
+        const requiredProperties = ['cwd', 'command'];
+
+        // This is a schema validation test - in real MCP, the server validates this
+        expect(expectedProperties).toContain('dryRun');
+        expect(requiredProperties).not.toContain('dryRun'); // dryRun should be optional
+    });
+
+    it('should log supervisor_started event', async () => {
+        // Simulate what the handler does
+        const eventsPath = path.join(testDir, '.rigour', 'events.jsonl');
+
+        const event = {
+            id: 'test-id',
+            timestamp: new Date().toISOString(),
+            type: 'supervisor_started',
+            requestId: 'req-123',
+            command: 'echo "test"',
+            maxRetries: 3,
+            dryRun: true
+        };
+
+        await fs.appendFile(eventsPath, JSON.stringify(event) + '\n');
+
+        const content = await fs.readFile(eventsPath, 'utf-8');
+        const logged = JSON.parse(content.trim());
+
+        expect(logged.type).toBe('supervisor_started');
+        expect(logged.dryRun).toBe(true);
+        expect(logged.maxRetries).toBe(3);
+    });
+
+    it('should log supervisor_iteration events', async () => {
+        const eventsPath = path.join(testDir, '.rigour', 'events.jsonl');
+
+        // Simulate iteration logging
+        const iterations = [
+            { iteration: 1, status: 'FAIL', failures: 2 },
+            { iteration: 2, status: 'FAIL', failures: 1 },
+            { iteration: 3, status: 'PASS', failures: 0 },
+        ];
+
+        for (const iter of iterations) {
+            const event = {
+                id: `iter-${iter.iteration}`,
+                timestamp: new Date().toISOString(),
+                type: 'supervisor_iteration',
+                requestId: 'req-123',
+                ...iter
+            };
+            await fs.appendFile(eventsPath, JSON.stringify(event) + '\n');
+        }
+
+        const content = await fs.readFile(eventsPath, 'utf-8');
+        const lines = content.trim().split('\n').map(l => JSON.parse(l));
+
+        expect(lines.length).toBe(3);
+        expect(lines[0].iteration).toBe(1);
+        expect(lines[2].status).toBe('PASS');
+    });
+
+    it('should log supervisor_completed event with final status', async () => {
+        const eventsPath = path.join(testDir, '.rigour', 'events.jsonl');
+
+        const event = {
+            id: 'completed-1',
+            timestamp: new Date().toISOString(),
+            type: 'supervisor_completed',
+            requestId: 'req-123',
+            finalStatus: 'PASS',
+            totalIterations: 2
+        };
+
+        await fs.appendFile(eventsPath, JSON.stringify(event) + '\n');
+
+        const content = await fs.readFile(eventsPath, 'utf-8');
+        const logged = JSON.parse(content.trim());
+
+        expect(logged.type).toBe('supervisor_completed');
+        expect(logged.finalStatus).toBe('PASS');
+        expect(logged.totalIterations).toBe(2);
+    });
+
+    it('should track iteration history correctly', () => {
+        const iterations: { iteration: number; status: string; failures: number }[] = [];
+
+        // Simulate the supervisor loop
+        iterations.push({ iteration: 1, status: 'FAIL', failures: 3 });
+        iterations.push({ iteration: 2, status: 'FAIL', failures: 1 });
+        iterations.push({ iteration: 3, status: 'PASS', failures: 0 });
+
+        const summary = iterations.map(i => `  ${i.iteration}. ${i.status} (${i.failures} failures)`).join('\n');
+
+        expect(summary).toContain('1. FAIL (3 failures)');
+        expect(summary).toContain('3. PASS (0 failures)');
+        expect(iterations.length).toBe(3);
+    });
+
+    it('should generate fix packet for failures', () => {
+        const failures = [
+            { id: 'max_lines', title: 'File too long', details: 'src/index.ts has 600 lines', files: ['src/index.ts'], hint: 'Split into modules' },
+            { id: 'forbid_todos', title: 'TODO found', details: 'Found TODO comment', files: ['src/utils.ts'] },
+        ];
+
+        const fixPacket = failures.map((f, i) => {
+            let text = `FIX TASK ${i + 1}: [${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 as any).hint) {
+                text += `   - REFACTORING GUIDANCE: ${(f as any).hint}\n`;
+            }
+            return text;
+        }).join('\n---\n');
+
+        expect(fixPacket).toContain('[MAX_LINES]');
+        expect(fixPacket).toContain('[FORBID_TODOS]');
+        expect(fixPacket).toContain('Split into modules');
+        expect(fixPacket).toContain('src/index.ts');
+    });
+});