@rigour-labs/mcp 4.3.3 → 4.3.5

package/dist/index.js

@@ -102,7 +102,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 break;
             case "rigour_run_supervised": {
                 const { command, maxRetries = 3, dryRun = false } = args;
-                result = await handleRunSupervised(runner, cwd, command, maxRetries, dryRun, requestId);
+                result = await handleRunSupervised(runner, cwd, command, maxRetries, dryRun, requestId, config);
                 break;
             }
             // Multi-agent governance

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

@@ -1,4 +1,5 @@
 import { GateRunner } from "@rigour-labs/core";
+import type { Config } from "@rigour-labs/core";
 type ToolResult = {
     content: {
         type: string;
@@ -7,5 +8,5 @@ type ToolResult = {
     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 declare function handleRunSupervised(runner: GateRunner, cwd: string, command: string, maxRetries: number, dryRun: boolean, requestId: string, config?: Config): Promise<ToolResult>;
 export {};

package/dist/tools/execution-handlers.js

@@ -7,6 +7,7 @@
  */
 import fs from "fs-extra";
 import path from "path";
+import { FixPacketService } from "@rigour-labs/core";
 import { logStudioEvent } from '../utils/config.js';
 export async function handleRun(cwd, command, requestId) {
     // 1. Log Interceptable Event
@@ -40,7 +41,7 @@ export async function handleRun(cwd, command, requestId) {
         };
     }
 }
-export async function handleRunSupervised(runner, cwd, command, maxRetries, dryRun, requestId) {
+export async function handleRunSupervised(runner, cwd, command, maxRetries, dryRun, requestId, config) {
     const { execa } = await import("execa");
     let iteration = 0;
     let lastReport = null;
@@ -67,39 +68,50 @@ export async function handleRunSupervised(runner, cwd, command, maxRetries, dryR
             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 });
+        const failedGateIds = [...new Set(lastReport.failures.map(f => f.id))];
+        iterations.push({
+            iteration,
+            status: lastReport.status,
+            failures: lastReport.failures.length,
+            failedGates: failedGateIds,
+        });
         await logStudioEvent(cwd, {
             type: "supervisor_iteration",
             requestId,
             iteration,
             status: lastReport.status,
             failures: lastReport.failures.length,
+            failedGates: failedGateIds,
         });
         if (lastReport.status === "PASS") {
+            const score = lastReport.stats.score !== undefined ? ` | Score: ${lastReport.stats.score}/100` : '';
             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.`,
+                        text: `✅ SUPERVISOR MODE: PASSED on iteration ${iteration}/${maxRetries}${score}\n\nIterations:\n${formatIterationHistory(iterations)}\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");
+            // Use FixPacketService for structured output instead of ad-hoc formatting
+            let fixPacketText;
+            if (config) {
+                const fixPacketService = new FixPacketService();
+                const fixPacket = fixPacketService.generate(lastReport, config);
+                fixPacketText = formatFixPacketForSupervisor(fixPacket);
+            }
+            else {
+                // Fallback if config not available
+                fixPacketText = lastReport.failures.map((f, i) => {
+                    const sevTag = `[${(f.severity || 'medium').toUpperCase()}]`;
+                    return `${i + 1}. ${sevTag} [${f.id}] ${f.title}: ${f.details}${f.files?.length ? ` (${f.files.join(', ')})` : ''}`;
+                }).join('\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}`,
+                        text: `❌ SUPERVISOR MODE: FAILED after ${iteration} iterations\n\nIterations:\n${formatIterationHistory(iterations)}\n\n${fixPacketText}`,
                     }],
                 isError: true,
             };
@@ -113,6 +125,44 @@ export async function handleRunSupervised(runner, cwd, command, maxRetries, dryR
     });
     return result;
 }
+function formatIterationHistory(iterations) {
+    return iterations.map(i => {
+        const gates = i.failedGates.length > 0 ? ` [${i.failedGates.join(', ')}]` : '';
+        return `  ${i.iteration}. ${i.status} (${i.failures} failures)${gates}`;
+    }).join('\n');
+}
+function formatFixPacketForSupervisor(fixPacket) {
+    const lines = [];
+    lines.push(`FINAL FIX PACKET (${fixPacket.violations.length} violations across gates: ${fixPacket.failed_gates.join(', ')})`);
+    lines.push('');
+    fixPacket.violations.forEach((v, i) => {
+        const sevTag = `[${(v.severity || 'medium').toUpperCase()}]`;
+        lines.push(`${i + 1}. ${sevTag} [${v.id}] ${v.title}`);
+        lines.push(`   PROBLEM: ${v.details}`);
+        if (v.locations?.length > 0) {
+            const locs = v.locations.map((l) => l.line ? `${l.file}:${l.line}` : l.file);
+            lines.push(`   WHERE: ${locs.join(', ')}`);
+        }
+        else if (v.files?.length > 0) {
+            lines.push(`   FILES: ${v.files.join(', ')}`);
+        }
+        if (v.instructions?.length > 0) {
+            lines.push(`   FIX: ${v.instructions[0]}`);
+        }
+    });
+    if (fixPacket.verification?.commands?.length > 0) {
+        lines.push('');
+        lines.push('VERIFICATION COMMANDS (run after fixing):');
+        fixPacket.verification.commands.forEach((c) => {
+            lines.push(`  $ ${c.cmd}  — ${c.purpose}`);
+        });
+    }
+    if (fixPacket.constraints?.allowed_scope?.length > 0) {
+        lines.push('');
+        lines.push(`ALLOWED SCOPE: ${fixPacket.constraints.allowed_scope.join(', ')}`);
+    }
+    return lines.join('\n');
+}
 // ─── Private Helpers ──────────────────────────────────────────────
 async function pollArbitration(cwd, rid, timeout) {
     const start = Date.now();

package/dist/tools/quality-handlers.js

@@ -108,27 +108,92 @@ export async function handleGetFixPacket(runner, cwd, config) {
     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}`,
-            }],
+        content: [{ type: "text", text: formatFixPacketText(fixPacket, report) }],
     };
 }
+/**
+ * Formats a FixPacketV2 into a structured, agent-readable text block.
+ * Every violation includes: who failed, which files, what rule, where (line numbers),
+ * and what commands must pass after fixing.
+ */
+function formatFixPacketText(fixPacket, report) {
+    const lines = [];
+    // Header
+    let scoreHeader = formatScoreText(report.stats).trim();
+    lines.push('ENGINEERING REFINEMENT REQUIRED');
+    if (scoreHeader)
+        lines.push(scoreHeader);
+    lines.push(`Violations: ${report.failures.length} | Failed gates: ${fixPacket.failed_gates.join(', ')}`);
+    lines.push('');
+    // Violations
+    fixPacket.violations.forEach((v, i) => {
+        const sevTag = `[${(v.severity || 'medium').toUpperCase()}]`;
+        const catTag = v.category ? ` (${v.category})` : '';
+        lines.push(`━━━ FIX ${i + 1}/${fixPacket.violations.length}: ${sevTag}${catTag} ${v.title} ━━━`);
+        lines.push(`GATE: ${v.id}`);
+        lines.push(`PROBLEM: ${v.details}`);
+        // Locations with line numbers (precise targeting)
+        if (v.locations && v.locations.length > 0) {
+            const locStrs = v.locations.map((loc) => {
+                let s = loc.file;
+                if (loc.line)
+                    s += `:${loc.line}`;
+                if (loc.endLine && loc.endLine !== loc.line)
+                    s += `-${loc.endLine}`;
+                return s;
+            });
+            lines.push(`WHERE: ${locStrs.join(', ')}`);
+        }
+        else if (v.files && v.files.length > 0) {
+            lines.push(`FILES: ${v.files.join(', ')}`);
+        }
+        // Metrics (thresholds vs actuals)
+        if (v.metrics && Object.keys(v.metrics).length > 0) {
+            const metricStrs = Object.entries(v.metrics).map(([k, val]) => `${k}=${val}`);
+            lines.push(`METRICS: ${metricStrs.join(', ')}`);
+        }
+        // Instructions
+        if (v.instructions && v.instructions.length > 0) {
+            lines.push(`FIX:`);
+            v.instructions.forEach((inst, j) => {
+                lines.push(`  ${j + 1}. ${inst}`);
+            });
+        }
+        else if (v.hint) {
+            lines.push(`HINT: ${v.hint}`);
+        }
+        lines.push('');
+    });
+    // Verification commands
+    if (fixPacket.verification?.commands?.length > 0) {
+        lines.push('━━━ VERIFICATION (run these after fixing) ━━━');
+        fixPacket.verification.commands.forEach((c) => {
+            lines.push(`  $ ${c.cmd}  — ${c.purpose}`);
+        });
+        lines.push('');
+    }
+    // Constraints
+    const c = fixPacket.constraints;
+    if (c) {
+        const constraintParts = [];
+        if (c.allowed_scope?.length > 0)
+            constraintParts.push(`ALLOWED SCOPE: ${c.allowed_scope.join(', ')}`);
+        if (c.do_not_touch?.length > 0)
+            constraintParts.push(`DO NOT TOUCH: ${c.do_not_touch.join(', ')}`);
+        if (c.max_files_changed)
+            constraintParts.push(`MAX FILES CHANGED: ${c.max_files_changed}`);
+        if (c.no_new_deps)
+            constraintParts.push('NO NEW DEPENDENCIES');
+        if (c.paradigm)
+            constraintParts.push(`PARADIGM: ${c.paradigm}`);
+        if (constraintParts.length > 0) {
+            lines.push('━━━ CONSTRAINTS ━━━');
+            constraintParts.forEach(p => lines.push(`  ${p}`));
+        }
+    }
+    return lines.join('\n');
+}
 export function handleListGates(config) {
     return {
         content: [{

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rigour-labs/mcp",
-  "version": "4.3.3",
+  "version": "4.3.5",
   "description": "MCP server for AI code governance — OWASP LLM Top 10 (10/10), real-time hooks, 25+ security patterns, hallucinated import detection, multi-agent governance. Works with Claude, Cursor, Cline, Windsurf, Gemini. Industry presets for HIPAA, SOC2, FedRAMP.",
   "license": "MIT",
   "homepage": "https://rigour.run",
@@ -48,7 +48,7 @@
     "execa": "^8.0.1",
     "fs-extra": "^11.2.0",
     "yaml": "^2.8.2",
-    "@rigour-labs/core": "4.3.3"
+    "@rigour-labs/core": "4.3.5"
   },
   "devDependencies": {
     "@types/node": "^25.0.3",