@crowley/rag-mcp 1.3.0 → 1.6.0

package/dist/context-enrichment.js

@@ -45,6 +45,8 @@ export const DEFAULT_SKIP_TOOLS = new Set([
 ]);
 export class ContextEnricher {
     config;
+    cache = new Map();
+    static CACHE_TTL_MS = 5 * 60 * 1000; // 5 minutes
     constructor(config = {}) {
         this.config = {
             enrichableTools: config.enrichableTools ?? DEFAULT_ENRICHABLE_TOOLS,
@@ -54,6 +56,12 @@ export class ContextEnricher {
             timeoutMs: config.timeoutMs ?? 2000,
         };
     }
+    /**
+     * Clear enrichment cache (call on session end).
+     */
+    clearCache() {
+        this.cache.clear();
+    }
     /**
      * Before hook: auto-recall relevant memories/patterns/ADRs.
      * Returns a context prefix string or null if nothing relevant found.
@@ -68,11 +76,29 @@ export class ContextEnricher {
         const query = this.extractQuery(args);
         if (!query)
             return null;
+        // Check per-session cache
+        const cacheKey = `${ctx.activeSessionId || "no-session"}:${query.slice(0, 100)}`;
+        const cached = this.cache.get(cacheKey);
+        if (cached && Date.now() < cached.expiresAt) {
+            return cached.result;
+        }
         try {
             const memories = await this.recallWithTimeout(query, ctx);
-            if (memories.length === 0)
-                return null;
-            return this.formatContext(memories);
+            const result = memories.length === 0 ? null : this.formatContext(memories);
+            // Store in cache
+            this.cache.set(cacheKey, {
+                result,
+                expiresAt: Date.now() + ContextEnricher.CACHE_TTL_MS,
+            });
+            // Evict expired entries lazily (every 50 calls)
+            if (this.cache.size > 100) {
+                const now = Date.now();
+                for (const [key, entry] of this.cache) {
+                    if (now > entry.expiresAt)
+                        this.cache.delete(key);
+                }
+            }
+            return result;
         }
         catch {
             // Enrichment should never break tool calls
@@ -150,8 +176,10 @@ export class ContextEnricher {
         const controller = new AbortController();
         const timeout = setTimeout(() => controller.abort(), this.config.timeoutMs);
         try {
-            // Parallel recall: general memories + decisions/ADRs
-            const [memoriesRes, decisionsRes] = await Promise.all([
+            // Parallel recall: general memories + decisions/ADRs + LTM (when enabled)
+            const graphRecallEnabled = process.env.GRAPH_RECALL_ENABLED === "true";
+            const consolidationEnabled = process.env.CONSOLIDATION_ENABLED === "true";
+            const recalls = [
                 ctx.api
                     .post("/api/memory/recall-durable", {
                     projectName: ctx.projectName,
@@ -168,13 +196,26 @@ export class ContextEnricher {
                     type: "decision",
                 }, { signal: controller.signal })
                     .catch(() => null),
-            ]);
+            ];
+            // Phase 2+4: also recall from LTM (episodic+semantic with Ebbinghaus decay)
+            if (consolidationEnabled) {
+                recalls.push(ctx.api
+                    .post("/api/memory/recall-ltm", {
+                    projectName: ctx.projectName,
+                    query,
+                    limit: this.config.maxAutoRecall,
+                    graphRecall: graphRecallEnabled,
+                }, { signal: controller.signal })
+                    .catch(() => null));
+            }
+            const [memoriesRes, decisionsRes, ltmRes] = await Promise.all(recalls);
             const memories = [];
             const seenIds = new Set();
             // Process general memories
             if (memoriesRes?.data?.memories) {
                 for (const m of memoriesRes.data.memories) {
-                    if (m.score >= this.config.minRelevance && !seenIds.has(m.memory?.id)) {
+                    if (m.score >= this.config.minRelevance &&
+                        !seenIds.has(m.memory?.id)) {
                         seenIds.add(m.memory?.id);
                         memories.push({
                             type: m.memory?.type || "note",
@@ -187,7 +228,8 @@ export class ContextEnricher {
             // Process decisions/ADRs
             if (decisionsRes?.data?.memories) {
                 for (const m of decisionsRes.data.memories) {
-                    if (m.score >= this.config.minRelevance && !seenIds.has(m.memory?.id)) {
+                    if (m.score >= this.config.minRelevance &&
+                        !seenIds.has(m.memory?.id)) {
                         seenIds.add(m.memory?.id);
                         memories.push({
                             type: m.memory?.type || "decision",
@@ -197,6 +239,23 @@ export class ContextEnricher {
                     }
                 }
             }
+            // Process LTM results (episodic + semantic)
+            if (ltmRes?.data?.results) {
+                for (const r of ltmRes.data.results) {
+                    const mem = r.memory;
+                    const id = mem?.id;
+                    if (r.score >= this.config.minRelevance && id && !seenIds.has(id)) {
+                        seenIds.add(id);
+                        memories.push({
+                            type: mem?.subtype || mem?.type || "insight",
+                            content: mem?.content || "",
+                            score: r.score,
+                        });
+                    }
+                }
+            }
+            // Sort by score and limit
+            memories.sort((a, b) => b.score - a.score);
             return memories.slice(0, this.config.maxAutoRecall + 2);
         }
         finally {

package/dist/formatters.js

@@ -25,7 +25,9 @@ export function formatCodeResults(results, contentLimit = PREVIEW.LONG) {
     return results
         .map((r) => `**${r.file}** (${pct(r.score)} match)\n` +
         (r.startLine ? `Lines ${r.startLine}-${r.endLine || "?"}\n` : "") +
-        "```" + (r.language || "") + "\n" +
+        "```" +
+        (r.language || "") +
+        "\n" +
         truncate(r.content, contentLimit) +
         "\n```")
         .join("\n\n---\n\n");
@@ -46,7 +48,7 @@ export function formatMemoryResults(results, emptyMessage = "No memories found."
     results.forEach((r, i) => {
         const m = r.memory;
         const type = m.type;
-        const emoji = type === "todo" && m.status === "done" ? "✅" : (typeEmojis[type] || "📝");
+        const emoji = type === "todo" && m.status === "done" ? "✅" : typeEmojis[type] || "📝";
         result += `### ${i + 1}. ${emoji} ${(type || "note").toUpperCase()}\n`;
         result += `**Relevance:** ${pct(r.score)}\n`;
         result += `${m.content}\n`;
@@ -64,21 +66,23 @@ export function formatMemoryResults(results, emptyMessage = "No memories found."
 export function formatNavigationResults(results) {
     if (!results?.length)
         return "No results found.";
-    return results.map(r => {
-        const loc = r.lines ? `:${r.lines[0]}-${r.lines[1]}` : '';
+    return results
+        .map((r) => {
+        const loc = r.lines ? `:${r.lines[0]}-${r.lines[1]}` : "";
         let out = `**${r.file}${loc}** (${pct(r.score)})`;
         if (r.layer)
             out += ` [${r.layer}]`;
         if (r.graphExpanded)
-            out += ' _(graph)_';
+            out += " _(graph)_";
         if (r.preview)
             out += `\n\`${truncate(r.preview, 100)}\``;
         if (r.symbols?.length)
-            out += `\nSymbols: ${r.symbols.join(', ')}`;
+            out += `\nSymbols: ${r.symbols.join(", ")}`;
         if (r.connections?.length)
-            out += `\nConnections: ${r.connections.map(c => '`' + c + '`').join(', ')}`;
+            out += `\nConnections: ${r.connections.map((c) => "`" + c + "`").join(", ")}`;
         return out;
-    }).join('\n\n');
+    })
+        .join("\n\n");
 }
 /** Format pagination footer for list tools */
 export function paginationFooter(count, limit, offset) {

package/dist/http-transport.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Streamable HTTP transport for MCP server.
+ * Enables dashboard and remote clients to connect over HTTP.
+ *
+ * Env:
+ *   MCP_TRANSPORT   — stdio | http | both (default: stdio)
+ *   MCP_HTTP_PORT   — port for HTTP transport (default: 3101)
+ *   RAG_API_KEY     — required for Bearer auth when HTTP is enabled
+ */
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export interface HttpTransportConfig {
+    port: number;
+    apiKey?: string;
+}
+export declare function startHttpTransport(server: McpServer, config: HttpTransportConfig): Promise<void>;

package/dist/http-transport.js

@@ -0,0 +1,109 @@
+/**
+ * Streamable HTTP transport for MCP server.
+ * Enables dashboard and remote clients to connect over HTTP.
+ *
+ * Env:
+ *   MCP_TRANSPORT   — stdio | http | both (default: stdio)
+ *   MCP_HTTP_PORT   — port for HTTP transport (default: 3101)
+ *   RAG_API_KEY     — required for Bearer auth when HTTP is enabled
+ */
+import { createServer, } from "node:http";
+import { randomUUID } from "node:crypto";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+export async function startHttpTransport(server, config) {
+    // Per-session transport instances
+    const transports = new Map();
+    function checkAuth(req, res) {
+        if (!config.apiKey)
+            return true;
+        const auth = req.headers.authorization;
+        if (auth !== `Bearer ${config.apiKey}`) {
+            res.writeHead(401, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ error: "Unauthorized" }));
+            return false;
+        }
+        return true;
+    }
+    function parseBody(req) {
+        return new Promise((resolve, reject) => {
+            const chunks = [];
+            req.on("data", (chunk) => chunks.push(chunk));
+            req.on("end", () => {
+                try {
+                    const body = Buffer.concat(chunks).toString();
+                    resolve(body ? JSON.parse(body) : undefined);
+                }
+                catch (e) {
+                    reject(e);
+                }
+            });
+            req.on("error", reject);
+        });
+    }
+    const httpServer = createServer(async (req, res) => {
+        // Only handle /mcp path
+        const url = new URL(req.url || "/", `http://${req.headers.host || "localhost"}`);
+        if (url.pathname !== "/mcp") {
+            res.writeHead(404, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ error: "Not found" }));
+            return;
+        }
+        if (!checkAuth(req, res))
+            return;
+        const sessionId = req.headers["mcp-session-id"];
+        if (req.method === "POST") {
+            const body = await parseBody(req).catch(() => undefined);
+            let transport = sessionId ? transports.get(sessionId) : undefined;
+            if (!transport) {
+                // New session — create transport and connect to MCP server
+                transport = new StreamableHTTPServerTransport({
+                    sessionIdGenerator: () => randomUUID(),
+                });
+                transport.onclose = () => {
+                    if (transport.sessionId) {
+                        transports.delete(transport.sessionId);
+                    }
+                };
+                await server.connect(transport);
+                if (transport.sessionId) {
+                    transports.set(transport.sessionId, transport);
+                }
+            }
+            await transport.handleRequest(req, res, body);
+        }
+        else if (req.method === "GET") {
+            // SSE stream for server-initiated messages
+            if (!sessionId) {
+                res.writeHead(400, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ error: "Missing mcp-session-id header" }));
+                return;
+            }
+            const transport = transports.get(sessionId);
+            if (!transport) {
+                res.writeHead(404, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ error: "Session not found" }));
+                return;
+            }
+            await transport.handleRequest(req, res);
+        }
+        else if (req.method === "DELETE") {
+            // Close session
+            if (sessionId) {
+                const transport = transports.get(sessionId);
+                if (transport) {
+                    await transport.close();
+                    transports.delete(sessionId);
+                }
+            }
+            res.writeHead(200);
+            res.end();
+        }
+        else {
+            res.writeHead(405, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ error: "Method not allowed" }));
+        }
+    });
+    httpServer.listen(config.port, "127.0.0.1", () => {
+        console.error(`MCP HTTP transport listening on http://127.0.0.1:${config.port}/mcp`);
+    });
+}

