@rigour-labs/mcp 3.0.6 → 4.0.1

package/dist/index.js

@@ -24,6 +24,7 @@ import { handleRun, handleRunSupervised } from './tools/execution-handlers.js';
 import { handleAgentRegister, handleCheckpoint, handleHandoff, handleAgentDeregister, handleHandoffAccept } from './tools/agent-handlers.js';
 import { handleReview } from './tools/review-handler.js';
 import { handleHooksCheck, handleHooksInit } from './tools/hooks-handler.js';
+import { handleCheckDeep, handleDeepStats } from './tools/deep-handlers.js';
 // ─── Server Setup ─────────────────────────────────────────────────
 const server = new Server({ name: "rigour-mcp", version: "3.0.1" }, { capabilities: { tools: {}, prompts: {} } });
 // ─── Tool Listing ─────────────────────────────────────────────────
@@ -113,6 +114,15 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             case "rigour_hooks_init":
                 result = await handleHooksInit(cwd, args.tool, args.force, args.dryRun);
                 break;
+            // Deep analysis (v4.0+)
+            case "rigour_check_deep": {
+                const { pro, apiKey, provider, apiBaseUrl, modelName } = args;
+                result = await handleCheckDeep(runner, cwd, config, { pro, apiKey, provider, apiBaseUrl, modelName });
+                break;
+            }
+            case "rigour_deep_stats":
+                result = await handleDeepStats(cwd, args.limit);
+                break;
             // Code review
             case "rigour_review":
                 result = await handleReview(runner, cwd, args.diff, args.files);
@@ -222,6 +232,20 @@ server.setRequestHandler(GetPromptRequestSchema, async (request) => {
                 ],
             };
         }
+        case "rigour-deep-analysis": {
+            return {
+                description: prompt.description,
+                messages: [
+                    {
+                        role: "user",
+                        content: {
+                            type: "text",
+                            text: `Run \`rigour_check_deep\` on ${cwd} for a full deep code quality analysis. This uses the three-step pipeline: AST extracts facts → LLM interprets patterns → AST verifies findings. Report the AI Health score, Code Quality score, and Overall score. List all verified findings grouped by category (SOLID violations, code smells, architecture issues, test quality). For each finding, show the file, description, and suggestion. If any critical findings exist, prioritize them. End with concrete action items to improve the code quality score.`,
+                        },
+                    },
+                ],
+            };
+        }
         default:
             throw new Error(`Unknown prompt: ${name}`);
     }
