@crowley/rag-mcp 1.0.6 → 1.1.0

package/dist/index.js

@@ -34,6 +34,7 @@ import { createCacheTools } from "./tools/cache.js";
 import { createGuidelinesTools } from "./tools/guidelines.js";
 import { createAdvancedTools } from "./tools/advanced.js";
 import { createAgentTools } from "./tools/agents.js";
+import { createQualityTools } from "./tools/quality.js";
 // Configuration from environment
 const PROJECT_NAME = process.env.PROJECT_NAME || "default";
 const PROJECT_PATH = process.env.PROJECT_PATH || process.cwd();
@@ -76,11 +77,63 @@ const allSpecs = [
     ...createGuidelinesTools(PROJECT_NAME),
     ...createAdvancedTools(PROJECT_NAME),
     ...createAgentTools(PROJECT_NAME),
+    ...createQualityTools(PROJECT_NAME),
 ];
+// Core tools exposed directly to Claude (~35 tools).
+// Hidden tools remain accessible via run_agent (agent runtime calls API directly).
+const CORE_TOOLS = new Set([
+    // Search (6)
+    "search_codebase",
+    "hybrid_search",
+    "search_graph",
+    "find_symbol",
+    "search_docs",
+    "find_feature",
+    // Ask (2)
+    "ask_codebase",
+    "explain_code",
+    // Index (3)
+    "index_codebase",
+    "get_index_status",
+    "get_project_stats",
+    // Memory (7)
+    "remember",
+    "recall",
+    "list_memories",
+    "forget",
+    "batch_remember",
+    "promote_memory",
+    "review_memories",
+    // Architecture (6)
+    "record_adr",
+    "get_adrs",
+    "record_pattern",
+    "get_patterns",
+    "record_tech_debt",
+    "get_tech_debt",
+    // Context (3)
+    "context_briefing",
+    "smart_dispatch",
+    "setup_project",
+    // Session (2)
+    "start_session",
+    "end_session",
+    // Confluence (2)
+    "search_confluence",
+    "index_confluence",
+    // DB (4)
+    "record_table",
+    "get_table_info",
+    "check_db_schema",
+    "get_db_rules",
+    // Agents (1)
+    "run_agent",
+]);
+const coreSpecs = allSpecs.filter((s) => CORE_TOOLS.has(s.name));
 // MCP Server (modern McpServer API with native Zod validation)