package/dist/index.js

@@ -13,8 +13,16 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { createApiClient } from "./api-client.js";
+import { configureConnectionPool } from "./connection-pool.js";
 import { ContextEnricher } from "./context-enrichment.js";
+import { startHttpTransport } from "./http-transport.js";
 import { wrapHandler } from "./tool-middleware.js";
+// Phase 3: Configure undici connection pool for RAG API communication
+configureConnectionPool({
+    connections: parseInt(process.env.MCP_POOL_CONNECTIONS || "10"),
+    keepAliveTimeout: parseInt(process.env.MCP_POOL_KEEPALIVE || "30000"),
+    pipelining: parseInt(process.env.MCP_POOL_PIPELINING || "1"),
+});
 // Tool modules
 import { createSearchTools } from "./tools/search.js";
 import { createAskTools } from "./tools/ask.js";
@@ -51,6 +59,11 @@ const ctx = {
     collectionPrefix: COLLECTION_PREFIX,
     enrichmentEnabled: true,
 };
+// If session ID was injected by SessionStart hook, use it
+const hookSessionId = process.env.RAG_SESSION_ID;
+if (hookSessionId) {
+    ctx.activeSessionId = hookSessionId;
+}
 // Context enrichment middleware
 const enricher = new ContextEnricher({
     maxAutoRecall: 3,
@@ -169,11 +182,21 @@ async function cleanup() {
 }
 process.on("SIGINT", cleanup);
 process.on("SIGTERM", cleanup);
-// Start server
+// Phase 4: Transport selection — stdio | http | both
+const MCP_TRANSPORT = process.env.MCP_TRANSPORT || "stdio";
+const MCP_HTTP_PORT = parseInt(process.env.MCP_HTTP_PORT || "3101");
 async function main() {
-    const transport = new StdioServerTransport();
-    await server.connect(transport);
-    console.error(`${PROJECT_NAME} RAG MCP server running (collection prefix: ${COLLECTION_PREFIX})`);
+    if (MCP_TRANSPORT === "stdio" || MCP_TRANSPORT === "both") {
+        const transport = new StdioServerTransport();
+        await server.connect(transport);
+    }
+    if (MCP_TRANSPORT === "http" || MCP_TRANSPORT === "both") {
+        await startHttpTransport(server, {
+            port: MCP_HTTP_PORT,
+            apiKey: RAG_API_KEY,
+        });
+    }
+    console.error(`${PROJECT_NAME} RAG MCP server running (transport: ${MCP_TRANSPORT}, prefix: ${COLLECTION_PREFIX})`);
     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.js

@@ -22,10 +22,7 @@ export function zodToInputSchema(schema) {
     };
 }
 // ── Primitives ──────────────────────────────────────────────
-export const QueryStr = z
-    .string()
-    .min(1)
-    .describe("Search query or question");
+export const QueryStr = z.string().min(1).describe("Search query or question");
 export const Limit = z
     .number()
     .int()
@@ -47,10 +44,7 @@ export const FilePaths = z
     .array(FilePath)
     .min(1)
     .describe("List of file paths");
-export const Content = z
-    .string()
-    .min(1)
-    .describe("Text content");
+export const Content = z.string().min(1).describe("Text content");
 export const CollectionSuffix = z
     .string()
     .min(1)
@@ -93,10 +87,7 @@ export const SearchFilters = z
         .string()
         .optional()
         .describe("Filter by file extension (e.g. 'ts', 'py')"),
-    directory: z
-        .string()
-        .optional()
-        .describe("Filter by directory prefix"),
+    directory: z.string().optional().describe("Filter by directory prefix"),
 })
     .optional()
     .describe("Search filters");

