@crowley/rag-mcp 1.0.6 → 1.2.0

package/dist/__tests__/tool-middleware.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/tool-middleware.test.js

@@ -0,0 +1,83 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { summarizeInput, countResults, formatToolError, TRACKING_EXCLUDE, SESSION_TOOLS, TOOL_TIMEOUTS, } from '../tool-middleware.js';
+describe('Tool Middleware', () => {
+    beforeEach(() => {
+        vi.resetAllMocks();
+    });
+    describe('summarizeInput', () => {
+        it('extracts query field', () => {
+            expect(summarizeInput('search', { query: 'find auth code' })).toBe('find auth code');
+        });
+        it('extracts question field', () => {
+            expect(summarizeInput('ask', { question: 'what is auth?' })).toBe('what is auth?');
+        });
+        it('extracts content field as fallback', () => {
+            expect(summarizeInput('remember', { content: 'important note' })).toBe('important note');
+        });
+        it('extracts file path as fallback', () => {
+            expect(summarizeInput('explain', { filePath: 'src/auth.ts' })).toBe('src/auth.ts');
+        });
+        it('truncates long strings to 200 chars', () => {
+            const long = 'a'.repeat(300);
+            expect(summarizeInput('search', { query: long }).length).toBeLessThanOrEqual(200);
+        });
+        it('returns tool name when no useful field', () => {
+            expect(summarizeInput('get_stats', {})).toBe('get_stats');
+        });
+    });
+    describe('countResults', () => {
+        it('returns 0 for "No results" messages', () => {
+            expect(countResults('No results found.')).toBe(0);
+        });
+        it('returns 0 for "not found" messages', () => {
+            expect(countResults('Memory not found')).toBe(0);
+        });
+        it('counts numbered items', () => {
+            const text = '1. First\n2. Second\n3. Third';
+            expect(countResults(text)).toBe(3);
+        });
+        it('counts bullet items', () => {
+            const text = '- item1\n- item2';
+            expect(countResults(text)).toBe(2);
+        });
+        it('returns 1 for generic content', () => {
+            expect(countResults('Some response text')).toBe(1);
+        });
+    });
+    describe('formatToolError', () => {
+        const ctx = {
+            api: { defaults: { baseURL: 'http://localhost:3100' } },
+        };
+        it('formats ECONNREFUSED error', () => {
+            const err = { code: 'ECONNREFUSED' };
+            const result = formatToolError(err, ctx);
+            expect(result).toContain('Cannot connect');
+            expect(result).toContain('localhost:3100');
+        });
+        it('formats API error with status', () => {
+            const err = { response: { status: 404, data: { error: 'not found' } } };
+            const result = formatToolError(err, ctx);
+            expect(result).toContain('404');
+        });
+        it('formats generic error message', () => {
+            const err = { message: 'Something broke' };
+            const result = formatToolError(err, ctx);
+            expect(result).toContain('Something broke');
+        });
+    });
+    describe('constants', () => {
+        it('TRACKING_EXCLUDE contains meta tools', () => {
+            expect(TRACKING_EXCLUDE.has('get_tool_analytics')).toBe(true);
+            expect(TRACKING_EXCLUDE.has('get_quality_metrics')).toBe(true);
+        });
+        it('SESSION_TOOLS contains session management', () => {
+            expect(SESSION_TOOLS.has('start_session')).toBe(true);
+            expect(SESSION_TOOLS.has('end_session')).toBe(true);
+        });
+        it('TOOL_TIMEOUTS has correct tiers', () => {
+            expect(TOOL_TIMEOUTS['index_codebase']).toBe(120_000);
+            expect(TOOL_TIMEOUTS['search_codebase']).toBe(15_000);
+            expect(TOOL_TIMEOUTS['recall']).toBe(10_000);
+        });
+    });
+});

package/dist/__tests__/tools/memory.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/tools/memory.test.js

