@rigour-labs/mcp 3.0.1 → 3.0.3

package/README.md

@@ -14,12 +14,16 @@ Rigour is a local-first Model Context Protocol (MCP) server that forces AI agent
 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, hygiene, and AI-native drift detection.
-- **Multi-Language**: Gates support TypeScript, JavaScript, Python, Go, Ruby, and C#/.NET.
+- **Quality Gates**: 23 deterministic checks for file size, complexity, hygiene, security, and AI-native drift detection.
+- **8-Language Support**: JS/TS, Python, Go, Ruby, C#/.NET, Rust, Java, and Kotlin — with stdlib whitelists, dependency manifest parsing, and project-relative import resolution.
+- **Real-Time Hooks**: Sub-200ms file-write hooks for Claude Code, Cursor, Cline, and Windsurf — catches issues as the AI writes, not after CI.
+- **OWASP LLM Top 10**: Strong coverage on all 10 risks from the OWASP Top 10 for LLM-Generated Code, with 25+ security patterns.
 - **Two-Score System**: Separate AI Health Score and Structural Score with provenance tracking.
 - **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.
+- **Multi-Agent Governance**: Agent registration, scope isolation, checkpoint supervision, and verified handoffs for multi-agent workflows.
+- **Industry Presets**: SOC2, HIPAA, FedRAMP-ready gate configurations.
 - **Zero Cloud**: 100% local analysis. Your code never leaves your machine.
 
 ---
@@ -45,6 +49,13 @@ Rigour moves code quality enforcement from the "Post-Commit" phase to the "In-Pr
 | `rigour_run_supervised` | Full supervisor mode — iterative command + gate check loop. |
 | `rigour_review` | High-fidelity code review on a PR diff against all quality gates. |
 
+### Real-Time Hooks (v3.0)
+
+| Tool | Description |
+|:---|:---|
+| `rigour_hooks_check` | Run fast hook checker on specific files (<100ms). Catches: hardcoded secrets, hallucinated imports, command injection, file size. |
+| `rigour_hooks_init` | Generate hook configs for Claude, Cursor, Cline, or Windsurf. Installs real-time checks on every file write. |
+
 ### Frontier Model Tools (v2.14+)
 
 For next-gen multi-agent workflows (Opus 4.6, GPT-5.3-Codex):
@@ -59,6 +70,23 @@ For next-gen multi-agent workflows (Opus 4.6, GPT-5.3-Codex):
 
 ---
 
+## 🌐 Language Support
+
+Hallucinated import detection with full stdlib whitelists and dependency manifest parsing:
+
+| Language | Stdlib | Dependency Manifest | Import Patterns |
+|:---|:---|:---|:---|
+| **JavaScript/TypeScript** | Node.js 22.x builtins | `package.json` | `import`, `require()`, `export from` |
+| **Python** | 160+ stdlib modules (3.12+) | Local module resolution | `import`, `from ... import` |
+| **Go** | 150+ stdlib packages (1.22+) | `go.mod` module path | `import "..."`, aliased imports |
+| **Ruby** | 80+ stdlib gems (3.3+ MRI) | `Gemfile`, `.gemspec` | `require`, `require_relative` |
+| **C# / .NET** | .NET 8 framework namespaces | `.csproj` (NuGet PackageReference) | `using`, `using static` |
+| **Rust** | `std`/`core`/`alloc`/`proc_macro` | `Cargo.toml` (with `-` → `_`) | `use`, `extern crate`, `pub use` |
+| **Java** | `java.*`/`javax.*`/`jakarta.*` | `build.gradle`, `pom.xml` | `import`, `import static` |
+| **Kotlin** | `kotlin.*`/`kotlinx.*` + Java interop | `build.gradle.kts` | `import` |
+
+---
+
 ## 📦 Installation
 
 ### 1. Install via npm

package/dist/index.js

