@crowley/rag-mcp 1.5.0 → 1.6.0

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 || "";
@@ -159,15 +164,15 @@ export function trackUsage(name, args, startTime, success, result, errorMessage,
 /** Extract file paths from tool args */
 function extractFiles(args) {
     const files = [];
-    for (const key of ['file', 'filePath', 'currentFile', 'path']) {
+    for (const key of ["file", "filePath", "currentFile", "path"]) {
         const v = args[key];
-        if (typeof v === 'string' && v.length > 0)
+        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')
+            if (typeof f === "string")
                 files.push(f);
         }
     }
@@ -223,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)
@@ -247,7 +252,7 @@ export function wrapHandler(name, handler, deps) {
             // 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;

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) => {

package/dist/tools/agents.js

@@ -12,10 +12,18 @@ export function createAgentTools(projectName) {
             name: "run_agent",
             description: `Run a specialized agent for ${projectName}. Agents autonomously research, review, or analyze using multiple tool calls. Returns result + reasoning trace.`,
             schema: z.object({
-                type: z.enum(["research", "review", "documentation", "refactor", "test"]).describe("Agent type: research, review, documentation, refactor, or test"),
+                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.coerce.number().optional().describe("Maximum ReAct iterations (default: varies by agent type)"),
+                context: z
+                    .string()
+                    .optional()
+                    .describe("Optional additional context (code, requirements, etc.)"),
+                maxIterations: z.coerce
+                    .number()
+                    .optional()
+                    .describe("Maximum ReAct iterations (default: varies by agent type)"),
             }),
             annotations: TOOL_ANNOTATIONS["run_agent"],
             handler: async (args, ctx) => {
@@ -63,16 +71,37 @@ export function createAgentTools(projectName) {
             name: "tribunal_debate",
             description: `Run an adversarial debate on a topic for ${projectName}. Multiple advocates argue positions, a judge renders a verdict. Use for architecture decisions, tech choices, or code approach trade-offs.`,
             schema: z.object({
-                topic: z.string().describe("The debate topic (e.g., 'Should we use REST or gRPC for the new API?')"),
-                positions: z.array(z.string()).min(2).max(4).describe("Positions to debate (2-4 options, e.g., ['REST', 'gRPC'])"),
-                context: z.string().optional().describe("Additional context for the debate"),
-                maxRounds: z.coerce.number().optional().describe("Number of rebuttal rounds (default: 1, max: 3)"),
-                useCodeContext: z.boolean().optional().describe("Fetch relevant code, ADRs, and patterns as evidence (default: false)"),
-                autoRecord: z.boolean().optional().describe("Save verdict as a decision in project memory (default: false)"),
+                topic: z
+                    .string()
+                    .describe("The debate topic (e.g., 'Should we use REST or gRPC for the new API?')"),
+                positions: z
+                    .array(z.string())
+                    .min(2)
+                    .max(4)
+                    .describe("Positions to debate (2-4 options, e.g., ['REST', 'gRPC'])"),
+                context: z
+                    .string()
+                    .optional()
+                    .describe("Additional context for the debate"),
+                maxRounds: z.coerce
+                    .number()
+                    .optional()
+                    .describe("Number of rebuttal rounds (default: 1, max: 3)"),
+                useCodeContext: z
+                    .boolean()
+                    .optional()
+                    .describe("Fetch relevant code, ADRs, and patterns as evidence (default: false)"),
+                autoRecord: z
+                    .boolean()
+                    .optional()
+                    .describe("Save verdict as a decision in project memory (default: false)"),
             }),
-            annotations: TOOL_ANNOTATIONS["tribunal_debate"] || { priority: 0.4, readOnlyHint: true },
+            annotations: TOOL_ANNOTATIONS["tribunal_debate"] || {
+                priority: 0.4,
+                readOnlyHint: true,
+            },
             handler: async (args, ctx) => {
-                const { topic, positions, context, maxRounds, useCodeContext, autoRecord } = args;
+                const { topic, positions, context, maxRounds, useCodeContext, autoRecord, } = args;
                 const response = await ctx.api.post("/api/tribunal/debate", {
                     projectName: ctx.projectName,
                     topic,
@@ -87,7 +116,7 @@ export function createAgentTools(projectName) {
                 let result = `## Tribunal Debate: ${data.topic}\n`;
                 result += `**Status:** ${data.status}`;
                 result += ` | **Duration:** ${Math.round(data.durationMs / 1000)}s`;
-                result += ` | **Cost:** ~$${data.cost?.estimatedUsd?.toFixed(3) || '?'}\n\n`;
+                result += ` | **Cost:** ~$${data.cost?.estimatedUsd?.toFixed(3) || "?"}\n\n`;
                 // Phases summary
                 if (data.phases) {
                     result += `### Phases\n`;
@@ -100,7 +129,7 @@ export function createAgentTools(projectName) {
                 if (data.arguments && data.arguments.length > 0) {
                     result += `### Arguments\n`;
                     for (const arg of data.arguments) {
-                        const label = arg.round === 0 ? 'Initial' : `Rebuttal R${arg.round}`;
+                        const label = arg.round === 0 ? "Initial" : `Rebuttal R${arg.round}`;
                         result += `#### ${arg.position} (${label})\n${arg.content}\n\n`;
                     }
                 }

package/dist/tools/analytics.js

@@ -72,7 +72,9 @@ export function createAnalyticsTools(projectName) {
             name: "get_analytics",
             description: `Get detailed analytics for a ${projectName} collection. Shows vectors, storage, language breakdown, and more.`,
             schema: z.object({
-                collectionName: z.string().describe("Collection name to get analytics for (e.g., 'codebase', 'docs', 'memory')"),
+                collectionName: z
+                    .string()
+                    .describe("Collection name to get analytics for (e.g., 'codebase', 'docs', 'memory')"),
             }),
             annotations: TOOL_ANNOTATIONS["get_analytics"],
             handler: async (args, ctx) => {
@@ -125,7 +127,9 @@ export function createAnalyticsTools(projectName) {
             name: "list_backups",
             description: `List backup snapshots for a ${projectName} collection.`,
             schema: z.object({
-                collectionName: z.string().describe("Collection name to list backups for"),
+                collectionName: z
+                    .string()
+                    .describe("Collection name to list backups for"),
             }),
             annotations: TOOL_ANNOTATIONS["list_backups"],
             handler: async (args, ctx) => {
@@ -153,8 +157,13 @@ export function createAnalyticsTools(projectName) {
             name: "enable_quantization",
             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.coerce.number().optional().describe("Quantile for quantization (0-1, default: 0.99)"),
+                collectionName: z
+                    .string()
+                    .describe("Collection name to enable quantization on"),
+                quantile: z.coerce
+                    .number()
+                    .optional()
+                    .describe("Quantile for quantization (0-1, default: 0.99)"),
             }),
             annotations: TOOL_ANNOTATIONS["enable_quantization"],
             handler: async (args, ctx) => {
@@ -195,7 +204,10 @@ export function createAnalyticsTools(projectName) {
             name: "get_prediction_stats",
             description: `Get predictive loader stats for ${projectName}. Shows prediction accuracy, hit rates, and strategy breakdown.`,
             schema: z.object({
-                sessionId: z.string().optional().describe("Session ID to get stats for. If omitted, returns aggregate stats."),
+                sessionId: z
+                    .string()
+                    .optional()
+                    .describe("Session ID to get stats for. If omitted, returns aggregate stats."),
             }),
             annotations: TOOL_ANNOTATIONS["get_prediction_stats"],
             handler: async (args, ctx) => {