@@ -0,0 +1,127 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { createMemoryTools } from '../../tools/memory';
+function createMockCtx() {
+    return {
+        api: {
+            post: vi.fn(),
+            get: vi.fn(),
+            delete: vi.fn(),
+            patch: vi.fn(),
+            defaults: { baseURL: 'http://localhost:3100' },
+        },
+        projectName: 'testproject',
+        projectPath: '/tmp/testproject',
+        collectionPrefix: 'testproject',
+        enrichmentEnabled: false,
+    };
+}
+describe('Memory Tools', () => {
+    let tools;
+    let ctx;
+    beforeEach(() => {
+        vi.resetAllMocks();
+        tools = createMemoryTools('testproject');
+        ctx = createMockCtx();
+    });
+    function findTool(name) {
+        return tools.find(t => t.name === name);
+    }
+    describe('remember', () => {
+        it('stores memory and returns formatted result', async () => {
+            const mem = { id: 'mem-1', type: 'note', content: 'test note', createdAt: new Date().toISOString() };
+            ctx.api.post.mockResolvedValue({ data: { memory: mem } });
+            const result = await findTool('remember').handler({ content: 'test note', type: 'note', tags: ['tag1'] }, ctx);
+            expect(ctx.api.post).toHaveBeenCalledWith('/api/memory', expect.objectContaining({
+                projectName: 'testproject',
+                content: 'test note',
+                type: 'note',
+            }));
+            expect(result).toContain('Memory stored');
+            expect(result).toContain('mem-1');
+        });
+    });
+    describe('recall', () => {
+        it('returns formatted results', async () => {
+            ctx.api.post.mockResolvedValue({
+                data: {
+                    results: [
+                        { memory: { type: 'insight', content: 'found it', createdAt: new Date().toISOString(), tags: [] }, score: 0.85 },
+                    ],
+                },
+            });
+            const result = await findTool('recall').handler({ query: 'find something', limit: 5 }, ctx);
+            expect(result).toContain('Recalled Memories');
+        });
+        it('returns empty message when no results', async () => {
+            ctx.api.post.mockResolvedValue({ data: { results: [] } });
+            const result = await findTool('recall').handler({ query: 'nothing' }, ctx);
+            expect(result).toContain('No memories found');
+        });
+    });
+    describe('forget', () => {
+        it('deletes by memoryId', async () => {
+            ctx.api.delete.mockResolvedValue({ data: { success: true } });
+            const result = await findTool('forget').handler({ memoryId: 'mem-1' }, ctx);
+            expect(ctx.api.delete).toHaveBeenCalledWith(expect.stringContaining('/api/memory/mem-1'));
+            expect(result).toContain('deleted');
+        });
+        it('deletes by type', async () => {
+            ctx.api.delete.mockResolvedValue({ data: {} });
+            const result = await findTool('forget').handler({ type: 'note' }, ctx);
+            expect(ctx.api.delete).toHaveBeenCalledWith(expect.stringContaining('/api/memory/type/note'));
+            expect(result).toContain('note');
+        });
+        it('deletes by olderThanDays', async () => {
+            ctx.api.post.mockResolvedValue({ data: { deleted: 10 } });
+            const result = await findTool('forget').handler({ olderThanDays: 30 }, ctx);
+            expect(ctx.api.post).toHaveBeenCalledWith('/api/memory/forget-older', expect.objectContaining({
+                olderThanDays: 30,
+            }));
+            expect(result).toContain('10');
+        });
+        it('returns message when nothing specified', async () => {
+            const result = await findTool('forget').handler({}, ctx);
+            expect(result).toContain('specify');
+        });
+    });
+    describe('promote_memory', () => {
+        it('promotes and returns formatted result', async () => {
+            const mem = { id: 'mem-1', type: 'insight', content: 'promoted' };
+            ctx.api.post.mockResolvedValue({ data: { memory: mem } });
+            const result = await findTool('promote_memory').handler({ memoryId: 'mem-1', reason: 'human_validated' }, ctx);
+            expect(result).toContain('promoted to durable');
+            expect(result).toContain('mem-1');
+        });
+    });
+    describe('memory_maintenance', () => {
+        it('formats maintenance results', async () => {
+            ctx.api.post.mockResolvedValue({
+                data: {
+                    quarantine_cleanup: { rejected: ['q-1', 'q-2'], errors: [] },
+                    feedback_maintenance: { promoted: ['f-1'], pruned: [], errors: [] },
+                },
+            });
+            const result = await findTool('memory_maintenance').handler({}, ctx);
+            expect(result).toContain('Maintenance Results');
+            expect(result).toContain('Quarantine Cleanup');
+            expect(result).toContain('Feedback Maintenance');
+        });
+    });
+    describe('batch_remember', () => {
+        it('stores multiple memories', async () => {
+            ctx.api.post.mockResolvedValue({
+                data: {
+                    savedCount: 2,
+                    memories: [
+                        { id: 'b-1', type: 'note', content: 'first' },
+                        { id: 'b-2', type: 'insight', content: 'second' },
+                    ],
+                    errors: [],
+                },
+            });
+            const result = await findTool('batch_remember').handler({ items: [{ content: 'first' }, { content: 'second', type: 'insight' }] }, ctx);
+            expect(result).toContain('Saved');
+            expect(result).toContain('2');
+        });
+    });
+});

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/memory.js

