@rigour-labs/mcp 2.9.3 → 2.10.0

package/README.md

@@ -0,0 +1,72 @@
+# 🛡️ Rigour MCP Server
+
+**The Quality Gate for AI-Assisted Engineering.**
+
+Rigour is a local-first Model Context Protocol (MCP) server that forces AI agents (Claude, Cursor, Windsurf, etc.) to meet strict engineering standards before marking tasks as complete.
+
+[![Registry](https://img.shields.io/badge/MCP-Registry-brightgreen)](https://github.com/mcp)
+[![npm version](https://img.shields.io/npm/v/@rigour-labs/mcp?color=cyan)](https://www.npmjs.com/package/@rigour-labs/mcp)
+
+---
+
+## 🚀 Overview
+
+Rigour moves code quality enforcement from the "Post-Commit" phase to the "In-Progress" phase. By running as an MCP server inside your editor, it provides the AI with a deterministic PASS/FAIL loop, preventing "Vibe Coding" and broken builds.
+
+### Key Features:
+- **Quality Gates**: Deterministic checks for file size, complexity, and hygiene.
+- **Context Memory**: Persistent memory that tracks project rules and patterns across sessions.
+- **Pattern Reinvention Blocking**: Warns or blocks the AI when it tries to rewrite existing utilities.
+- **Security Audits**: Real-time CVE detection for dependencies the AI is suggesting.
+- **Zero Cloud**: 100% local analysis. Your code never leaves your machine.
+
+---
+
+## 🛠️ Available Tools
+
+| Tool | Description |
+|:---|:---|
+| `rigour_check` | Runs all configured quality gates on the current workspace. |
+| `rigour_explain` | Explains why a specific gate failed and provides actionable fix instructions. |
+| `rigour_check_pattern` | Checks if a proposed code pattern already exists in the codebase. |
+| `rigour_remember` | Stores project-specific context or rules in Rigour's persistent memory. |
+| `rigour_recall` | Retrieves stored context to guide AI generation. |
+
+---
+
+## 📦 Installation
+
+### 1. Install via npm
+```bash
+npm install -g @rigour-labs/mcp
+```
+
+### 2. Configure your IDE
+
+#### Cursor / Claude Desktop
+Add the following to your MCP settings:
+```json
+{
+  "mcpServers": {
+    "rigour": {
+      "command": "npx",
+      "args": ["-y", "@rigour-labs/mcp"],
+      "env": {
+        "RIGOUR_CWD": "/path/to/your/project"
+      }
+    }
+  }
+}
+```
+
+---
+
+## 📖 Documentation
+
+For full configuration and advanced usage, visit **[docs.rigour.run](https://docs.rigour.run)**.
+
+---
+
+## 📜 License
+
+MIT © [Rigour Labs](https://github.com/rigour-labs)

package/dist/index.js

@@ -11,6 +11,7 @@ const fs_extra_1 = __importDefault(require("fs-extra"));
 const path_1 = __importDefault(require("path"));
 const yaml_1 = __importDefault(require("yaml"));
 const core_1 = require("@rigour-labs/core");
+const pattern_index_1 = require("@rigour-labs/core/pattern-index");
 const server = new index_js_1.Server({
     name: "rigour-mcp",
     version: "1.0.0",
@@ -189,6 +190,46 @@ server.setRequestHandler(types_js_1.ListToolsRequestSchema, async () => {
                     required: ["cwd", "key"],
                 },
             },
+            {
+                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: {
+                        cwd: {
+                            type: "string",
+                            description: "Absolute path to the project root.",
+                        },
+                        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: {
+                        cwd: {
+                            type: "string",
+                            description: "Absolute path to the project root.",
+                        },
+                    },
+                    required: ["cwd"],
+                },
+            },
         ],
     };
 });
@@ -394,6 +435,85 @@ server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
                     ],
                 };
             }
+            case "rigour_check_pattern": {
+                const { name: patternName, type, intent } = args;
+                const indexPath = (0, pattern_index_1.getDefaultIndexPath)(cwd);
+                const index = await (0, pattern_index_1.loadPatternIndex)(indexPath);
+                let resultText = "";
+                // 1. Check for Reinvention
+                if (index) {
+                    const matcher = new pattern_index_1.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 pattern_index_1.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 pattern_index_1.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,
+                        },
+                    ],
+                };
+            }
+            case "rigour_security_audit": {
+                const security = new pattern_index_1.SecurityDetector(cwd);
+                const summary = await security.getSecuritySummary();
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: summary,
+                        },
+                    ],
+                };
+            }
             default:
                 throw new Error(`Unknown tool: ${name}`);
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rigour-labs/mcp",
-  "version": "2.9.3",
+  "version": "2.10.0",
   "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.",
   "bin": {
@@ -18,7 +18,7 @@
     "@modelcontextprotocol/sdk": "^1.25.2",
     "fs-extra": "^11.2.0",
     "yaml": "^2.8.2",
-    "@rigour-labs/core": "2.9.3"
+    "@rigour-labs/core": "2.10.0"
   },
   "devDependencies": {
     "@types/node": "^25.0.3"

package/server.json

@@ -6,12 +6,12 @@
         "url": "https://github.com/rigour-labs/rigour",
         "source": "github"
     },
-    "version": "1.0.0",
+    "version": "2.9.3",
     "packages": [
         {
             "registryType": "npm",
             "identifier": "@rigour-labs/mcp",
-            "version": "1.0.0",
+            "version": "2.9.3",
             "transport": {
                 "type": "stdio"
             },

package/src/index.ts

@@ -8,7 +8,18 @@ import {
 import fs from "fs-extra";
 import path from "path";
 import yaml from "yaml";
-import { GateRunner, ConfigSchema, Report } from "@rigour-labs/core";
+import {
+    GateRunner,
+    ConfigSchema,
+    Report,
+} from "@rigour-labs/core";
+import {
+    PatternMatcher,
+    loadPatternIndex,
+    getDefaultIndexPath,
+    StalenessDetector,
+    SecurityDetector
+} from "@rigour-labs/core/pattern-index";
 
 const server = new Server(
     {
@@ -201,6 +212,46 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                     required: ["cwd", "key"],
                 },
             },
+            {
+                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: {
+                        cwd: {
+                            type: "string",
+                            description: "Absolute path to the project root.",
+                        },
+                        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: {
+                        cwd: {
+                            type: "string",
+                            description: "Absolute path to the project root.",
+                        },
+                    },
+                    required: ["cwd"],
+                },
+            },
         ],
     };
 });
@@ -429,6 +480,95 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 };
             }
 
+            case "rigour_check_pattern": {
+                const { name: patternName, type, intent } = args as any;
+                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,
+                        },
+                    ],
+                };
+            }
+
+            case "rigour_security_audit": {
+                const security = new SecurityDetector(cwd);
+                const summary = await security.getSecuritySummary();
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: summary,
+                        },
+                    ],
+                };
+            }
+
             default:
                 throw new Error(`Unknown tool: ${name}`);
         }