@crowley/rag-mcp 1.1.0 → 1.2.1

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.js';
+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/tools/advanced.js

@@ -15,9 +15,9 @@ export function createAdvancedTools(projectName) {
             description: `Consolidate duplicate memories for ${projectName}. Finds similar memories and merges them using LLM to reduce clutter.`,
             schema: z.object({
                 type: z.string().optional().describe("Filter by memory type (decision, insight, context, todo, conversation, note, or all). Default: all"),
-                threshold: z.number().optional().describe("Similarity threshold for merging (0.5-1.0, default: 0.9). Lower = more aggressive merging."),
+                threshold: z.coerce.number().optional().describe("Similarity threshold for merging (0.5-1.0, default: 0.9). Lower = more aggressive merging."),
                 dryRun: z.boolean().optional().describe("If true, preview merge candidates without making changes (default: true)."),
-                limit: z.number().optional().describe("Max clusters to process (default: 50)."),
+                limit: z.coerce.number().optional().describe("Max clusters to process (default: 50)."),
             }),
             annotations: TOOL_ANNOTATIONS["merge_memories"],
             handler: async (args, ctx) => {
@@ -65,7 +65,7 @@ export function createAdvancedTools(projectName) {
                 currentFile: z.string().describe("Path of the file being edited"),
                 currentCode: z.string().describe("Current code snippet or file content"),
                 language: z.string().optional().describe("Programming language filter (optional)"),
-                limit: z.number().optional().describe("Max results (default: 5)"),
+                limit: z.coerce.number().optional().describe("Max results (default: 5)"),
             }),
             annotations: TOOL_ANNOTATIONS["get_completion_context"],
             handler: async (args, ctx) => {
@@ -108,7 +108,7 @@ export function createAdvancedTools(projectName) {
                 currentFile: z.string().describe("Path of the file being edited"),
                 currentCode: z.string().describe("Current code content"),
                 language: z.string().optional().describe("Programming language filter (optional)"),
-                limit: z.number().optional().describe("Max suggestions (default: 10)"),
+                limit: z.coerce.number().optional().describe("Max suggestions (default: 10)"),
             }),
             annotations: TOOL_ANNOTATIONS["get_import_suggestions"],
             handler: async (args, ctx) => {
@@ -147,7 +147,7 @@ export function createAdvancedTools(projectName) {
                 typeName: z.string().optional().describe("Name of the type/interface/class to look up"),
                 code: z.string().optional().describe("Code containing types to look up (alternative to typeName)"),
                 currentFile: z.string().optional().describe("Current file to exclude from results"),
-                limit: z.number().optional().describe("Max results per category (default: 5)"),
+                limit: z.coerce.number().optional().describe("Max results per category (default: 5)"),
             }),
             annotations: TOOL_ANNOTATIONS["get_type_context"],
             handler: async (args, ctx) => {
@@ -187,7 +187,7 @@ export function createAdvancedTools(projectName) {
             name: "get_behavior_patterns",
             description: `Analyze user workflow patterns for ${projectName}. Shows peak hours, tool preferences, common sequences, and session statistics.`,
             schema: z.object({
-                days: z.number().optional().describe("Number of days to analyze (default: 7)"),
+                days: z.coerce.number().optional().describe("Number of days to analyze (default: 7)"),
                 sessionId: z.string().optional().describe("Filter to a specific session (optional)"),
             }),
             annotations: TOOL_ANNOTATIONS["get_behavior_patterns"],

package/dist/tools/agents.js

@@ -15,7 +15,7 @@ export function createAgentTools(projectName) {
                 type: z.enum(["research", "review", "documentation", "refactor", "test"]).describe("Agent type: research, review, documentation, refactor, or test"),
                 task: z.string().describe("The task for the agent to perform"),
                 context: z.string().optional().describe("Optional additional context (code, requirements, etc.)"),
-                maxIterations: z.number().optional().describe("Maximum ReAct iterations (default: varies by agent type)"),
+                maxIterations: z.coerce.number().optional().describe("Maximum ReAct iterations (default: varies by agent type)"),
             }),
             annotations: TOOL_ANNOTATIONS["run_agent"],
             handler: async (args, ctx) => {

package/dist/tools/analytics.js

@@ -154,7 +154,7 @@ export function createAnalyticsTools(projectName) {
             description: `Enable scalar quantization on a ${projectName} collection to reduce memory usage.`,
             schema: z.object({
                 collectionName: z.string().describe("Collection name to enable quantization on"),
-                quantile: z.number().optional().describe("Quantile for quantization (0-1, default: 0.99)"),
+                quantile: z.coerce.number().optional().describe("Quantile for quantization (0-1, default: 0.99)"),
             }),
             annotations: TOOL_ANNOTATIONS["enable_quantization"],
             handler: async (args, ctx) => {

package/dist/tools/architecture.js

@@ -56,7 +56,7 @@ ${alternatives ? `## Alternatives Considered\n${alternatives}` : ""}`;
             schema: z.object({
                 query: z.string().optional().describe("Search query (optional - returns all if empty)"),
                 status: z.enum(["proposed", "accepted", "deprecated", "superseded", "all"]).optional().describe("Filter by status"),
-                limit: z.number().optional().describe("Max results (default: 10)"),
+                limit: z.coerce.number().optional().describe("Max results (default: 10)"),
             }),
             annotations: TOOL_ANNOTATIONS["get_adrs"],
             handler: async (args, ctx) => {
@@ -138,7 +138,7 @@ ${appliesTo ? `## Applies To\n${appliesTo}` : ""}`;
             schema: z.object({
                 query: z.string().optional().describe("Search for patterns by name or description"),
                 appliesTo: z.string().optional().describe("Filter by what patterns apply to (e.g., 'api', 'module')"),
-                limit: z.number().optional().describe("Max results (default: 10)"),
+                limit: z.coerce.number().optional().describe("Max results (default: 10)"),
             }),
             annotations: TOOL_ANNOTATIONS["get_patterns"],
             handler: async (args, ctx) => {
@@ -437,7 +437,7 @@ ${relatedAdr ? `## Related ADR\n${relatedAdr}` : ""}`;
             description: `List technical debt items for ${projectName}.`,
             schema: z.object({
                 impact: z.enum(["low", "medium", "high", "critical", "all"]).optional().describe("Filter by impact"),
-                limit: z.number().optional().describe("Max results (default: 10)"),
+                limit: z.coerce.number().optional().describe("Max results (default: 10)"),
             }),
             annotations: TOOL_ANNOTATIONS["get_tech_debt"],
             handler: async (args, ctx) => {

package/dist/tools/ask.js

@@ -99,7 +99,7 @@ export function createAskTools(projectName) {
                 conversation: z.string().describe("The conversation text to analyze"),
                 context: z.string().optional().describe("Additional context about the conversation"),
                 autoSave: z.boolean().optional().describe("Automatically save extracted learnings (default: false)"),
-                minConfidence: z.number().optional().describe("Minimum confidence threshold for learnings (0-1, default: 0.7)"),
+                minConfidence: z.coerce.number().optional().describe("Minimum confidence threshold for learnings (0-1, default: 0.7)"),
             }),
             annotations: TOOL_ANNOTATIONS["analyze_conversation"],
             handler: async (args, ctx) => {

package/dist/tools/clustering.js

@@ -15,8 +15,8 @@ export function createClusteringTools(projectName) {
             description: `Cluster code in the ${projectName} codebase by similarity. Groups related files around seed points.`,
             schema: z.object({
                 seedIds: z.array(z.string()).describe("Seed point IDs to cluster around"),
-                limit: z.number().optional().describe("Max results per cluster (default: 5)"),
-                threshold: z.number().optional().describe("Minimum similarity threshold (0-1, default: 0.7)"),
+                limit: z.coerce.number().optional().describe("Max results per cluster (default: 5)"),
+                threshold: z.coerce.number().optional().describe("Minimum similarity threshold (0-1, default: 0.7)"),
             }),
             annotations: TOOL_ANNOTATIONS["cluster_code"],
             handler: async (args, ctx) => {
@@ -52,8 +52,8 @@ export function createClusteringTools(projectName) {
             description: `Find duplicate or near-duplicate code in ${projectName}. Groups similar files by content.`,
             schema: z.object({
                 collection: z.string().optional().describe("Collection to search (default: codebase)"),
-                limit: z.number().optional().describe("Max duplicate groups to return (default: 10)"),
-                threshold: z.number().optional().describe("Minimum similarity threshold (0-1, default: 0.9)"),
+                limit: z.coerce.number().optional().describe("Max duplicate groups to return (default: 10)"),
+                threshold: z.coerce.number().optional().describe("Minimum similarity threshold (0-1, default: 0.9)"),
             }),
             annotations: TOOL_ANNOTATIONS["find_duplicates"],
             handler: async (args, ctx) => {
@@ -97,7 +97,7 @@ export function createClusteringTools(projectName) {
             schema: z.object({
                 positiveIds: z.array(z.string()).describe("IDs of vectors to find similar code to"),
                 negativeIds: z.array(z.string()).optional().describe("IDs of vectors to avoid (dissimilar)"),
-                limit: z.number().optional().describe("Max results (default: 5)"),
+                limit: z.coerce.number().optional().describe("Max results (default: 5)"),
             }),
             annotations: TOOL_ANNOTATIONS["recommend_similar"],
             handler: async (args, ctx) => {
@@ -129,7 +129,7 @@ export function createClusteringTools(projectName) {
                 text: z.string().describe("Text to extract learnings from"),
                 context: z.string().optional().describe("Additional context about the text"),
                 autoSave: z.boolean().optional().describe("Automatically save extracted learnings (default: false)"),
-                minConfidence: z.number().optional().describe("Minimum confidence threshold (0-1, default: 0.7)"),
+                minConfidence: z.coerce.number().optional().describe("Minimum confidence threshold (0-1, default: 0.7)"),
             }),
             annotations: TOOL_ANNOTATIONS["extract_learnings"],
             handler: async (args, ctx) => {

package/dist/tools/confluence.js

@@ -15,7 +15,7 @@ export function createConfluenceTools(projectName) {
             description: `Search indexed Confluence documentation for ${projectName}. Returns relevant pages with content snippets.`,
             schema: z.object({
                 query: z.string().describe("Search query for Confluence content"),
-                limit: z.number().optional().describe("Max results (default: 5)"),
+                limit: z.coerce.number().optional().describe("Max results (default: 5)"),
                 spaceKey: z.string().optional().describe("Filter by Confluence space key"),
             }),
             annotations: TOOL_ANNOTATIONS["search_confluence"],
@@ -46,7 +46,7 @@ export function createConfluenceTools(projectName) {
             schema: z.object({
                 spaceKeys: z.array(z.string()).optional().describe("Specific space keys to index (indexes all accessible if empty)"),
                 labels: z.array(z.string()).optional().describe("Filter pages by labels"),
-                maxPages: z.number().optional().describe("Maximum pages to index (default: 500)"),
+                maxPages: z.coerce.number().optional().describe("Maximum pages to index (default: 500)"),
                 force: z.boolean().optional().describe("Force re-index even if already indexed"),
             }),
             annotations: TOOL_ANNOTATIONS["index_confluence"],

package/dist/tools/indexing.js

@@ -138,10 +138,10 @@ export function createIndexingTools(projectName) {
             schema: z.object({}),
             outputSchema: z.object({
                 status: z.string(),
-                totalFiles: z.number().optional(),
-                indexedFiles: z.number().optional(),
+                totalFiles: z.coerce.number().optional(),
+                indexedFiles: z.coerce.number().optional(),
                 lastUpdated: z.string().optional(),
-                vectorCount: z.number().optional(),
+                vectorCount: z.coerce.number().optional(),
                 cached: z.boolean(),
             }),
             annotations: TOOL_ANNOTATIONS["get_index_status"],

package/dist/tools/memory.js

@@ -62,7 +62,7 @@ export function createMemoryTools(projectName) {
             schema: z.object({
                 query: z.string().describe("What to recall (semantic search)"),
                 type: z.enum(["decision", "insight", "context", "todo", "conversation", "note", "all"]).optional().describe("Filter by memory type (default: all)"),
-                limit: z.number().optional().describe("Max memories to retrieve (default: 5)"),
+                limit: z.coerce.number().optional().describe("Max memories to retrieve (default: 5)"),
             }),
             annotations: TOOL_ANNOTATIONS["recall"],
             handler: async (args, ctx) => {
@@ -89,8 +89,8 @@ export function createMemoryTools(projectName) {
             schema: z.object({
                 type: z.enum(["decision", "insight", "context", "todo", "conversation", "note", "all"]).optional().describe("Filter by type"),
                 tag: z.string().optional().describe("Filter by tag"),
-                limit: z.number().optional().describe("Max results (default: 10)"),
-                offset: z.number().optional().describe("Pagination offset (default: 0)"),
+                limit: z.coerce.number().optional().describe("Max results (default: 10)"),
+                offset: z.coerce.number().optional().describe("Pagination offset (default: 0)"),
             }),
             annotations: TOOL_ANNOTATIONS["list_memories"],
             handler: async (args, ctx) => {
@@ -129,12 +129,13 @@ export function createMemoryTools(projectName) {
             schema: z.object({
                 memoryId: z.string().optional().describe("Specific memory ID to delete"),
                 type: z.enum(["decision", "insight", "context", "todo", "conversation", "note"]).optional().describe("Delete all memories of this type"),
-                olderThanDays: z.number().optional().describe("Delete memories older than N days"),
+                olderThanDays: z.coerce.number().optional().describe("Delete memories older than N days"),
             }),
             annotations: TOOL_ANNOTATIONS["forget"],
             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;
@@ -238,8 +247,8 @@ export function createMemoryTools(projectName) {
             name: "review_memories",
             description: `Get auto-extracted memories pending review in ${projectName}. Shows unvalidated learnings that need human confirmation.`,
             schema: z.object({
-                limit: z.number().optional().describe("Max memories to return (default: 20)"),
-                offset: z.number().optional().describe("Pagination offset (default: 0)"),
+                limit: z.coerce.number().optional().describe("Max memories to return (default: 20)"),
+                offset: z.coerce.number().optional().describe("Pagination offset (default: 0)"),
             }),
             annotations: TOOL_ANNOTATIONS["review_memories"],
             handler: async (args, ctx) => {
@@ -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/pm.js

@@ -15,7 +15,7 @@ export function createPmTools(projectName) {
             description: `Search technical requirements and product documentation for ${projectName}. Finds relevant requirements, user stories, and specifications from Confluence.`,
             schema: z.object({
                 query: z.string().describe("Search query for requirements (e.g., 'video inspection flow', 'payment integration')"),
-                limit: z.number().optional().describe("Max results (default: 5)"),
+                limit: z.coerce.number().optional().describe("Max results (default: 5)"),
             }),
             annotations: TOOL_ANNOTATIONS["search_requirements"],
             handler: async (args, ctx) => {
@@ -236,8 +236,8 @@ export function createPmTools(projectName) {
             description: `List all documented requirements/features for ${projectName} from Confluence. Groups by category or status.`,
             schema: z.object({
                 category: z.string().optional().describe("Filter by category (optional)"),
-                limit: z.number().optional().describe("Max results (default: 20)"),
-                offset: z.number().optional().describe("Pagination offset (default: 0)"),
+                limit: z.coerce.number().optional().describe("Max results (default: 20)"),
+                offset: z.coerce.number().optional().describe("Pagination offset (default: 0)"),
             }),
             annotations: TOOL_ANNOTATIONS["list_requirements"],
             handler: async (args, ctx) => {

package/dist/tools/search.js

@@ -15,7 +15,7 @@ export function createSearchTools(projectName) {
             description: `Search the ${projectName} codebase. Returns file locations, symbols, and graph connections. Use Read tool to view the actual code at returned locations.`,
             schema: z.object({
                 query: z.string().describe("Search query for finding code"),
-                limit: z.number().optional().describe("Max results to return (default: 5)"),
+                limit: z.coerce.number().optional().describe("Max results to return (default: 5)"),
                 language: z.string().optional().describe("Filter by language (typescript, python, vue, etc.)"),
                 path: z.string().optional().describe("Filter by path pattern (e.g., 'src/modules/*')"),
                 layer: z.string().optional().describe("Filter by architectural layer (api, service, util, model, middleware, test, parser, types, config, other)"),
@@ -43,7 +43,7 @@ export function createSearchTools(projectName) {
             description: "Find code similar to a given snippet.",
             schema: z.object({
                 code: z.string().describe("Code snippet to find similar code for"),
-                limit: z.number().optional().describe("Max results (default: 5)"),
+                limit: z.coerce.number().optional().describe("Max results (default: 5)"),
             }),
             annotations: TOOL_ANNOTATIONS["search_similar"],
             handler: async (args, ctx) => {
@@ -66,7 +66,7 @@ export function createSearchTools(projectName) {
             schema: z.object({
                 query: z.string().describe("Search query"),
                 groupBy: z.string().optional().describe("Field to group by (default: 'file')"),
-                limit: z.number().optional().describe("Max groups to return (default: 10)"),
+                limit: z.coerce.number().optional().describe("Max groups to return (default: 10)"),
                 language: z.string().optional().describe("Filter by language"),
                 layer: z.string().optional().describe("Filter by architectural layer (api, service, util, etc.)"),
                 service: z.string().optional().describe("Filter by service/class name"),
@@ -97,8 +97,8 @@ export function createSearchTools(projectName) {
             description: `Hybrid search combining keyword matching and semantic similarity for ${projectName}. Returns file locations with symbols and connections. Use Read tool to view code.`,
             schema: z.object({
                 query: z.string().describe("Search query"),
-                limit: z.number().optional().describe("Max results (default: 10)"),
-                semanticWeight: z.number().optional().describe("Weight for semantic vs keyword (0-1, default: 0.7)"),
+                limit: z.coerce.number().optional().describe("Max results (default: 10)"),
+                semanticWeight: z.coerce.number().optional().describe("Weight for semantic vs keyword (0-1, default: 0.7)"),
                 language: z.string().optional().describe("Filter by language"),
                 layer: z.string().optional().describe("Filter by architectural layer (api, service, util, etc.)"),
                 service: z.string().optional().describe("Filter by service/class name"),
@@ -128,7 +128,7 @@ export function createSearchTools(projectName) {
             description: `Search documentation in the ${projectName} project.`,
             schema: z.object({
                 query: z.string().describe("Search query"),
-                limit: z.number().optional().describe("Max results (default: 5)"),
+                limit: z.coerce.number().optional().describe("Max results (default: 5)"),
             }),
             annotations: TOOL_ANNOTATIONS["search_docs"],
             handler: async (args, ctx) => {
@@ -154,11 +154,11 @@ export function createSearchTools(projectName) {
             schema: z.object({}),
             outputSchema: z.object({
                 projectName: z.string(),
-                totalFiles: z.number(),
-                totalLines: z.number().optional(),
-                vectorCount: z.number(),
+                totalFiles: z.coerce.number(),
+                totalLines: z.coerce.number().optional(),
+                vectorCount: z.coerce.number(),
                 lastIndexed: z.string().optional(),
-                languages: z.record(z.string(), z.number()).optional(),
+                languages: z.record(z.string(), z.coerce.number()).optional(),
             }),
             annotations: TOOL_ANNOTATIONS["get_project_stats"],
             handler: async (_args, ctx) => {
@@ -194,15 +194,15 @@ export function createSearchTools(projectName) {
             schema: z.object({
                 symbol: z.string().describe("Symbol name to find (function, class, type, etc.)"),
                 kind: z.string().optional().describe("Filter by kind: function, class, interface, type, enum, const"),
-                limit: z.number().optional().describe("Max results (default: 10)"),
+                limit: z.coerce.number().optional().describe("Max results (default: 10)"),
             }),
             outputSchema: z.object({
                 symbols: z.array(z.object({
                     kind: z.string(),
                     name: z.string(),
                     file: z.string(),
-                    startLine: z.number(),
-                    endLine: z.number(),
+                    startLine: z.coerce.number(),
+                    endLine: z.coerce.number(),
                     signature: z.string(),
                     exported: z.boolean(),
                 })),
@@ -246,8 +246,8 @@ export function createSearchTools(projectName) {
             description: `Search ${projectName} codebase with graph expansion. Returns file locations plus connected files via import/call relationships. Use Read tool to view code.`,
             schema: z.object({
                 query: z.string().describe("Search query"),
-                limit: z.number().optional().describe("Max direct results (default: 5)"),
-                expandHops: z.number().optional().describe("Number of graph hops to expand (default: 1)"),
+                limit: z.coerce.number().optional().describe("Max direct results (default: 5)"),
+                expandHops: z.coerce.number().optional().describe("Number of graph hops to expand (default: 1)"),
             }),
             annotations: TOOL_ANNOTATIONS["search_graph"],
             handler: async (args, ctx) => {

package/dist/tools/session.js

@@ -102,7 +102,7 @@ export function createSessionTools(projectName, sharedCtx) {
             name: "analyze_usage_patterns",
             description: `Analyze tool usage patterns for ${projectName}. Shows common workflows, detected patterns, and recommendations for improving productivity.`,
             schema: z.object({
-                days: z.number().optional().describe("Number of days to analyze (default: 7)."),
+                days: z.coerce.number().optional().describe("Number of days to analyze (default: 7)."),
             }),
             annotations: TOOL_ANNOTATIONS["analyze_usage_patterns"],
             handler: async (args, ctx) => {

package/dist/tools/suggestions.js

@@ -290,7 +290,7 @@ export function createSuggestionTools(projectName) {
             schema: z.object({
                 file: z.string().optional().describe("File path to find related code for"),
                 code: z.string().optional().describe("Code snippet to find related code for"),
-                limit: z.number().optional().describe("Max results (default: 5)"),
+                limit: z.coerce.number().optional().describe("Max results (default: 5)"),
             }),
             annotations: TOOL_ANNOTATIONS["suggest_related_code"],
             handler: async (args, ctx) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@crowley/rag-mcp",
-  "version": "1.1.0",
+  "version": "1.2.1",
   "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"
   }
 }