@rigour-labs/mcp 2.17.2 → 2.18.1

package/dist/index.test.js

@@ -0,0 +1,254 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import * as fs from 'fs-extra';
+import * as path from 'path';
+import * as os from 'os';
+// Mock the MCP tool handlers for testing
+// In a real scenario, we'd refactor index.ts to export testable functions
+describe('MCP Frontier Tools', () => {
+    let testDir;
+    let rigourDir;
+    beforeEach(async () => {
+        testDir = fs.mkdtempSync(path.join(os.tmpdir(), 'mcp-test-'));
+        rigourDir = path.join(testDir, '.rigour');
+        await fs.ensureDir(rigourDir);
+    });
+    afterEach(async () => {
+        await fs.remove(testDir);
+    });
+    describe('rigour_agent_register', () => {
+        const sessionPath = () => path.join(rigourDir, 'agent-session.json');
+        async function registerAgent(agentId, taskScope) {
+            let session = { agents: [], startedAt: new Date().toISOString() };
+            if (await fs.pathExists(sessionPath())) {
+                session = JSON.parse(await fs.readFile(sessionPath(), 'utf-8'));
+            }
+            const existingIdx = session.agents.findIndex((a) => a.agentId === agentId);
+            if (existingIdx >= 0) {
+                session.agents[existingIdx] = {
+                    agentId,
+                    taskScope,
+                    registeredAt: session.agents[existingIdx].registeredAt,
+                    lastCheckpoint: new Date().toISOString(),
+                };
+            }
+            else {
+                session.agents.push({
+                    agentId,
+                    taskScope,
+                    registeredAt: new Date().toISOString(),
+                    lastCheckpoint: new Date().toISOString(),
+                });
+            }
+            // Check for scope conflicts
+            const conflicts = [];
+            for (const agent of session.agents) {
+                if (agent.agentId !== agentId) {
+                    for (const scope of taskScope) {
+                        if (agent.taskScope.includes(scope)) {
+                            conflicts.push(`${agent.agentId} also claims "${scope}"`);
+                        }
+                    }
+                }
+            }
+            await fs.writeFile(sessionPath(), JSON.stringify(session, null, 2));
+            return { session, conflicts };
+        }
+        it('should register a new agent', async () => {
+            const { session, conflicts } = await registerAgent('agent-a', ['src/api/**']);
+            expect(session.agents).toHaveLength(1);
+            expect(session.agents[0].agentId).toBe('agent-a');
+            expect(conflicts).toHaveLength(0);
+        });
+        it('should detect scope conflicts', async () => {
+            await registerAgent('agent-a', ['src/api/**', 'src/utils/**']);
+            const { conflicts } = await registerAgent('agent-b', ['src/api/**']);
+            expect(conflicts).toHaveLength(1);
+            expect(conflicts[0]).toContain('agent-a');
+        });
+        it('should update existing agent registration', async () => {
+            await registerAgent('agent-a', ['src/api/**']);
+            const { session } = await registerAgent('agent-a', ['src/api/**', 'tests/**']);
+            expect(session.agents).toHaveLength(1);
+            expect(session.agents[0].taskScope).toContain('tests/**');
+        });
+        it('should support multiple agents', async () => {
+            await registerAgent('agent-a', ['src/frontend/**']);
+            await registerAgent('agent-b', ['src/backend/**']);
+            const { session } = await registerAgent('agent-c', ['src/shared/**']);
+            expect(session.agents).toHaveLength(3);
+        });
+    });
+    describe('rigour_checkpoint', () => {
+        const checkpointPath = () => path.join(rigourDir, 'checkpoint-session.json');
+        async function recordCheckpoint(progressPct, qualityScore, summary = 'Test') {
+            let session = {
+                sessionId: `chk-session-${Date.now()}`,
+                startedAt: new Date().toISOString(),
+                checkpoints: [],
+                status: 'active'
+            };
+            if (await fs.pathExists(checkpointPath())) {
+                session = JSON.parse(await fs.readFile(checkpointPath(), 'utf-8'));
+            }
+            const warnings = [];
+            if (qualityScore < 80) {
+                warnings.push(`Quality score ${qualityScore}% is below threshold 80%`);
+            }
+            // Drift detection
+            if (session.checkpoints.length >= 2) {
+                const recentScores = session.checkpoints.slice(-3).map((cp) => cp.qualityScore);
+                const avgRecent = recentScores.reduce((a, b) => a + b, 0) / recentScores.length;
+                if (qualityScore < avgRecent - 10) {
+                    warnings.push(`Drift detected: quality dropped from avg ${avgRecent.toFixed(0)}% to ${qualityScore}%`);
+                }
+            }
+            const checkpoint = {
+                checkpointId: `cp-${Date.now()}`,
+                timestamp: new Date().toISOString(),
+                progressPct,
+                summary,
+                qualityScore,
+                warnings,
+            };
+            session.checkpoints.push(checkpoint);
+            await fs.writeFile(checkpointPath(), JSON.stringify(session, null, 2));
+            return { checkpoint, warnings, session };
+        }
+        it('should record a checkpoint', async () => {
+            const { checkpoint, session } = await recordCheckpoint(25, 85, 'Initial work');
+            expect(checkpoint.progressPct).toBe(25);
+            expect(checkpoint.qualityScore).toBe(85);
+            expect(session.checkpoints).toHaveLength(1);
+        });
+        it('should warn on low quality score', async () => {
+            const { warnings } = await recordCheckpoint(50, 65, 'Struggling');
+            expect(warnings.some(w => w.includes('below threshold'))).toBe(true);
+        });
+        it('should detect quality drift', async () => {
+            await recordCheckpoint(20, 90);
+            await recordCheckpoint(40, 88);
+            await recordCheckpoint(60, 85);
+            const { warnings } = await recordCheckpoint(80, 70);
+            expect(warnings.some(w => w.includes('Drift detected'))).toBe(true);
+        });
+        it('should track multiple checkpoints', async () => {
+            await recordCheckpoint(25, 90);
+            await recordCheckpoint(50, 88);
+            await recordCheckpoint(75, 92);
+            const { session } = await recordCheckpoint(100, 95);
+            expect(session.checkpoints).toHaveLength(4);
+        });
+    });
+    describe('rigour_handoff', () => {
+        const handoffPath = () => path.join(rigourDir, 'handoffs.jsonl');
+        async function createHandoff(fromAgentId, toAgentId, taskDescription, filesInScope = []) {
+            const handoff = {
+                handoffId: `handoff-${Date.now()}`,
+                timestamp: new Date().toISOString(),
+                fromAgentId,
+                toAgentId,
+                taskDescription,
+                filesInScope,
+                status: 'pending',
+            };
+            await fs.appendFile(handoffPath(), JSON.stringify(handoff) + '\n');
+            return handoff;
+        }
+        it('should create a handoff record', async () => {
+            const handoff = await createHandoff('agent-a', 'agent-b', 'Complete API integration');
+            expect(handoff.fromAgentId).toBe('agent-a');
+            expect(handoff.toAgentId).toBe('agent-b');
+            expect(handoff.status).toBe('pending');
+        });
+        it('should include files in scope', async () => {
+            const handoff = await createHandoff('agent-a', 'agent-b', 'Fix tests', ['tests/api.test.ts', 'tests/utils.test.ts']);
+            expect(handoff.filesInScope).toHaveLength(2);
+        });
+        it('should append multiple handoffs', async () => {
+            await createHandoff('agent-a', 'agent-b', 'Task 1');
+            await createHandoff('agent-b', 'agent-c', 'Task 2');
+            const content = await fs.readFile(handoffPath(), 'utf-8');
+            const lines = content.trim().split('\n');
+            expect(lines).toHaveLength(2);
+        });
+    });
+    describe('rigour_agent_deregister', () => {
+        const sessionPath = () => path.join(rigourDir, 'agent-session.json');
+        async function deregisterAgent(agentId) {
+            if (!await fs.pathExists(sessionPath())) {
+                return { success: false, message: 'No active session' };
+            }
+            const session = JSON.parse(await fs.readFile(sessionPath(), 'utf-8'));
+            const initialCount = session.agents.length;
+            session.agents = session.agents.filter((a) => a.agentId !== agentId);
+            await fs.writeFile(sessionPath(), JSON.stringify(session, null, 2));
+            return {
+                success: session.agents.length < initialCount,
+                remainingAgents: session.agents.length,
+            };
+        }
+        it('should remove an agent from session', async () => {
+            // First register
+            const session = { agents: [{ agentId: 'agent-a', taskScope: [] }], startedAt: new Date().toISOString() };
+            await fs.writeFile(sessionPath(), JSON.stringify(session));
+            const result = await deregisterAgent('agent-a');
+            expect(result.success).toBe(true);
+            expect(result.remainingAgents).toBe(0);
+        });
+        it('should handle non-existent agent', async () => {
+            const session = { agents: [{ agentId: 'agent-a', taskScope: [] }], startedAt: new Date().toISOString() };
+            await fs.writeFile(sessionPath(), JSON.stringify(session));
+            const result = await deregisterAgent('agent-b');
+            expect(result.success).toBe(false);
+        });
+    });
+    describe('rigour_handoff_accept', () => {
+        const handoffPath = () => path.join(rigourDir, 'handoffs.jsonl');
+        async function acceptHandoff(handoffId, agentId) {
+            if (!await fs.pathExists(handoffPath())) {
+                return { success: false, message: 'No handoffs found' };
+            }
+            const content = await fs.readFile(handoffPath(), 'utf-8');
+            const handoffs = content.trim().split('\n').map(line => JSON.parse(line));
+            const handoff = handoffs.find(h => h.handoffId === handoffId);
+            if (!handoff) {
+                return { success: false, message: 'Handoff not found' };
+            }
+            if (handoff.toAgentId !== agentId) {
+                return { success: false, message: 'Agent not the intended recipient' };
+            }
+            handoff.status = 'accepted';
+            handoff.acceptedAt = new Date().toISOString();
+            // Rewrite the file with updated handoff
+            const updatedContent = handoffs.map(h => JSON.stringify(h)).join('\n') + '\n';
+            await fs.writeFile(handoffPath(), updatedContent);
+            return { success: true, handoff };
+        }
+        it('should accept a pending handoff', async () => {
+            const handoff = {
+                handoffId: 'handoff-123',
+                fromAgentId: 'agent-a',
+                toAgentId: 'agent-b',
+                taskDescription: 'Test task',
+                status: 'pending',
+            };
+            await fs.writeFile(handoffPath(), JSON.stringify(handoff) + '\n');
+            const result = await acceptHandoff('handoff-123', 'agent-b');
+            expect(result.success).toBe(true);
+            expect(result.handoff?.status).toBe('accepted');
+        });
+        it('should reject if agent is not recipient', async () => {
+            const handoff = {
+                handoffId: 'handoff-123',
+                fromAgentId: 'agent-a',
+                toAgentId: 'agent-b',
+                taskDescription: 'Test task',
+                status: 'pending',
+            };
+            await fs.writeFile(handoffPath(), JSON.stringify(handoff) + '\n');
+            const result = await acceptHandoff('handoff-123', 'agent-c');
+            expect(result.success).toBe(false);
+            expect(result.message).toContain('not the intended recipient');
+        });
+    });
+});

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.1",
   "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,10 +20,11 @@
     "execa": "^8.0.1",
     "fs-extra": "^11.2.0",
     "yaml": "^2.8.2",
-    "@rigour-labs/core": "2.17.2"
+    "@rigour-labs/core": "2.18.1"
   },
   "devDependencies": {
-    "@types/node": "^25.0.3"
+    "@types/node": "^25.0.3",
+    "vitest": "^1.0.0"
   },
   "scripts": {
     "build": "tsc",