@@ -9,7 +9,7 @@
  */
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
+import { CallToolRequestSchema, ListToolsRequestSchema, ListPromptsRequestSchema, GetPromptRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
 import { randomUUID } from "crypto";
 import { GateRunner } from "@rigour-labs/core";
 // Utils
@@ -23,8 +23,9 @@ import { handleCheckPattern, handleSecurityAudit } from './tools/pattern-handler
 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';
 // ─── Server Setup ─────────────────────────────────────────────────
-const server = new Server({ name: "rigour-mcp", version: "1.0.0" }, { capabilities: { tools: {} } });
+const server = new Server({ name: "rigour-mcp", version: "3.0.1" }, { capabilities: { tools: {}, prompts: {} } });
 // ─── Tool Listing ─────────────────────────────────────────────────
 server.setRequestHandler(ListToolsRequestSchema, async () => ({
     tools: TOOL_DEFINITIONS,
@@ -105,6 +106,13 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             case "rigour_handoff_accept":
                 result = await handleHandoffAccept(cwd, args.handoffId, args.agentId, requestId);
                 break;
+            // Real-time hooks (v3.0)
+            case "rigour_hooks_check":
+                result = await handleHooksCheck(cwd, args.files, args.timeout);
+                break;
+            case "rigour_hooks_init":
+                result = await handleHooksInit(cwd, args.tool, args.force, args.dryRun);
+                break;
             // Code review
             case "rigour_review":
                 result = await handleReview(runner, cwd, args.diff, args.files);
@@ -130,11 +138,99 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         return errorResponse;
     }
 });
+// ─── Prompt Templates ────────────────────────────────────────────
+import { PROMPT_DEFINITIONS } from './tools/prompts.js';
+server.setRequestHandler(ListPromptsRequestSchema, async () => ({
+    prompts: PROMPT_DEFINITIONS,
+}));
+server.setRequestHandler(GetPromptRequestSchema, async (request) => {
+    const { name, arguments: promptArgs } = request.params;
+    const cwd = promptArgs?.cwd || process.env.RIGOUR_CWD || process.cwd();
+    const prompt = PROMPT_DEFINITIONS.find((p) => p.name === name);
+    if (!prompt) {
+        throw new Error(`Unknown prompt: ${name}`);
+    }
+    // Generate dynamic messages based on prompt name
+    switch (name) {
+        case "rigour-setup": {
+            return {
+                description: prompt.description,
+                messages: [
+                    {
+                        role: "user",
+                        content: {
+                            type: "text",
+                            text: `Initialize Rigour quality gates for the project at ${cwd}. Run \`rigour_check\` to see current quality score, then use \`rigour_hooks_init\` to install real-time hooks for the detected AI coding tool. Report the score breakdown (overall, AI health, structural) and any critical violations.`,
+                        },
+                    },
+                ],
+            };
+        }
+        case "rigour-fix-loop": {
+            return {
+                description: prompt.description,
+                messages: [
+                    {
+                        role: "user",
+                        content: {
+                            type: "text",
+                            text: `Run \`rigour_check\` on ${cwd}. If the project FAILS, retrieve the fix packet with \`rigour_get_fix_packet\` and fix every violation in priority order (critical → high → medium → low). After each fix, re-run \`rigour_check\` to verify. Repeat until PASS. Do NOT skip any violation. Report progress after each iteration.`,
+                        },
+                    },
+                ],
+            };
+        }
+        case "rigour-security-review": {
+            return {
+                description: prompt.description,
+                messages: [
+                    {
+                        role: "user",
+                        content: {
+                            type: "text",
+                            text: `Perform a full security review on ${cwd}. First run \`rigour_security_audit\` for CVE checks on dependencies. Then run \`rigour_check\` and filter for security-provenance violations (hardcoded secrets, SQL injection, XSS, command injection, path traversal). Report all findings with severity, file locations, and remediation instructions.`,
+                        },
+                    },
+                ],
+            };
+        }
+        case "rigour-pre-commit": {
+            return {
+                description: prompt.description,
+                messages: [
+                    {
+                        role: "user",
+                        content: {
+                            type: "text",
+                            text: `Run a pre-commit quality check on ${cwd}. Execute \`rigour_check\` and \`rigour_hooks_check\` on all staged files. If any critical or high severity violations exist, list them and block the commit. For medium/low violations, warn but allow. Provide a one-line summary: PASS (safe to commit) or FAIL (must fix first).`,
+                        },
+                    },
+                ],
+            };
+        }
+        case "rigour-ai-health-report": {
+            return {
+                description: prompt.description,
+                messages: [
+                    {
+                        role: "user",
+                        content: {
+                            type: "text",
+                            text: `Generate an AI code health report for ${cwd}. Run \`rigour_check\` and focus on AI-drift provenance violations: hallucinated imports, duplication drift, context window artifacts, inconsistent error handling, and promise safety. Compare AI health score vs structural score. Provide a summary table of AI-specific issues and concrete next steps to improve the AI health score.`,
+                        },
+                    },
+                ],
+            };
+        }
+        default:
+            throw new Error(`Unknown prompt: ${name}`);
+    }
+});
 // ─── Start ────────────────────────────────────────────────────────
 async function main() {
     const transport = new StdioServerTransport();
     await server.connect(transport);
-    console.error("Rigour MCP server v1.0.0 running on stdio");
+    console.error("Rigour MCP server v3.0.0 running on stdio");
 }
 main().catch((error) => {
     console.error("Fatal error in Rigour MCP server:", error);

package/dist/tools/definitions.d.ts

@@ -2,9 +2,18 @@
  * MCP Tool Definitions
  *
  * Schema definitions for all Rigour MCP tools.
- * Each tool has a name, description, and JSON Schema for its input.
+ * Each tool has a name, description, JSON Schema for input, and MCP annotations.
+ *
+ * Annotations follow the MCP spec (2025-03-26):
+ *   title         — human-readable display name
+ *   readOnlyHint  — true if tool only reads/computes, never writes
+ *   destructiveHint — true if tool deletes or overwrites data
+ *   idempotentHint  — true if repeated calls produce same result
+ *   openWorldHint   — true if tool reaches outside the user's project
  *
  * @since v2.17.0 — extracted from monolithic index.ts
+ * @since v3.0.0 — hooks tools added
+ * @since v3.0.1 — MCP annotations added for Smithery quality compliance
  */
 export declare const TOOL_DEFINITIONS: ({
     name: string;
@@ -19,6 +28,13 @@ export declare const TOOL_DEFINITIONS: ({
         };
         required: string[];
     };
+    annotations: {
+        title: string;
+        readOnlyHint: boolean;
+        destructiveHint: boolean;
+        idempotentHint: boolean;
+        openWorldHint: boolean;
+    };
 } | {
     name: string;
     description: string;
@@ -40,6 +56,13 @@ export declare const TOOL_DEFINITIONS: ({
         };
         required: string[];
     };
+    annotations: {
+        title: string;
+        readOnlyHint: boolean;
+        destructiveHint: boolean;
+        idempotentHint: boolean;
+        openWorldHint: boolean;
+    };
 } | {
     name: string;
     description: string;
@@ -57,6 +80,13 @@ export declare const TOOL_DEFINITIONS: ({
         };
         required: string[];
     };
+    annotations: {
+        title: string;
+        readOnlyHint: boolean;
+        destructiveHint: boolean;
+        idempotentHint: boolean;
+        openWorldHint: boolean;
+    };
 } | {
     name: string;
     description: string;
@@ -82,6 +112,13 @@ export declare const TOOL_DEFINITIONS: ({
         };
         required: string[];
     };
+    annotations: {
+        title: string;
+        readOnlyHint: boolean;
+        destructiveHint: boolean;
+        idempotentHint: boolean;
+        openWorldHint: boolean;
+    };
 } | {
     name: string;
     description: string;
@@ -103,6 +140,13 @@ export declare const TOOL_DEFINITIONS: ({
         };
         required: string[];
     };
+    annotations: {
+        title: string;
+        readOnlyHint: boolean;
+        destructiveHint: boolean;
+        idempotentHint: boolean;
+        openWorldHint: boolean;
+    };
 } | {
     name: string;
     description: string;
@@ -128,6 +172,13 @@ export declare const TOOL_DEFINITIONS: ({
         };
         required: string[];
     };
+    annotations: {
+        title: string;
+        readOnlyHint: boolean;
+        destructiveHint: boolean;
+        idempotentHint: boolean;
+        openWorldHint: boolean;
+    };
 } | {
     name: string;
     description: string;
@@ -152,6 +203,13 @@ export declare const TOOL_DEFINITIONS: ({
         };
         required: string[];
     };
+    annotations: {
+        title: string;
+        readOnlyHint: boolean;
+        destructiveHint: boolean;
+        idempotentHint: boolean;
+        openWorldHint: boolean;
+    };
 } | {
     name: string;
     description: string;
@@ -184,6 +242,13 @@ export declare const TOOL_DEFINITIONS: ({
         };
         required: string[];
     };
+    annotations: {
+        title: string;
+        readOnlyHint: boolean;
+        destructiveHint: boolean;
+        idempotentHint: boolean;
+        openWorldHint: boolean;
+    };
 } | {
     name: string;
     description: string;
@@ -220,6 +285,13 @@ export declare const TOOL_DEFINITIONS: ({
         };
         required: string[];
     };
+    annotations: {
+        title: string;
+        readOnlyHint: boolean;
+        destructiveHint: boolean;
+        idempotentHint: boolean;
+        openWorldHint: boolean;
+    };
 } | {
     name: string;
     description: string;
@@ -237,6 +309,13 @@ export declare const TOOL_DEFINITIONS: ({
         };
         required: string[];
     };
+    annotations: {
+        title: string;
+        readOnlyHint: boolean;
+        destructiveHint: boolean;
+        idempotentHint: boolean;
+        openWorldHint: boolean;
+    };
 } | {
     name: string;
     description: string;
@@ -258,6 +337,76 @@ export declare const TOOL_DEFINITIONS: ({
         };
         required: string[];
     };
+    annotations: {
+        title: string;
+        readOnlyHint: boolean;
+        destructiveHint: boolean;
+        idempotentHint: boolean;
+        openWorldHint: boolean;
+    };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            files: {
+                type: string;
+                items: {
+                    type: string;
+                };
+                description: string;
+            };
+            timeout: {
+                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: {
+            tool: {
+                type: string;
+                description: string;
+            };
+            force: {
+                type: string;
+                description: string;
+            };
+            dryRun: {
+                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;
@@ -290,4 +439,11 @@ export declare const TOOL_DEFINITIONS: ({
         };
         required: string[];
     };
+    annotations: {
+        title: string;
+        readOnlyHint: boolean;
+        destructiveHint: boolean;
+        idempotentHint: boolean;
+        openWorldHint: boolean;
+    };
 })[];

package/dist/tools/definitions.js

@@ -2,9 +2,18 @@
  * MCP Tool Definitions
  *
  * Schema definitions for all Rigour MCP tools.
- * Each tool has a name, description, and JSON Schema for its input.
+ * Each tool has a name, description, JSON Schema for input, and MCP annotations.
+ *
+ * Annotations follow the MCP spec (2025-03-26):
+ *   title         — human-readable display name
+ *   readOnlyHint  — true if tool only reads/computes, never writes
+ *   destructiveHint — true if tool deletes or overwrites data
+ *   idempotentHint  — true if repeated calls produce same result
+ *   openWorldHint   — true if tool reaches outside the user's project
  *
  * @since v2.17.0 — extracted from monolithic index.ts
+ * @since v3.0.0 — hooks tools added
+ * @since v3.0.1 — MCP annotations added for Smithery quality compliance
  */
 function cwdParam() {
     return {
@@ -24,6 +33,13 @@ export const TOOL_DEFINITIONS = [
             properties: cwdParam(),
             required: ["cwd"],
         },
+        annotations: {
+            title: "Run Quality Gates",
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
     },
     {
         name: "rigour_explain",
@@ -33,6 +49,13 @@ export const TOOL_DEFINITIONS = [
             properties: cwdParam(),
             required: ["cwd"],
         },
+        annotations: {
+            title: "Explain Gate Failures",
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
     },
     {
         name: "rigour_status",
@@ -42,6 +65,13 @@ export const TOOL_DEFINITIONS = [
             properties: cwdParam(),
             required: ["cwd"],
         },
+        annotations: {
+            title: "Quality Status",
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
     },
     {
         name: "rigour_get_fix_packet",
@@ -51,6 +81,13 @@ export const TOOL_DEFINITIONS = [
             properties: cwdParam(),
             required: ["cwd"],
         },
+        annotations: {
+            title: "Get Fix Packet",
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
     },
     {
         name: "rigour_list_gates",
@@ -60,6 +97,13 @@ export const TOOL_DEFINITIONS = [
             properties: cwdParam(),
             required: ["cwd"],
         },
+        annotations: {
+            title: "List Quality Gates",
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
     },
     {
         name: "rigour_get_config",
@@ -69,6 +113,13 @@ export const TOOL_DEFINITIONS = [
             properties: cwdParam(),
             required: ["cwd"],
         },
+        annotations: {
+            title: "Get Configuration",
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
     },
     // ─── Memory Persistence ───────────────────────────────
     {
@@ -83,6 +134,13 @@ export const TOOL_DEFINITIONS = [
             },
             required: ["cwd", "key", "value"],
         },
+        annotations: {
+            title: "Store Memory",
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
     },
     {
         name: "rigour_recall",
@@ -95,6 +153,13 @@ export const TOOL_DEFINITIONS = [
             },
             required: ["cwd"],
         },
+        annotations: {
+            title: "Recall Memory",
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
     },
     {
         name: "rigour_forget",
@@ -107,6 +172,13 @@ export const TOOL_DEFINITIONS = [
             },
             required: ["cwd", "key"],
         },
+        annotations: {
+            title: "Delete Memory",
+            readOnlyHint: false,
+            destructiveHint: true,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
     },
     // ─── Pattern Intelligence ─────────────────────────────
     {
@@ -122,6 +194,13 @@ export const TOOL_DEFINITIONS = [
             },
             required: ["cwd", "name"],
         },
+        annotations: {
+            title: "Check Pattern Exists",
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
     },
     {
         name: "rigour_security_audit",
@@ -131,6 +210,13 @@ export const TOOL_DEFINITIONS = [
             properties: cwdParam(),
             required: ["cwd"],
         },
+        annotations: {
+            title: "Security Audit",
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: true,
+        },
     },
     // ─── Execution & Supervision ──────────────────────────
     {
@@ -145,6 +231,13 @@ export const TOOL_DEFINITIONS = [
             },
             required: ["cwd", "command"],
         },
+        annotations: {
+            title: "Run Command",
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: false,
+            openWorldHint: false,
+        },
     },
     {
         name: "rigour_run_supervised",
@@ -159,6 +252,13 @@ export const TOOL_DEFINITIONS = [
             },
             required: ["cwd", "command"],
         },
+        annotations: {
+            title: "Supervised Execution",
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: false,
+            openWorldHint: false,
+        },
     },
     // ─── Multi-Agent Governance (v2.14+) ──────────────────
     {
@@ -173,6 +273,13 @@ export const TOOL_DEFINITIONS = [
             },
             required: ["cwd", "agentId", "taskScope"],
         },
+        annotations: {
+            title: "Register Agent",
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
     },
     {
         name: "rigour_checkpoint",
@@ -188,6 +295,13 @@ export const TOOL_DEFINITIONS = [
             },
             required: ["cwd", "progressPct", "summary", "qualityScore"],
         },
+        annotations: {
+            title: "Record Checkpoint",
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: false,
+            openWorldHint: false,
+        },
     },
     {
         name: "rigour_handoff",
@@ -204,6 +318,13 @@ export const TOOL_DEFINITIONS = [
             },
             required: ["cwd", "fromAgentId", "toAgentId", "taskDescription"],
         },
+        annotations: {
+            title: "Handoff Task",
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: false,
+            openWorldHint: false,
+        },
     },
     {
         name: "rigour_agent_deregister",
@@ -216,6 +337,13 @@ export const TOOL_DEFINITIONS = [
             },
             required: ["cwd", "agentId"],
         },
+        annotations: {
+            title: "Deregister Agent",
+            readOnlyHint: false,
+            destructiveHint: true,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
     },
     {
         name: "rigour_handoff_accept",
@@ -229,6 +357,55 @@ export const TOOL_DEFINITIONS = [
             },
             required: ["cwd", "handoffId", "agentId"],
         },
+        annotations: {
+            title: "Accept Handoff",
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
+    },
+    // ─── Real-Time Hooks (v3.0) ────────────────────────────
+    {
+        name: "rigour_hooks_check",
+        description: "Run the fast hook checker on specific files. Same checks that run inside IDE hooks (Claude, Cursor, Cline, Windsurf). Catches: hardcoded secrets, hallucinated imports, command injection, file size. Completes in <100ms.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                ...cwdParam(),
+                files: { type: "array", items: { type: "string" }, description: "List of file paths (relative to cwd) to check." },
+                timeout: { type: "number", description: "Optional timeout in milliseconds (default: 5000)." },
+            },
+            required: ["cwd", "files"],
+        },
+        annotations: {
+            title: "Fast Hook Check",
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
+    },
+    {
+        name: "rigour_hooks_init",
+        description: "Generate hook configs for AI coding tools (Claude, Cursor, Cline, Windsurf). Installs real-time quality checks that run on every file write.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                ...cwdParam(),
+                tool: { type: "string", description: "Target tool: 'claude', 'cursor', 'cline', or 'windsurf'." },
+                force: { type: "boolean", description: "Overwrite existing hook files (default: false)." },
+                dryRun: { type: "boolean", description: "Preview changes without writing files (default: false)." },
+            },
+            required: ["cwd", "tool"],
+        },
+        annotations: {
+            title: "Install IDE Hooks",
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
     },
     // ─── Code Review ──────────────────────────────────────
     {
@@ -245,5 +422,12 @@ export const TOOL_DEFINITIONS = [
             },
             required: ["cwd", "diff"],
         },
+        annotations: {
+            title: "Code Review",
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
     },
 ];

package/dist/tools/hooks-handler.d.ts

@@ -0,0 +1,18 @@
+type ToolResult = {
+    content: {
+        type: string;
+        text: string;
+    }[];
+    isError?: boolean;
+};
+/**
+ * rigour_hooks_check — Run the fast hook checker on specific files.
+ * This is the same check that runs inside IDE hooks (Claude, Cursor, Cline, Windsurf).
+ * Catches: hardcoded secrets, hallucinated imports, command injection, file size.
+ */
+export declare function handleHooksCheck(cwd: string, files: string[], timeout?: number): Promise<ToolResult>;
+/**
+ * rigour_hooks_init — Generate hook configs for AI coding tools.
+ */
+export declare function handleHooksInit(cwd: string, tool: string, force?: boolean, dryRun?: boolean): Promise<ToolResult>;
+export {};

package/dist/tools/hooks-handler.js

@@ -0,0 +1,86 @@
+/**
+ * Hooks Tool Handlers
+ *
+ * Handlers for: rigour_hooks_check, rigour_hooks_init
+ *
+ * @since v3.0.0 — real-time hooks for AI coding tools
+ */
+import { runHookChecker, generateHookFiles } from "@rigour-labs/core";
+import fs from "fs-extra";
+import path from "path";
+/**
+ * rigour_hooks_check — Run the fast hook checker on specific files.
+ * This is the same check that runs inside IDE hooks (Claude, Cursor, Cline, Windsurf).
+ * Catches: hardcoded secrets, hallucinated imports, command injection, file size.
+ */
+export async function handleHooksCheck(cwd, files, timeout) {
+    const input = { cwd, files };
+    if (timeout)
+        input.timeout_ms = timeout;
+    const result = await runHookChecker(input);
+    if (result.status === 'pass') {
+        return {
+            content: [{
+                    type: "text",
+                    text: `✓ PASS — ${files.length} file(s) passed all hook checks.\nDuration: ${result.duration_ms}ms`,
+                }],
+        };
+    }
+    const failureLines = result.failures.map(f => `  [${f.severity.toUpperCase()}] [${f.gate}] ${f.file}:${f.line ?? '?'}\n    → ${f.message}`).join('\n');
+    return {
+        content: [{
+                type: "text",
+                text: `✘ FAIL — ${result.failures.length} issue(s) found in ${files.length} file(s).\nDuration: ${result.duration_ms}ms\n\n${failureLines}`,
+            }],
+    };
+}
+/**
+ * rigour_hooks_init — Generate hook configs for AI coding tools.
+ */
+export async function handleHooksInit(cwd, tool, force = false, dryRun = false) {
+    try {
+        const hookTool = tool;
+        const checkerPath = 'npx @rigour-labs/cli hooks check';
+        const files = generateHookFiles(hookTool, checkerPath);
+        if (dryRun) {
+            const preview = files.map(f => `${f.path}:\n${f.content}`).join('\n\n');
+            return {
+                content: [{
+                        type: "text",
+                        text: `[DRY RUN] Would generate ${files.length} hook file(s) for '${tool}':\n\n${preview}`,
+                    }],
+            };
+        }
+        const written = [];
+        const skipped = [];
+        for (const file of files) {
+            const fullPath = path.join(cwd, file.path);
+            if (!force && await fs.pathExists(fullPath)) {
+                skipped.push(file.path);
+                continue;
+            }
+            await fs.ensureDir(path.dirname(fullPath));
+            await fs.writeFile(fullPath, file.content);
+            written.push(file.path);
+        }
+        const parts = [];
+        if (written.length > 0)
+            parts.push(`✓ Created: ${written.join(', ')}`);
+        if (skipped.length > 0)
+            parts.push(`⊘ Skipped (exists): ${skipped.join(', ')}. Use force=true to overwrite.`);
+        parts.push(`Tool: ${tool}`);
+        parts.push('Checks: file-size, security-patterns, hallucinated-imports, command-injection');
+        return {
+            content: [{ type: "text", text: parts.join('\n') }],
+        };
+    }
+    catch (error) {
+        return {
+            content: [{
+                    type: "text",
+                    text: `Hook init failed: ${error.message}\n\nFallback: run 'npx @rigour-labs/cli hooks init --tool ${tool}' from the terminal.`,
+                }],
+            isError: true,
+        };
+    }
+}

package/dist/tools/prompts.d.ts

@@ -0,0 +1,17 @@
+/**
+ * MCP Prompt Definitions
+ *
+ * Reusable prompt templates that guide AI agents through common Rigour workflows.
+ * These appear in the MCP prompts capability and can be invoked by any MCP client.
+ *
+ * @since v3.0.1 — added for Smithery quality compliance
+ */
+export declare const PROMPT_DEFINITIONS: {
+    name: string;
+    description: string;
+    arguments: {
+        name: string;
+        description: string;
+        required: boolean;
+    }[];
+}[];

package/dist/tools/prompts.js

@@ -0,0 +1,65 @@
+/**
+ * MCP Prompt Definitions
+ *
+ * Reusable prompt templates that guide AI agents through common Rigour workflows.
+ * These appear in the MCP prompts capability and can be invoked by any MCP client.
+ *
+ * @since v3.0.1 — added for Smithery quality compliance
+ */
+export const PROMPT_DEFINITIONS = [
+    {
+        name: "rigour-setup",
+        description: "Initialize Rigour quality gates for a project. Runs gate checks, installs IDE hooks, and reports the initial quality score breakdown.",
+        arguments: [
+            {
+                name: "cwd",
+                description: "Absolute path to the project root.",
+                required: false,
+            },
+        ],
+    },
+    {
+        name: "rigour-fix-loop",
+        description: "Iteratively fix all quality gate violations until the project passes. Retrieves fix packets and resolves issues in priority order (critical → low).",
+        arguments: [
+            {
+                name: "cwd",
+                description: "Absolute path to the project root.",
+                required: false,
+            },
+        ],
+    },
+    {
+        name: "rigour-security-review",
+        description: "Full security review: CVE audit on dependencies + code-level vulnerability scan (OWASP LLM Top 10). Reports all findings with remediation steps.",
+        arguments: [
+            {
+                name: "cwd",
+                description: "Absolute path to the project root.",
+                required: false,
+            },
+        ],
+    },
+    {
+        name: "rigour-pre-commit",
+        description: "Pre-commit quality gate check. Runs fast hooks on staged files and full gate check. Returns PASS/FAIL verdict for commit safety.",
+        arguments: [
+            {
+                name: "cwd",
+                description: "Absolute path to the project root.",
+                required: false,
+            },
+        ],
+    },
+    {
+        name: "rigour-ai-health-report",
+        description: "AI code health report focusing on drift detection: hallucinated imports, duplication drift, context window artifacts, inconsistent error handling, and promise safety.",
+        arguments: [
+            {
+                name: "cwd",
+                description: "Absolute path to the project root.",
+                required: false,
+            },
+        ],
+    },
+];

package/package.json

@@ -1,20 +1,30 @@
 {
   "name": "@rigour-labs/mcp",
-  "version": "3.0.1",
-  "description": "MCP server for AI code quality gates. Integrates with Claude Desktop, Cursor, Cline, and VS Code to enforce engineering standards in real-time.",
+  "version": "3.0.3",
+  "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",
+  "icon": "https://raw.githubusercontent.com/rigour-labs/rigour/main/docs/assets/icon.svg",
   "keywords": [
     "mcp",
     "model-context-protocol",
-    "quality-gates",
-    "ai-code-quality",
+    "owasp-llm-top-10",
+    "ai-code-governance",
+    "real-time-hooks",
+    "security-patterns",
+    "hallucinated-imports",
+    "industry-presets",
+    "hipaa",
+    "soc2",
+    "fedramp",
     "claude",
     "cursor",
     "cline",
-    "code-review",
+    "windsurf",
+    "multi-agent-governance",
+    "quality-gates",
     "static-analysis",
-    "agent-governance"
+    "code-review"
   ],
   "type": "module",
   "mcpName": "io.github.rigour-labs/rigour",
@@ -38,7 +48,7 @@
     "execa": "^8.0.1",
     "fs-extra": "^11.2.0",
     "yaml": "^2.8.2",
-    "@rigour-labs/core": "3.0.1"
+    "@rigour-labs/core": "3.0.3"
   },
   "devDependencies": {
     "@types/node": "^25.0.3",