@@ -230,7 +254,7 @@ server.setRequestHandler(GetPromptRequestSchema, async (request) => {
 async function main() {
     const transport = new StdioServerTransport();
     await server.connect(transport);
-    console.error("Rigour MCP server v3.0.0 running on stdio");
+    console.error("Rigour MCP server v4.0.0 running on stdio");
 }
 main().catch((error) => {
     console.error("Fatal error in Rigour MCP server:", error);

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

@@ -0,0 +1,25 @@
+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;
+};
+/**
+ * Run quality gates with deep LLM-powered analysis.
+ */
+export declare function handleCheckDeep(runner: GateRunner, cwd: string, config: Config, args: {
+    pro?: boolean;
+    apiKey?: string;
+    provider?: string;
+    apiBaseUrl?: string;
+    modelName?: string;
+}): Promise<ToolResult>;
+/**
+ * Get deep analysis statistics from SQLite storage.
+ */
+export declare function handleDeepStats(cwd: string, limit?: number): Promise<ToolResult>;
+export {};

package/dist/tools/deep-handlers.js

@@ -0,0 +1,140 @@
+/**
+ * Deep Analysis Tool Handlers
+ *
+ * Handlers for: rigour_check_deep, rigour_deep_stats
+ *
+ * @since v4.0.0
+ */
+import path from "path";
+/**
+ * Run quality gates with deep LLM-powered analysis.
+ */
+export async function handleCheckDeep(runner, cwd, config, args) {
+    const deepOpts = {
+        enabled: true,
+        pro: !!args.pro,
+        apiKey: args.apiKey,
+        provider: args.apiKey ? (args.provider || 'claude') : 'local',
+        apiBaseUrl: args.apiBaseUrl,
+        modelName: args.modelName,
+    };
+    const report = await runner.run(cwd, undefined, deepOpts);
+    // Persist to SQLite (best-effort)
+    try {
+        const { openDatabase, insertScan, insertFindings } = await import('@rigour-labs/core');
+        const db = openDatabase();
+        if (db) {
+            const repoName = path.basename(cwd);
+            const scanId = insertScan(db, repoName, report, {
+                deepTier: args.pro ? 'pro' : (args.apiKey ? 'cloud' : 'deep'),
+                deepModel: report.stats.deep?.model,
+            });
+            insertFindings(db, scanId, report.failures);
+            db.close();
+        }
+    }
+    catch {
+        // SQLite persistence is best-effort
+    }
+    // Format response
+    const stats = report.stats;
+    const aiHealth = stats.ai_health_score ?? 100;
+    const codeQuality = stats.code_quality_score ?? stats.structural_score ?? 100;
+    const overall = stats.score ?? 100;
+    const isLocal = !args.apiKey;
+    let text = `RIGOUR DEEP ANALYSIS: ${report.status}\n\n`;
+    text += `AI Health:     ${aiHealth}/100\n`;
+    text += `Code Quality:  ${codeQuality}/100\n`;
+    text += `Overall:       ${overall}/100\n\n`;
+    if (isLocal) {
+        text += `🔒 100% local. Code never left this machine.\n`;
+    }
+    else {
+        text += `☁️  Code was sent to ${args.provider || 'cloud'} API.\n`;
+    }
+    if (stats.deep) {
+        const tier = stats.deep.tier === 'cloud' ? (args.provider || 'cloud') : stats.deep.tier;
+        const model = stats.deep.model || 'unknown';
+        const inferenceSec = stats.deep.total_ms ? (stats.deep.total_ms / 1000).toFixed(1) + 's' : '';
+        text += `Model: ${model} (${tier}) ${inferenceSec}\n`;
+    }
+    if (report.failures.length > 0) {
+        text += `\n--- Findings (${report.failures.length}) ---\n\n`;
+        // Group by provenance
+        const grouped = {};
+        for (const f of report.failures) {
+            const prov = f.provenance || 'traditional';
+            if (!grouped[prov])
+                grouped[prov] = [];
+            grouped[prov].push(f);
+        }
+        for (const [prov, failures] of Object.entries(grouped)) {
+            text += `[${prov}] (${failures.length} issues)\n`;
+            for (const f of failures.slice(0, 10)) {
+                const sev = (f.severity || 'medium').toUpperCase();
+                const conf = f.confidence ? ` (${(f.confidence * 100).toFixed(0)}%)` : '';
+                text += `  ${sev}: ${f.title}${conf}\n`;
+                if (f.hint)
+                    text += `    → ${f.hint}\n`;
+            }
+            if (failures.length > 10) {
+                text += `  ... +${failures.length - 10} more\n`;
+            }
+            text += '\n';
+        }
+    }
+    text += `\nDuration: ${(stats.duration_ms / 1000).toFixed(1)}s`;
+    const result = {
+        content: [{ type: "text", text }],
+    };
+    result._rigour_report = report;
+    return result;
+}
+/**
+ * Get deep analysis statistics from SQLite storage.
+ */
+export async function handleDeepStats(cwd, limit = 10) {
+    try {
+        const { openDatabase, getRecentScans, getScoreTrendFromDB, getTopIssues } = await import('@rigour-labs/core');
+        const db = openDatabase();
+        if (!db) {
+            return {
+                content: [{ type: "text", text: "SQLite storage not available. Run `rigour check --deep` first to generate scan data." }],
+            };
+        }
+        const repoName = path.basename(cwd);
+        const scans = getRecentScans(db, repoName, limit);
+        const trend = getScoreTrendFromDB(db, repoName, limit);
+        const topIssues = getTopIssues(db, repoName, 10);
+        db.close();
+        if (scans.length === 0) {
+            return {
+                content: [{ type: "text", text: `No deep analysis scans found for "${repoName}". Run \`rigour check --deep\` first.` }],
+            };
+        }
+        let text = `DEEP ANALYSIS STATS for "${repoName}"\n\n`;
+        // Score trend
+        text += `Score Trend: ${trend.scores.join(' → ')} (${trend.direction})\n\n`;
+        // Recent scans
+        text += `Recent Scans (${scans.length}):\n`;
+        for (const scan of scans) {
+            const date = new Date(scan.timestamp).toISOString().split('T')[0];
+            const tier = scan.deep_tier || '?';
+            text += `  ${date} | Overall: ${scan.overall_score ?? '?'}/100 | AI: ${scan.ai_health_score ?? '?'}/100 | Quality: ${scan.code_quality_score ?? '?'}/100 | Tier: ${tier}\n`;
+        }
+        // Top issues
+        if (topIssues.length > 0) {
+            text += `\nTop Issue Categories:\n`;
+            for (const issue of topIssues) {
+                text += `  ${issue.category}: ${issue.count} occurrences\n`;
+            }
+        }
+        return { content: [{ type: "text", text }] };
+    }
+    catch (error) {
+        return {
+            content: [{ type: "text", text: `Error reading deep stats: ${error.message}` }],
+            isError: true,
+        };
+    }
+}

package/dist/tools/definitions.d.ts

@@ -407,6 +407,70 @@ export declare const TOOL_DEFINITIONS: ({
         idempotentHint: boolean;
         openWorldHint: boolean;
     };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            pro: {
+                type: string;
+                description: string;
+            };
+            apiKey: {
+                type: string;
+                description: string;
+            };
+            provider: {
+                type: string;
+                description: string;
+            };
+            apiBaseUrl: {
+                type: string;
+                description: string;
+            };
+            modelName: {
+                type: string;
+                description: string;
+            };
+            cwd: {
+                type: "string";
+                description: string;
+            };
+        };
+        required: string[];
+    };
+    annotations: {
+        title: string;
+        readOnlyHint: boolean;
+        destructiveHint: boolean;
+        idempotentHint: boolean;
+        openWorldHint: boolean;
+    };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            limit: {
+                type: string;
+                description: string;
+            };
+            cwd: {
+                type: "string";
+                description: string;
+            };
+        };
+        required: string[];
+    };
+    annotations: {
+        title: string;
+        readOnlyHint: boolean;
+        destructiveHint: boolean;
+        idempotentHint: boolean;
+        openWorldHint: boolean;
+    };
 } | {
     name: string;
     description: string;

package/dist/tools/definitions.js

@@ -407,6 +407,49 @@ export const TOOL_DEFINITIONS = [
             openWorldHint: false,
         },
     },