package/dist/tool-middleware.js

@@ -69,7 +69,12 @@ export const SESSION_TOOLS = new Set([
 // ── Helpers ─────────────────────────────────────────────────
 /** Summarize tool args into a short string for analytics */
 export function summarizeInput(name, args) {
-    const q = args.query || args.question || args.feature || args.description || args.task || "";
+    const q = args.query ||
+        args.question ||
+        args.feature ||
+        args.description ||
+        args.task ||
+        "";
     if (q && typeof q === "string")
         return q.slice(0, 200);
     const content = args.content || args.code || args.diff || "";
@@ -155,6 +160,43 @@ export function trackUsage(name, args, startTime, success, result, errorMessage,
     })
         .catch(() => { });
 }
+// ── Sensory buffer ─────────────────────────────────────────
+/** Extract file paths from tool args */
+function extractFiles(args) {
+    const files = [];
+    for (const key of ["file", "filePath", "currentFile", "path"]) {
+        const v = args[key];
+        if (typeof v === "string" && v.length > 0)
+            files.push(v);
+    }
+    const arr = args.affectedFiles || args.files;
+    if (Array.isArray(arr)) {
+        for (const f of arr) {
+            if (typeof f === "string")
+                files.push(f);
+        }
+    }
+    return files.slice(0, 20);
+}
+/** Fire-and-forget: capture tool event in sensory buffer */
+function appendToSensoryBuffer(name, args, startTime, success, resultText, ctx) {
+    if (!ctx.activeSessionId)
+        return;
+    if (TRACKING_EXCLUDE.has(name))
+        return;
+    ctx.api
+        .post("/api/sensory/append", {
+        projectName: ctx.projectName,
+        sessionId: ctx.activeSessionId,
+        toolName: name,
+        inputSummary: summarizeInput(name, args).slice(0, 500),
+        outputSummary: (resultText || "").slice(0, 500),
+        filesTouched: extractFiles(args),
+        success,
+        durationMs: Date.now() - startTime,
+    })
+        .catch(() => { });
+}
 // ── Error formatting ────────────────────────────────────────
 /** Format an error caught during tool execution */
 export function formatToolError(error, ctx) {
@@ -186,12 +228,12 @@ export function wrapHandler(name, handler, deps) {
             // Validate: run PreToolUse hooks
             const validation = await validationPipeline.validate(name, args, ctx);
             if (!validation.allowed) {
-                return `Blocked: ${validation.reason || 'validation failed'}`;
+                return `Blocked: ${validation.reason || "validation failed"}`;
             }
             const validatedArgs = validation.modifiedArgs || args;
             const warningPrefix = validation.warnings?.length
-                ? `⚠️ ${validation.warnings.join(' | ')}\n\n`
-                : '';
+                ? `⚠️ ${validation.warnings.join(" | ")}\n\n`
+                : "";
             // Before: auto-enrich context
             const contextPrefix = ctx.enrichmentEnabled && deps.enricher
                 ? await deps.enricher.before(name, validatedArgs, ctx)
@@ -207,8 +249,10 @@ export function wrapHandler(name, handler, deps) {
             }
             // Track usage (fire-and-forget)
             trackUsage(name, args, startTime, true, text, undefined, ctx);
+            // Capture in sensory buffer (fire-and-forget)
+            appendToSensoryBuffer(name, args, startTime, true, text, ctx);
             // Prepend context/warnings if available
-            const prefix = [warningPrefix, contextPrefix].filter(Boolean).join('');
+            const prefix = [warningPrefix, contextPrefix].filter(Boolean).join("");
             if (prefix) {
                 if (typeof result === "string") {
                     return prefix + result;
@@ -221,6 +265,8 @@ export function wrapHandler(name, handler, deps) {
             const errorMessage = formatToolError(error, ctx);
             // Track failed usage (fire-and-forget)
             trackUsage(name, args, startTime, false, "", errorMessage, ctx);
+            // Capture failure in sensory buffer (fire-and-forget)
+            appendToSensoryBuffer(name, args, startTime, false, errorMessage, ctx);
             return errorMessage;
         }
     };

package/dist/tool-registry.js

@@ -21,7 +21,12 @@ const SESSION_TOOLS = new Set([
 /** Summarize tool args into a short string for analytics */
 function summarizeInput(name, args) {
     // Common patterns: query, question, content, feature, code, file
-    const q = args.query || args.question || args.feature || args.description || args.task || "";
+    const q = args.query ||
+        args.question ||
+        args.feature ||
+        args.description ||
+        args.task ||
+        "";
     if (q && typeof q === "string")
         return q.slice(0, 200);
     const content = args.content || args.code || args.diff || "";
@@ -40,7 +45,9 @@ function summarizeInput(name, args) {
 /** Count results from a tool response string */
 function countResults(result) {
     // Heuristic: count numbered list items, file matches, or "No results" = 0
-    if (result.includes("No results") || result.includes("No matches") || result.includes("not found"))
+    if (result.includes("No results") ||
+        result.includes("No matches") ||
+        result.includes("not found"))
         return 0;
     const numbered = result.match(/^\d+\./gm);
     if (numbered)
@@ -166,8 +173,8 @@ export class ToolRegistry {
             // Track failed usage (fire-and-forget)
             this.trackUsage(name, args, startTime, false, "", errorMessage, ctx);
             if (err.code === "ECONNREFUSED") {
-                return `Error: Cannot connect to RAG API at ${ctx.api.defaults.baseURL}. Is it running?\n` +
-                    `Start with: cd docker && docker-compose up -d`;
+                return (`Error: Cannot connect to RAG API at ${ctx.api.defaults.baseURL}. Is it running?\n` +
+                    `Start with: cd docker && docker-compose up -d`);
             }
             if (err.response) {
                 return `API Error (${err.response.status}): ${JSON.stringify(err.response.data)}`;

package/dist/tools/advanced.js

@@ -14,15 +14,28 @@ export function createAdvancedTools(projectName) {
             name: "merge_memories",
             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.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.coerce.number().optional().describe("Max clusters to process (default: 50)."),
+                type: z
+                    .string()
+                    .optional()
+                    .describe("Filter by memory type (decision, insight, context, todo, conversation, note, or all). Default: all"),
+                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.coerce
+                    .number()
+                    .optional()
+                    .describe("Max clusters to process (default: 50)."),
             }),
             annotations: TOOL_ANNOTATIONS["merge_memories"],
             handler: async (args, ctx) => {
-                const { type = "all", threshold = 0.9, dryRun = true, limit = 50 } = args;
+                const { type = "all", threshold = 0.9, dryRun = true, limit = 50, } = args;
                 const response = await ctx.api.post("/api/memory/merge", {
+                    projectName: ctx.projectName,
                     type,
                     threshold,
                     dryRun,
@@ -63,13 +76,21 @@ export function createAdvancedTools(projectName) {
             description: `Get code completion context for ${projectName}. Finds similar patterns, imports, and symbols from the codebase to aid code completion.`,
             schema: z.object({
                 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.coerce.number().optional().describe("Max results (default: 5)"),
+                currentCode: z
+                    .string()
+                    .describe("Current code snippet or file content"),
+                language: z
+                    .string()
+                    .optional()
+                    .describe("Programming language filter (optional)"),
+                limit: z.coerce
+                    .number()
+                    .optional()
+                    .describe("Max results (default: 5)"),
             }),
             annotations: TOOL_ANNOTATIONS["get_completion_context"],
             handler: async (args, ctx) => {
-                const { currentFile, currentCode, language, limit = 5 } = args;
+                const { currentFile, currentCode, language, limit = 5, } = args;
                 const response = await ctx.api.post("/api/code/completion-context", {
                     currentFile,
                     currentCode,
@@ -107,12 +128,18 @@ export function createAdvancedTools(projectName) {
             schema: z.object({
                 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.coerce.number().optional().describe("Max suggestions (default: 10)"),
+                language: z
+                    .string()
+                    .optional()
+                    .describe("Programming language filter (optional)"),
+                limit: z.coerce
+                    .number()
+                    .optional()
+                    .describe("Max suggestions (default: 10)"),
             }),
             annotations: TOOL_ANNOTATIONS["get_import_suggestions"],
             handler: async (args, ctx) => {
-                const { currentFile, currentCode, language, limit = 10 } = args;
+                const { currentFile, currentCode, language, limit = 10, } = args;
                 const response = await ctx.api.post("/api/code/import-suggestions", {
                     currentFile,
                     currentCode,
@@ -144,14 +171,26 @@ export function createAdvancedTools(projectName) {
             name: "get_type_context",
             description: `Look up type/interface/class definitions and usage in ${projectName}. Finds where a type is defined and how it's used across the codebase.`,
             schema: z.object({
-                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.coerce.number().optional().describe("Max results per category (default: 5)"),
+                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.coerce
+                    .number()
+                    .optional()
+                    .describe("Max results per category (default: 5)"),
             }),
             annotations: TOOL_ANNOTATIONS["get_type_context"],
             handler: async (args, ctx) => {
-                const { typeName, code, currentFile, limit = 5 } = args;
+                const { typeName, code, currentFile, limit = 5, } = args;
                 if (!typeName && !code) {
                     return "Error: Either typeName or code is required.";
                 }
@@ -187,8 +226,14 @@ 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.coerce.number().optional().describe("Number of days to analyze (default: 7)"),
-                sessionId: z.string().optional().describe("Filter to a specific session (optional)"),
+                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"],
             handler: async (args, ctx) => {