-const server = new McpServer({ name: `${PROJECT_NAME}-rag`, version: "1.0.5" }, { capabilities: { tools: {} } });
-// Register all tools with McpServer using wrapHandler middleware
-for (const spec of allSpecs) {
+const server = new McpServer({ name: `${PROJECT_NAME}-rag`, version: "1.1.0" }, { capabilities: { tools: {} } });
+// Register core tools with McpServer using wrapHandler middleware
+for (const spec of coreSpecs) {
     const wrapped = wrapHandler(spec.name, spec.handler, { enricher, ctx });
     server.registerTool(spec.name, {
         description: spec.description,
@@ -121,6 +174,6 @@ async function main() {
     const transport = new StdioServerTransport();
     await server.connect(transport);
     console.error(`${PROJECT_NAME} RAG MCP server running (collection prefix: ${COLLECTION_PREFIX})`);
-    console.error(`Registered ${allSpecs.length} tools from 18 modules`);
+    console.error(`Registered ${coreSpecs.length}/${allSpecs.length} core tools (${allSpecs.length - coreSpecs.length} hidden, accessible via run_agent)`);
 }
 main().catch(console.error);

package/dist/schemas.d.ts

@@ -83,13 +83,13 @@ export declare const MemoryRecordInput: z.ZodObject<{
     importance: z.ZodOptional<z.ZodDefault<z.ZodEnum<["low", "medium", "high", "critical"]>>>;
     context: z.ZodOptional<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
-    type: "decision" | "insight" | "todo" | "adr" | "pattern" | "tech_debt" | "architecture" | "convention" | "bug_fix" | "optimization";
+    type: "decision" | "insight" | "todo" | "adr" | "pattern" | "architecture" | "tech_debt" | "convention" | "bug_fix" | "optimization";
     content: string;
     context?: string | undefined;
     tags?: string[] | undefined;
     importance?: "low" | "medium" | "high" | "critical" | undefined;
 }, {
-    type: "decision" | "insight" | "todo" | "adr" | "pattern" | "tech_debt" | "architecture" | "convention" | "bug_fix" | "optimization";
+    type: "decision" | "insight" | "todo" | "adr" | "pattern" | "architecture" | "tech_debt" | "convention" | "bug_fix" | "optimization";
     content: string;
     context?: string | undefined;
     tags?: string[] | undefined;

package/dist/tools/quality.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Quality tools module - LLM quality monitoring and reporting.
+ */
+import type { ToolSpec } from "../types.js";
+/**
+ * Create the quality tools module.
+ */
+export declare function createQualityTools(projectName: string): ToolSpec[];

package/dist/tools/quality.js

@@ -0,0 +1,60 @@
+/**
+ * Quality tools module - LLM quality monitoring and reporting.
+ */
+import { z } from "zod";
+import { TOOL_ANNOTATIONS } from "../annotations.js";
+/**
+ * Create the quality tools module.
+ */
+export function createQualityTools(projectName) {
+    return [
+        {
+            name: "get_quality_report",
+            description: `Get LLM quality metrics for ${projectName}. Shows JSON parse rates, latency percentiles, thinking trace rates, and alerts.`,
+            schema: z.object({
+                endpoint: z.string().optional().describe("Filter by specific endpoint (e.g., '/api/ask')"),
+            }),
+            annotations: TOOL_ANNOTATIONS["get_quality_report"] || {
+                title: "Get Quality Report",
+                readOnlyHint: true,
+                openWorldHint: false,
+            },
+            handler: async (args, ctx) => {
+                const params = args.endpoint ? `?endpoint=${encodeURIComponent(args.endpoint)}` : '';
+                const response = await ctx.api.get(`/api/quality/report${params}`);
+                const data = response.data;
+                let result = `## Quality Report\n\n`;
+                result += `**Total Metrics:** ${data.total}\n\n`;
+                if (data.total === 0) {
+                    result += `No quality metrics recorded yet.\n`;
+                    return result;
+                }
+                const m = data.metrics;
+                result += `### Aggregate Metrics\n`;
+                result += `- **Avg Latency:** ${m.avgLatencyMs}ms\n`;
+                result += `- **P95 Latency:** ${m.p95LatencyMs}ms\n`;
+                result += `- **JSON Parse Rate:** ${(m.jsonParseRate * 100).toFixed(1)}%\n`;
+                result += `- **Thinking Rate:** ${(m.thinkingRate * 100).toFixed(1)}%\n`;
+                result += `- **Avg Output Length:** ${m.avgOutputLength} chars\n`;
+                result += `- **Avg Thinking Length:** ${m.avgThinkingLength} chars\n`;
+                result += `- **Avg Tokens:** ${m.avgTokens}\n\n`;
+                if (data.alerts.length > 0) {
+                    result += `### ⚠ Alerts\n`;
+                    for (const alert of data.alerts) {
+                        result += `- ${alert}\n`;
+                    }
+                    result += `\n`;
+                }
+                if (Object.keys(data.byEndpoint).length > 0) {
+                    result += `### By Endpoint\n`;
+                    for (const [ep, stats] of Object.entries(data.byEndpoint)) {
+                        result += `- **${ep}**: ${stats.count} calls, ${stats.avgLatencyMs}ms avg, `;
+                        result += `JSON: ${(stats.jsonParseRate * 100).toFixed(0)}%, `;
+                        result += `Thinking: ${(stats.thinkingRate * 100).toFixed(0)}%\n`;
+                    }
+                }
+                return result;
+            },
+        },
+    ];
+}

package/dist/tools/suggestions.js

@@ -7,6 +7,75 @@ import * as path from "path";
 import { truncate, pct, PREVIEW } from "../formatters.js";
 import { z } from "zod";
 import { TOOL_ANNOTATIONS } from "../annotations.js";
+/**
+ * Format smart dispatch result into readable markdown.
+ */
+function formatSmartDispatchResult(task, data) {
+    let result = `# Context Briefing: ${task}\n`;
+    result += `_Routing: ${data.reasoning} (${data.plan?.join(", ")}) [${data.timing?.totalMs}ms]_\n\n`;
+    const ctx = data.context || {};
+    if (ctx.memories?.length > 0) {
+        result += `## Memories (${ctx.memories.length})\n`;
+        for (const m of ctx.memories) {
+            const mem = m.memory || m;
+            result += `- [${mem.type || "note"}] ${(mem.content || "").slice(0, 150)}\n`;
+        }
+        result += "\n";
+    }
+    if (ctx.codeResults?.length > 0) {
+        result += `## Related Code (${ctx.codeResults.length})\n`;
+        for (const r of ctx.codeResults) {
+            result += `- \`${r.file}\``;
+            if (r.symbols?.length)
+                result += ` — ${r.symbols.join(", ")}`;
+            result += "\n";
+        }
+        result += "\n";
+    }
+    if (ctx.patterns?.length > 0) {
+        result += `## Patterns (${ctx.patterns.length})\n`;
+        for (const p of ctx.patterns) {
+            const mem = p.memory || p;
+            const name = mem.metadata?.patternName || mem.relatedTo || "Pattern";
+            result += `- **${name}**: ${(mem.content || "").slice(0, 120)}\n`;
+        }
+        result += "\n";
+    }
+    if (ctx.adrs?.length > 0) {
+        result += `## ADRs (${ctx.adrs.length})\n`;
+        for (const a of ctx.adrs) {
+            const mem = a.memory || a;
+            const title = mem.metadata?.adrTitle || mem.relatedTo || "ADR";
+            result += `- **${title}**: ${(mem.content || "").slice(0, 120)}\n`;
+        }
+        result += "\n";
+    }
+    if (ctx.graphDeps?.length > 0) {
+        result += `## Dependencies (${ctx.graphDeps.length})\n`;
+        for (const g of ctx.graphDeps) {
+            result += `- \`${g.file}\`\n`;
+        }
+        result += "\n";
+    }
+    if (ctx.docs?.length > 0) {
+        result += `## Docs (${ctx.docs.length})\n`;
+        for (const d of ctx.docs) {
+            result += `- \`${d.file}\`: ${(d.content || "").slice(0, 100)}\n`;
+        }
+        result += "\n";
+    }
+    if (ctx.symbols?.length > 0) {
+        result += `## Symbols (${ctx.symbols.length})\n`;
+        for (const s of ctx.symbols) {
+            result += `- \`${s.name || s.symbol}\` [${s.kind || "unknown"}] in \`${s.file || "?"}\`\n`;
+        }
+        result += "\n";
+    }
+    if (result.endsWith(`_Routing: ${data.reasoning} (${data.plan?.join(", ")}) [${data.timing?.totalMs}ms]_\n\n`)) {
+        result += "_No relevant context found. Proceed with implementation._\n";
+    }
+    return result;
+}
 /**
  * Create the suggestions tools module with project-specific descriptions.
  */
@@ -22,9 +91,21 @@ export function createSuggestionTools(projectName) {
             annotations: TOOL_ANNOTATIONS["context_briefing"],
             handler: async (args, ctx) => {
                 const { task, files } = args;
-                // 5 parallel lookups
+                // Use smart_dispatch for intelligent routing
+                try {
+                    const dispatchRes = await ctx.api.post("/api/smart-dispatch", {
+                        projectName: ctx.projectName,
+                        task,
+                        files,
+                    });
+                    const data = dispatchRes.data;
+                    return formatSmartDispatchResult(task, data);
+                }
+                catch {
+                    // Fallback to legacy 5-parallel-lookups if smart-dispatch unavailable
+                }
+                // Legacy fallback: 5 parallel lookups
                 const [memoriesRes, searchRes, patternsRes, adrsRes, graphRes] = await Promise.all([
-                    // 1. Recall relevant memories
                     ctx.api
                         .post("/api/memory/recall", {
                         projectName: ctx.projectName,
@@ -33,7 +114,6 @@ export function createSuggestionTools(projectName) {
                         type: "all",
                     })
                         .catch(() => null),
-                    // 2. Hybrid search for related code
                     ctx.api
                         .post("/api/search-hybrid", {
                         projectName: ctx.projectName,
@@ -42,7 +122,6 @@ export function createSuggestionTools(projectName) {
                         mode: "navigate",
                     })
                         .catch(() => null),
-                    // 3. Architectural patterns
                     ctx.api
                         .post("/api/memory/recall", {
                         projectName: ctx.projectName,
@@ -52,7 +131,6 @@ export function createSuggestionTools(projectName) {
                         tag: "pattern",
                     })
                         .catch(() => null),
-                    // 4. ADRs
                     ctx.api
                         .post("/api/memory/recall", {
                         projectName: ctx.projectName,
@@ -62,7 +140,6 @@ export function createSuggestionTools(projectName) {
                         tag: "adr",
                     })
                         .catch(() => null),
-                    // 5. Graph dependencies (if files specified)
                     files && files.length > 0
                         ? ctx.api
                             .post("/api/search-graph", {
@@ -75,7 +152,6 @@ export function createSuggestionTools(projectName) {
                         : Promise.resolve(null),
                 ]);
                 let result = `# Context Briefing: ${task}\n\n`;
-                // Memories
                 const memories = memoriesRes?.data?.results || memoriesRes?.data?.memories || [];
                 if (memories.length > 0) {
                     result += `## Memories (${memories.length})\n`;
@@ -85,7 +161,6 @@ export function createSuggestionTools(projectName) {
                     }
                     result += "\n";
                 }
-                // Related code
                 const codeResults = searchRes?.data?.results || [];
                 if (codeResults.length > 0) {
                     result += `## Related Code (${codeResults.length})\n`;
@@ -97,7 +172,6 @@ export function createSuggestionTools(projectName) {
                     }
                     result += "\n";
                 }
-                // Patterns
                 const patterns = (patternsRes?.data?.results || []).filter((r) => r.memory?.tags?.includes("pattern"));
                 if (patterns.length > 0) {
                     result += `## Patterns (${patterns.length})\n`;
@@ -107,7 +181,6 @@ export function createSuggestionTools(projectName) {
                     }
                     result += "\n";
                 }
-                // ADRs
                 const adrs = (adrsRes?.data?.results || []).filter((r) => r.memory?.tags?.includes("adr"));
                 if (adrs.length > 0) {
                     result += `## ADRs (${adrs.length})\n`;
@@ -117,7 +190,6 @@ export function createSuggestionTools(projectName) {
                     }
                     result += "\n";
                 }
-                // Graph dependencies
                 const graphResults = graphRes?.data?.results || graphRes?.data?.directResults || [];
                 const connectedFiles = graphRes?.data?.connectedFiles || graphRes?.data?.expandedResults || [];
                 if (graphResults.length > 0 || connectedFiles.length > 0) {
@@ -136,6 +208,26 @@ export function createSuggestionTools(projectName) {
                 return result;
             },
         },
+        {
+            name: "smart_dispatch",
+            description: `Intelligent task routing for ${projectName}. LLM analyzes your task and runs only the needed lookups (2-5 of 7 available) in parallel. More efficient than context_briefing for narrow tasks.`,
+            schema: z.object({
+                task: z.string().describe("What you will implement/change"),
+                files: z.array(z.string()).optional().describe("Files you plan to modify"),
+                intent: z.enum(["code", "research", "debug", "review", "architecture"]).optional().describe("Task intent for better routing"),
+            }),
+            annotations: TOOL_ANNOTATIONS["context_briefing"], // Same annotations as context_briefing
+            handler: async (args, ctx) => {
+                const { task, files, intent } = args;
+                const response = await ctx.api.post("/api/smart-dispatch", {
+                    projectName: ctx.projectName,
+                    task,
+                    files,
+                    intent,
+                });
+                return formatSmartDispatchResult(task, response.data);
+            },
+        },
         {
             name: "get_contextual_suggestions",
             description: `Get contextual suggestions based on current work context for ${projectName}. Returns relevant suggestions, triggers, and related memories.`,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@crowley/rag-mcp",
-  "version": "1.0.6",
+  "version": "1.1.0",
   "description": "Universal RAG MCP Server for any project",
   "type": "module",
   "main": "dist/index.js",