+    // ─── Deep Analysis (v4.0+) ──────────────────────────────
+    {
+        name: "rigour_check_deep",
+        description: "Run quality gates WITH deep LLM-powered analysis. Three-step pipeline: AST extracts facts → LLM interprets → AST verifies. Local-first by default (Qwen2.5-Coder), or bring your own API key for any cloud provider.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                ...cwdParam(),
+                pro: { type: "boolean", description: "Use the larger 1.5B model (--pro tier). Default: false (0.5B model)." },
+                apiKey: { type: "string", description: "API key for cloud LLM provider. If provided, uses cloud instead of local sidecar." },
+                provider: { type: "string", description: "Cloud provider name (e.g., 'claude', 'openai', 'gemini', 'groq', 'mistral', 'together', 'fireworks', 'deepseek', 'perplexity', 'ollama', 'lmstudio'). Default: 'claude' when apiKey is provided." },
+                apiBaseUrl: { type: "string", description: "Custom API base URL for self-hosted or proxy endpoints." },
+                modelName: { type: "string", description: "Override the default model name for the chosen provider." },
+            },
+            required: ["cwd"],
+        },
+        annotations: {
+            title: "Deep Analysis",
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
+    },
+    {
+        name: "rigour_deep_stats",
+        description: "Get deep analysis statistics from SQLite storage. Returns recent scan scores, top issues, and score trends for a repository.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                ...cwdParam(),
+                limit: { type: "number", description: "Number of recent scans to return (default: 10)." },
+            },
+            required: ["cwd"],
+        },
+        annotations: {
+            title: "Deep Analysis Stats",
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
+    },
     // ─── Code Review ──────────────────────────────────────
     {
         name: "rigour_review",

package/dist/tools/prompts.js

@@ -62,4 +62,15 @@ export const PROMPT_DEFINITIONS = [
             },
         ],
     },
+    {
+        name: "rigour-deep-analysis",
+        description: "Run deep LLM-powered code quality analysis. AST extracts facts, LLM interprets patterns (SOLID violations, code smells, architecture issues), AST verifies findings. 100% local by default.",
+        arguments: [
+            {
+                name: "cwd",
+                description: "Absolute path to the project root.",
+                required: false,
+            },
+        ],
+    },
 ];

package/dist/utils/config.d.ts

@@ -8,6 +8,29 @@ export declare function loadConfig(cwd: string): Promise<{
         test?: string | undefined;
     };
     gates: {
+        deep: {
+            enabled: boolean;
+            pro: boolean;
+            provider: string;
+            threads: number;
+            max_tokens: number;
+            temperature: number;
+            timeout_ms: number;
+            checks: {
+                architecture: boolean;
+                test_quality: boolean;
+                solid: boolean;
+                dry: boolean;
+                design_patterns: boolean;
+                language_idioms: boolean;
+                error_handling: boolean;
+                code_smells: boolean;
+            };
+            api_key?: string | undefined;
+            api_base_url?: string | undefined;
+            model_name?: string | undefined;
+            model_path?: string | undefined;
+        };
         max_file_lines: number;
         forbid_todos: boolean;
         forbid_fixme: boolean;
@@ -159,8 +182,8 @@ export declare function loadConfig(cwd: string): Promise<{
     hooks: {
         enabled: boolean;
         tools: ("claude" | "cursor" | "cline" | "windsurf")[];
-        fast_gates: string[];
         timeout_ms: number;
+        fast_gates: string[];
         block_on_failure: boolean;
     };
     output: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rigour-labs/mcp",
-  "version": "3.0.6",
+  "version": "4.0.1",
   "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": "3.0.6"
+    "@rigour-labs/core": "4.0.1"
   },
   "devDependencies": {
     "@types/node": "^25.0.3",