@@ -135,6 +135,7 @@ export function createMemoryTools(projectName) {
             handler: async (args, ctx) => {
                 const memoryId = args.memoryId;
                 const type = args.type;
+                const olderThanDays = args.olderThanDays;
                 if (memoryId) {
                     const response = await ctx.api.delete(`/api/memory/${memoryId}?projectName=${ctx.projectName}`);
                     return response.data.success
@@ -145,7 +146,14 @@ export function createMemoryTools(projectName) {
                     await ctx.api.delete(`/api/memory/type/${type}?projectName=${ctx.projectName}`);
                     return `\u{1F5D1}\uFE0F Deleted all memories of type: ${type}`;
                 }
-                return "Please specify memoryId or type to delete.";
+                if (olderThanDays) {
+                    const response = await ctx.api.post("/api/memory/forget-older", {
+                        projectName: ctx.projectName,
+                        olderThanDays,
+                    });
+                    return `\u{1F5D1}\uFE0F Deleted ${response.data.deleted} memories older than ${olderThanDays} days`;
+                }
+                return "Please specify memoryId, type, or olderThanDays to delete.";
             },
         },
         {
@@ -191,6 +199,7 @@ export function createMemoryTools(projectName) {
             handler: async (args, ctx) => {
                 const items = args.items;
                 const response = await ctx.api.post("/api/memory/batch", {
+                    projectName: ctx.projectName,
                     items,
                 });
                 const { savedCount, errors, memories } = response.data;
@@ -345,33 +354,81 @@ export function createMemoryTools(projectName) {
         },
         {
             name: "memory_maintenance",
-            description: `Run feedback-driven memory maintenance for ${projectName}: auto-promote memories with 3+ positive feedback, auto-prune memories with 2+ incorrect feedback.`,
-            schema: z.object({}),
+            description: `Run memory maintenance for ${projectName}: quarantine cleanup (expire old auto-memories), feedback-driven promote/prune, and compaction (merge similar durable memories).`,
+            schema: z.object({
+                operations: z.object({
+                    quarantine_cleanup: z.boolean().optional().describe("Remove expired quarantine memories (default: true)"),
+                    feedback_maintenance: z.boolean().optional().describe("Auto-promote/prune by feedback (default: true)"),
+                    compaction: z.boolean().optional().describe("Merge similar durable memories (default: false)"),
+                    compaction_dry_run: z.boolean().optional().describe("Preview compaction without changes (default: true)"),
+                }).optional().describe("Which operations to run (default: quarantine_cleanup + feedback_maintenance)"),
+            }),
             annotations: TOOL_ANNOTATIONS["memory_maintenance"],
-            handler: async (_args, ctx) => {
+            handler: async (args, ctx) => {
+                const operations = args.operations;
                 const response = await ctx.api.post("/api/memory/maintenance", {
                     projectName: ctx.projectName,
+                    operations,
                 });
-                const { promoted, pruned, errors } = response.data;
+                const data = response.data;
                 let result = `# \u{1F9F9} Memory Maintenance Results\n\n`;
-                if (promoted.length > 0) {
-                    result += `**Promoted** (${promoted.length}): memories with 3+ positive feedback moved to durable\n`;
-                    promoted.forEach((id) => { result += `  \u2705 ${id}\n`; });
+                // Quarantine cleanup section
+                if (data.quarantine_cleanup) {
+                    const qc = data.quarantine_cleanup;
+                    result += `## Quarantine Cleanup\n`;
+                    if (qc.rejected.length > 0) {
+                        result += `**Expired** (${qc.rejected.length}): removed from quarantine\n`;
+                        qc.rejected.slice(0, 10).forEach((id) => { result += `  \u{1F5D1}\u{FE0F} ${id}\n`; });
+                        if (qc.rejected.length > 10)
+                            result += `  ... and ${qc.rejected.length - 10} more\n`;
+                    }
+                    else {
+                        result += `No expired quarantine memories.\n`;
+                    }
+                    if (qc.errors.length > 0) {
+                        qc.errors.forEach((e) => { result += `  \u26A0\u{FE0F} ${e}\n`; });
+                    }
                     result += `\n`;
                 }
-                if (pruned.length > 0) {
-                    result += `**Pruned** (${pruned.length}): memories with 2+ incorrect feedback removed\n`;
-                    pruned.forEach((id) => { result += `  \u{1F5D1}\u{FE0F} ${id}\n`; });
+                // Feedback maintenance section
+                if (data.feedback_maintenance) {
+                    const fm = data.feedback_maintenance;
+                    result += `## Feedback Maintenance\n`;
+                    if (fm.promoted.length > 0) {
+                        result += `**Promoted** (${fm.promoted.length}): moved to durable\n`;
+                        fm.promoted.forEach((id) => { result += `  \u2705 ${id}\n`; });
+                    }
+                    if (fm.pruned.length > 0) {
+                        result += `**Pruned** (${fm.pruned.length}): removed\n`;
+                        fm.pruned.forEach((id) => { result += `  \u{1F5D1}\u{FE0F} ${id}\n`; });
+                    }
+                    if (fm.promoted.length === 0 && fm.pruned.length === 0) {
+                        result += `No feedback-based actions needed.\n`;
+                    }
+                    if (fm.errors.length > 0) {
+                        fm.errors.forEach((e) => { result += `  \u26A0\u{FE0F} ${e}\n`; });
+                    }
                     result += `\n`;
                 }
-                if (errors.length > 0) {
-                    result += `**Errors** (${errors.length}):\n`;
-                    errors.forEach((e) => { result += `  \u26A0\u{FE0F} ${e}\n`; });
+                // Compaction section
+                if (data.compaction) {
+                    const cp = data.compaction;
+                    result += `## Compaction${cp.dryRun ? ' (dry run)' : ''}\n`;
+                    if (cp.clusters.length > 0) {
+                        result += `**${cp.totalClusters} cluster(s)** of similar memories found\n\n`;
+                        cp.clusters.slice(0, 5).forEach((c, i) => {
+                            result += `${i + 1}. ${c.originalIds.length} memories → ${truncate(c.mergedContent, 120)}\n`;
+                            if (c.mergedId)
+                                result += `   Merged ID: \`${c.mergedId}\`\n`;
+                        });
+                        if (cp.clusters.length > 5)
+                            result += `... and ${cp.clusters.length - 5} more clusters\n`;
+                    }
+                    else {
+                        result += `No similar memory clusters found.\n`;
+                    }
                     result += `\n`;
                 }
-                if (promoted.length === 0 && pruned.length === 0) {
-                    result += `No memories needed maintenance. All feedback thresholds are below auto-action levels.\n`;
-                }
                 return result;
             },
         },

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.2.0",
   "description": "Universal RAG MCP Server for any project",
   "type": "module",
   "main": "dist/index.js",
@@ -14,7 +14,9 @@
     "build": "tsc",
     "dev": "tsc -w",
     "start": "node dist/index.js",
-    "prepublishOnly": "npm run build"
+    "prepublishOnly": "npm run build",
+    "test": "vitest run --passWithNoTests",
+    "test:watch": "vitest"
   },
   "keywords": [
     "mcp",
@@ -38,6 +40,7 @@
   },
   "devDependencies": {
     "@types/node": "^20.10.0",
-    "typescript": "^5.3.0"
+    "typescript": "^5.3.0",
+    "vitest": "^4.0.18"
   }
 }