@luckydraw/cumulus 0.5.1

package/dist/mcp/tool-handler.js

@@ -0,0 +1,1405 @@
+import { spawn } from 'child_process';
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { cosineSimilarity, embeddingsAvailable, generateMissingEmbeddings, getEmbeddingProvider, loadEmbeddings, } from '../lib/embeddings.js';
+import { SessionManager } from '../lib/session.js';
+import { getSummary } from '../lib/summarizer.js';
+// Sub-query configuration
+const MAX_SUB_QUERIES_PER_REQUEST = 10;
+const SUB_QUERY_TIMEOUT_MS = 60000; // 60 seconds for CLI
+// Track per-request sub_query usage
+const requestStates = new Map();
+// Clean up old request states periodically (every 5 minutes)
+setInterval(() => {
+    const fiveMinutesAgo = Date.now() - 5 * 60 * 1000;
+    for (const [requestId, state] of requestStates.entries()) {
+        if (state.timestamp < fiveMinutesAgo) {
+            requestStates.delete(requestId);
+        }
+    }
+}, 5 * 60 * 1000);
+/**
+ * Execute a sub-query using the claude CLI.
+ * Uses --print mode with haiku model for cost efficiency.
+ */
+async function handleSubQuery(params, requestId) {
+    // Check rate limit
+    const state = requestStates.get(requestId) || { subQueryCount: 0, timestamp: Date.now() };
+    if (state.subQueryCount >= MAX_SUB_QUERIES_PER_REQUEST) {
+        throw new Error(`Maximum sub_query calls (${MAX_SUB_QUERIES_PER_REQUEST}) exceeded for this request`);
+    }
+    // Increment counter
+    state.subQueryCount++;
+    state.timestamp = Date.now();
+    requestStates.set(requestId, state);
+    // Construct the prompt for Claude
+    const fullPrompt = `<context>
+${params.context}
+</context>
+
+Based on the context above, answer this question concisely:
+${params.prompt}`;
+    // Build args for claude CLI
+    const modelFlag = params.model === 'sonnet' ? 'sonnet' : 'haiku';
+    const args = ['--print', '--model', modelFlag, fullPrompt];
+    return new Promise((resolve, reject) => {
+        // Filter out Claude Code env vars so child process is isolated
+        const cleanEnv = Object.fromEntries(Object.entries(process.env).filter(([key]) => !key.startsWith('CLAUDE') && key !== 'CLAUDECODE'));
+        const claude = spawn('claude', args, {
+            stdio: ['ignore', 'pipe', 'pipe'],
+            env: cleanEnv,
+        });
+        let stdout = '';
+        let stderr = '';
+        const timeout = setTimeout(() => {
+            claude.kill();
+            reject(new Error('sub_query timed out after 60 seconds'));
+        }, SUB_QUERY_TIMEOUT_MS);
+        claude.stdout.on('data', (data) => {
+            stdout += data.toString();
+        });
+        claude.stderr.on('data', (data) => {
+            stderr += data.toString();
+        });
+        claude.on('close', code => {
+            clearTimeout(timeout);
+            if (code === 0) {
+                resolve({ response: stdout.trim() });
+            }
+            else {
+                reject(new Error(`claude exited with code ${code}: ${stderr}`));
+            }
+        });
+        claude.on('error', err => {
+            clearTimeout(timeout);
+            if (err.message.includes('ENOENT')) {
+                reject(new Error('Claude CLI not found. Please install it first.'));
+            }
+            else {
+                reject(err);
+            }
+        });
+    });
+}
+const SNIPPET_LENGTH = 200;
+const MAX_READ_MESSAGES = 50;
+const DEFAULT_PEEK_COUNT = 5;
+const MAX_PEEK_COUNT = 20;
+const DEFAULT_SEARCH_LIMIT = 10;
+function createSnippet(content, maxLength = SNIPPET_LENGTH) {
+    if (content.length <= maxLength) {
+        return content;
+    }
+    return content.slice(0, maxLength) + '...';
+}
+function timestampToISO(timestamp) {
+    return new Date(timestamp).toISOString();
+}
+function messageToSearchResult(msg, index) {
+    const result = {
+        id: msg.id,
+        timestamp: timestampToISO(msg.timestamp),
+        role: msg.role,
+        content_snippet: createSnippet(msg.content),
+        index,
+    };
+    if (msg.metadata?.sessionId) {
+        result.sessionId = msg.metadata.sessionId;
+    }
+    return result;
+}
+function messageToResult(msg, index) {
+    const result = {
+        id: msg.id,
+        timestamp: timestampToISO(msg.timestamp),
+        role: msg.role,
+        content: msg.content,
+        index,
+    };
+    if (msg.metadata?.sessionId) {
+        result.sessionId = msg.metadata.sessionId;
+    }
+    return result;
+}
+export function getToolDefinitions() {
+    return [
+        {
+            name: 'search_history',
+            description: 'Search conversation history for relevant messages. Supports keyword, semantic, and hybrid search modes.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    query: {
+                        type: 'string',
+                        description: 'Search query',
+                    },
+                    limit: {
+                        type: 'number',
+                        description: 'Maximum number of results (default: 10)',
+                    },
+                    mode: {
+                        type: 'string',
+                        enum: ['keyword', 'semantic', 'hybrid'],
+                        description: "Search mode: 'keyword' (exact substring), 'semantic' (meaning-based), 'hybrid' (combined). Default: hybrid",
+                    },
+                },
+                required: ['query'],
+            },
+        },
+        {
+            name: 'read_messages',
+            description: 'Read full message content for a range of history indices. Use after search_history to get complete message content.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    startIndex: {
+                        type: 'number',
+                        description: 'Start index (0-indexed, inclusive)',
+                    },
+                    endIndex: {
+                        type: 'number',
+                        description: 'End index (inclusive)',
+                    },
+                },
+                required: ['startIndex', 'endIndex'],
+            },
+        },
+        {
+            name: 'peek_recent',
+            description: 'Get the most recent messages from conversation history. Useful for understanding current context.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    count: {
+                        type: 'number',
+                        description: 'Number of recent messages to retrieve (default: 5, max: 20)',
+                    },
+                },
+                required: [],
+            },
+        },
+        {
+            name: 'get_history_stats',
+            description: 'Get statistics about the conversation history including message count, token estimate, and time range.',
+            inputSchema: {
+                type: 'object',
+                properties: {},
+                required: [],
+            },
+        },
+        {
+            name: 'sub_query',
+            description: 'Make a recursive LLM call to reason over a specific context snippet. Use this to extract focused answers from large contexts (like conversation history) without consuming main context window. Defaults to fast/cheap haiku model.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    prompt: {
+                        type: 'string',
+                        description: 'The question to answer based on the provided context',
+                    },
+                    context: {
+                        type: 'string',
+                        description: 'The context snippet (conversation history, documents, etc.) to reason over',
+                    },
+                    model: {
+                        type: 'string',
+                        enum: ['haiku', 'sonnet'],
+                        description: "Model for sub-query. Default: 'haiku' (fast/cheap). Use 'sonnet' for complex reasoning.",
+                    },
+                },
+                required: ['prompt', 'context'],
+            },
+        },
+        {
+            name: 'get_summary',
+            description: "Get a summary of conversation history. Use 'recent' for the latest chunk, 'full' for overall summary, or 'range' for specific message indices. Summaries are auto-generated every 50 messages.",
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    scope: {
+                        type: 'string',
+                        enum: ['recent', 'full', 'range'],
+                        description: "Summary scope: 'recent' (last chunk), 'full' (entire conversation), 'range' (specific messages). Default: recent",
+                    },
+                    startIndex: {
+                        type: 'number',
+                        description: "Starting message index (only for scope='range')",
+                    },
+                    endIndex: {
+                        type: 'number',
+                        description: "Ending message index (only for scope='range')",
+                    },
+                },
+                required: [],
+            },
+        },
+        // Content retrieval tools (for externalized content)
+        {
+            name: 'retrieve_content',
+            description: 'Retrieve externally stored content by reference ID. Use when you see [STORED:xxx] references in tool results.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    contentId: {
+                        type: 'string',
+                        description: 'The content reference ID (e.g., cnt_abc123)',
+                    },
+                    chunkIndex: {
+                        type: 'number',
+                        description: 'Optional: retrieve only a specific chunk (0-indexed)',
+                    },
+                },
+                required: ['contentId'],
+            },
+        },
+        {
+            name: 'search_content',
+            description: 'Search across all externally stored content (file reads, command outputs, web fetches, etc.).',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    query: {
+                        type: 'string',
+                        description: 'Search query',
+                    },
+                    sourceTypes: {
+                        type: 'array',
+                        items: { type: 'string' },
+                        description: "Filter by source type: 'file_read', 'bash_output', 'web_fetch', 'user_input', 'tool_result'",
+                    },
+                    limit: {
+                        type: 'number',
+                        description: 'Maximum number of results (default: 10)',
+                    },
+                },
+                required: ['query'],
+            },
+        },
+        {
+            name: 'list_stored_content',
+            description: 'List all externally stored content with summaries. Use to see what large content is available.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    limit: {
+                        type: 'number',
+                        description: 'Maximum number of items to return (default: 20)',
+                    },
+                    sourceTypes: {
+                        type: 'array',
+                        items: { type: 'string' },
+                        description: 'Filter by source type',
+                    },
+                },
+                required: [],
+            },
+        },
+        {
+            name: 'read_content_chunk',
+            description: 'Read a specific chunk of stored content. Use for navigating through large content piece by piece.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    contentId: {
+                        type: 'string',
+                        description: 'The content reference ID',
+                    },
+                    chunkIndex: {
+                        type: 'number',
+                        description: 'The chunk index to read (0-indexed)',
+                    },
+                },
+                required: ['contentId', 'chunkIndex'],
+            },
+        },
+        {
+            name: 'forget_content',
+            description: 'Permanently delete stored content that should be forgotten. Use when the user says content was incorrect, outdated, or should no longer be referenced. This removes it from storage and search results.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    contentId: {
+                        type: 'string',
+                        description: 'The content reference ID to forget (e.g., cnt_abc123). Get this from list_stored_content or search_content.',
+                    },
+                    reason: {
+                        type: 'string',
+                        description: 'Brief reason for forgetting (for logging)',
+                    },
+                },
+                required: ['contentId'],
+            },
+        },
+        // File read and content storage tools
+        {
+            name: 'read_file',
+            description: 'CRITICAL: This tool REPLACES the built-in Read tool. You MUST use this for ALL file reads — text, code, PDFs. The built-in Read tool is DISABLED in this environment. read_file stores content in a vector database for persistent retrieval across sessions. Using the built-in Read tool bypasses storage and loses all context permanently. Returns a summary, content ID, and chunk table-of-contents. Use read_content_chunk to access specific chunks.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    file_path: {
+                        type: 'string',
+                        description: 'Absolute path to the file to read',
+                    },
+                    encoding: {
+                        type: 'string',
+                        description: "File encoding for text files (default: 'utf-8'). Ignored for PDFs.",
+                    },
+                },
+                required: ['file_path'],
+            },
+        },
+        {
+            name: 'store_content',
+            description: 'Store arbitrary text content in the content store for future retrieval. Use this AFTER reading PDFs or images with the built-in Read tool — pass the extracted text so it gets chunked, indexed, and searchable in future sessions.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    content: {
+                        type: 'string',
+                        description: 'The text content to store',
+                    },
+                    source: {
+                        type: 'string',
+                        description: 'Description of where this content came from (e.g., "PDF: /path/to/file.pdf pages 1-20")',
+                    },
+                    file_path: {
+                        type: 'string',
+                        description: 'Optional file path for metadata (if content came from a file)',
+                    },
+                },
+                required: ['content'],
+            },
+        },
+        {
+            name: 'detect_anomalies',
+            description: "Analyze stored content for anomalous chunks that don't belong in their surrounding context. Uses embedding-based rolling window coherence scoring. Useful for finding out-of-place content, corruption, or misplaced sections.",
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    contentId: {
+                        type: 'string',
+                        description: 'The stored content ID to analyze',
+                    },
+                    threshold: {
+                        type: 'number',
+                        description: 'Override the adaptive threshold (0-1). If not set, uses max(mean - 2σ, 0.3)',
+                    },
+                },
+                required: ['contentId'],
+            },
+        },
+    ];
+}
+export async function handleToolCall(name, args, ctx) {
+    const { historyStore, contentStore, sessionsPath, currentSessionId } = ctx;
+    try {
+        switch (name) {
+            case 'search_history': {
+                const query = args?.query;
+                const limit = Math.max(1, args?.limit || DEFAULT_SEARCH_LIMIT);
+                const mode = args?.mode || 'hybrid';
+                if (!query || typeof query !== 'string') {
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: JSON.stringify({ error: 'query parameter is required' }),
+                            },
+                        ],
+                    };
+                }
+                const allMsgs = await historyStore.getAll();
+                // Exclude session docs from message search (they're searched separately)
+                const messages = allMsgs.filter(m => m.role !== 'session');
+                const queryLower = query.toLowerCase();
+                const queryTerms = queryLower.split(/\s+/);
+                // Keyword search scores
+                const keywordScores = new Map();
+                for (let i = 0; i < messages.length; i++) {
+                    const msg = messages[i];
+                    if (!msg)
+                        continue;
+                    const contentLower = msg.content.toLowerCase();
+                    let score = 0;
+                    for (const term of queryTerms) {
+                        if (contentLower.includes(term)) {
+                            // Boost for exact phrase match
+                            if (contentLower.includes(queryLower)) {
+                                score += 2;
+                            }
+                            else {
+                                score += 1;
+                            }
+                        }
+                    }
+                    // Normalize to 0-1
+                    if (score > 0) {
+                        keywordScores.set(i, Math.min(score / queryTerms.length, 1));
+                    }
+                }
+                // Semantic search scores (if available and mode requires it)
+                const semanticScores = new Map();
+                const useSemanticSearch = mode !== 'keyword' && (await embeddingsAvailable());
+                if (useSemanticSearch) {
+                    try {
+                        // Generate missing embeddings first
+                        await generateMissingEmbeddings(historyStore.threadPath, messages.map(m => ({ id: m.id, content: m.content })));
+                        // Load embeddings and generate query embedding
+                        const embeddings = await loadEmbeddings(historyStore.threadPath);
+                        const provider = getEmbeddingProvider();
+                        const [queryEmbedding] = await provider.embed([query]);
+                        // Calculate similarity for each message
+                        for (let i = 0; i < messages.length; i++) {
+                            const msg = messages[i];
+                            if (!msg)
+                                continue;
+                            const embedding = embeddings.get(msg.id);
+                            if (!embedding || !queryEmbedding)
+                                continue;
+                            const similarity = cosineSimilarity(queryEmbedding, embedding);
+                            if (similarity > 0.3) {
+                                // Threshold for relevance
+                                semanticScores.set(i, similarity);
+                            }
+                        }
+                    }
+                    catch {
+                        // Fall back to keyword-only if embeddings fail
+                    }
+                }
+                const combined = [];
+                const allIndices = new Set([...keywordScores.keys(), ...semanticScores.keys()]);
+                for (const index of allIndices) {
+                    const kwScore = keywordScores.get(index) ?? 0;
+                    const semScore = semanticScores.get(index) ?? 0;
+                    let finalScore;
+                    if (mode === 'keyword') {
+                        finalScore = kwScore;
+                    }
+                    else if (mode === 'semantic') {
+                        finalScore = semScore;
+                    }
+                    else {
+                        // hybrid: combine with weights (semantic weighted higher)
+                        finalScore = kwScore * 0.3 + semScore * 0.7;
+                        // Boost if both match
+                        if (kwScore > 0 && semScore > 0) {
+                            finalScore *= 1.2;
+                        }
+                    }
+                    if (finalScore > 0) {
+                        combined.push({
+                            index,
+                            score: finalScore,
+                            keywordScore: kwScore > 0 ? kwScore : undefined,
+                            semanticScore: semScore > 0 ? semScore : undefined,
+                        });
+                    }
+                }
+                // Sort by score descending, then by index descending (most recent first)
+                combined.sort((a, b) => {
+                    if (b.score !== a.score) {
+                        return b.score - a.score;
+                    }
+                    return b.index - a.index; // Tiebreaker: more recent first
+                });
+                // Build message results
+                const results = [];
+                for (const scored of combined.slice(0, limit)) {
+                    const msg = messages[scored.index];
+                    if (msg) {
+                        results.push({
+                            ...messageToSearchResult(msg, scored.index),
+                            score: Math.round(scored.score * 100) / 100,
+                        });
+                    }
+                }
+                // Search session documents if available
+                if (sessionsPath && useSemanticSearch) {
+                    try {
+                        const provider = getEmbeddingProvider();
+                        const [queryEmbedding] = await provider.embed([query]);
+                        if (queryEmbedding) {
+                            const sessionResults = await SessionManager.searchAllSessions(sessionsPath, queryEmbedding, currentSessionId ?? '', 0.3);
+                            for (const sr of sessionResults.slice(0, 3)) {
+                                results.push({
+                                    id: `${sr.sessionId}:chunk${sr.chunkIndex}`,
+                                    timestamp: new Date().toISOString(),
+                                    role: 'session',
+                                    content_snippet: sr.content_snippet,
+                                    index: -1,
+                                    sessionId: sr.sessionId,
+                                    score: Math.round(sr.score * 100) / 100,
+                                });
+                            }
+                        }
+                    }
+                    catch {
+                        // Session search failure is non-fatal
+                    }
+                }
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify(results),
+                        },
+                    ],
+                };
+            }
+            case 'read_messages': {
+                const startIndex = args?.startIndex;
+                const endIndex = args?.endIndex;
+                if (typeof startIndex !== 'number' || typeof endIndex !== 'number') {
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: JSON.stringify({ error: 'startIndex and endIndex are required' }),
+                            },
+                        ],
+                    };
+                }
+                if (startIndex > endIndex) {
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: JSON.stringify([]),
+                            },
+                        ],
+                    };
+                }
+                const messages = await historyStore.getAll();
+                const clampedStart = Math.max(0, startIndex);
+                const clampedEnd = Math.min(messages.length - 1, endIndex);
+                // Limit range to MAX_READ_MESSAGES
+                const effectiveEnd = Math.min(clampedEnd, clampedStart + MAX_READ_MESSAGES - 1);
+                const results = [];
+                for (let i = clampedStart; i <= effectiveEnd && i < messages.length; i++) {
+                    const msg = messages[i];
+                    if (msg) {
+                        results.push(messageToResult(msg, i));
+                    }
+                }
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify(results),
+                        },
+                    ],
+                };
+            }
+            case 'peek_recent': {
+                const rawCount = args?.count || DEFAULT_PEEK_COUNT;
+                const count = Math.max(1, Math.min(MAX_PEEK_COUNT, rawCount));
+                const allMessages = await historyStore.getAll();
+                // Filter out session documents — peek is for conversation messages only
+                const messages = allMessages.filter(m => m.role !== 'session');
+                const startIndex = Math.max(0, messages.length - count);
+                const results = [];
+                for (let i = startIndex; i < messages.length; i++) {
+                    const msg = messages[i];
+                    if (msg) {
+                        // Use original index from allMessages for consistency
+                        const originalIndex = allMessages.indexOf(msg);
+                        results.push(messageToResult(msg, originalIndex >= 0 ? originalIndex : i));
+                    }
+                }
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify(results),
+                        },
+                    ],
+                };
+            }
+            case 'get_history_stats': {
+                const stats = await historyStore.getStats();
+                const result = {
+                    messageCount: stats.count,
+                    totalTokens: stats.totalTokens,
+                    oldestTimestamp: stats.oldestTimestamp ? timestampToISO(stats.oldestTimestamp) : null,
+                    newestTimestamp: stats.newestTimestamp ? timestampToISO(stats.newestTimestamp) : null,
+                };
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify(result),
+                        },
+                    ],
+                };
+            }
+            case 'sub_query': {
+                const prompt = args?.prompt;
+                const context = args?.context;
+                const model = args?.model;
+                if (!prompt || typeof prompt !== 'string') {
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: JSON.stringify({ error: 'prompt parameter is required' }),
+                            },
+                        ],
+                        isError: true,
+                    };
+                }
+                if (!context || typeof context !== 'string') {
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: JSON.stringify({ error: 'context parameter is required' }),
+                            },
+                        ],
+                        isError: true,
+                    };
+                }
+                // Generate request ID for rate limiting (use timestamp-based for now)
+                const requestId = `req_${Date.now()}`;
+                const subQueryResult = await handleSubQuery({ prompt, context, model }, requestId);
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify(subQueryResult, null, 2),
+                        },
+                    ],
+                };
+            }
+            case 'get_summary': {
+                const scope = args?.scope || 'recent';
+                const summaryStartIndex = args?.startIndex;
+                const summaryEndIndex = args?.endIndex;
+                // Check if range scope has required parameters
+                if (scope === 'range') {
+                    if (summaryStartIndex === undefined || summaryEndIndex === undefined) {
+                        return {
+                            content: [
+                                {
+                                    type: 'text',
+                                    text: JSON.stringify({
+                                        error: "startIndex and endIndex are required for scope='range'",
+                                    }),
+                                },
+                            ],
+                            isError: true,
+                        };
+                    }
+                }
+                const result = await getSummary(historyStore.threadPath, scope, summaryStartIndex, summaryEndIndex);
+                if (!result) {
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: JSON.stringify({
+                                    message: 'No summaries available yet. Summaries are generated after 50+ messages.',
+                                }),
+                            },
+                        ],
+                    };
+                }
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify(result, null, 2),
+                        },
+                    ],
+                };
+            }
+            // Content retrieval tools
+            case 'retrieve_content': {
+                if (!contentStore) {
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: JSON.stringify({ error: 'Content store not available' }),
+                            },
+                        ],
+                        isError: true,
+                    };
+                }
+                const contentId = args?.contentId;
+                const chunkIndex = args?.chunkIndex;
+                if (!contentId) {
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: JSON.stringify({ error: 'contentId is required' }),
+                            },
+                        ],
+                        isError: true,
+                    };
+                }
+                const content = await contentStore.retrieve(contentId, chunkIndex);
+                if (content === null) {
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: JSON.stringify({ error: `Content not found: ${contentId}` }),
+                            },
+                        ],
+                        isError: true,
+                    };
+                }
+                const meta = await contentStore.getMeta(contentId);
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify({
+                                contentId,
+                                chunkIndex: chunkIndex ?? 'all',
+                                totalChunks: meta?.chunkCount ?? 1,
+                                contentType: meta?.contentType,
+                                content,
+                            }, null, 2),
+                        },
+                    ],
+                };
+            }
+            case 'search_content': {
+                if (!contentStore) {
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: JSON.stringify({ error: 'Content store not available' }),
+                            },
+                        ],
+                        isError: true,
+                    };
+                }
+                const query = args?.query;
+                const sourceTypes = args?.sourceTypes;
+                const searchLimit = args?.limit || 10;
+                if (!query) {
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: JSON.stringify({ error: 'query is required' }),
+                            },
+                        ],
+                        isError: true,
+                    };
+                }
+                const results = await contentStore.search(query, {
+                    sourceTypes: sourceTypes,
+                    limit: searchLimit,
+                });
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify(results.map(r => ({
+                                contentId: r.meta.id,
+                                sourceType: r.meta.sourceType,
+                                contentType: r.meta.contentType,
+                                summary: r.meta.summary,
+                                score: r.score,
+                                snippet: r.snippet,
+                            })), null, 2),
+                        },
+                    ],
+                };
+            }
+            case 'list_stored_content': {
+                if (!contentStore) {
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: JSON.stringify({ error: 'Content store not available' }),
+                            },
+                        ],
+                        isError: true,
+                    };
+                }
+                const listLimit = args?.limit || 20;
+                const listSourceTypes = args?.sourceTypes;
+                const items = await contentStore.list({
+                    limit: listLimit,
+                    sourceTypes: listSourceTypes,
+                });
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify(items.map(item => ({
+                                contentId: item.id,
+                                sourceType: item.sourceType,
+                                sourceTool: item.sourceTool,
+                                contentType: item.contentType,
+                                originalSize: item.originalSize,
+                                tokenEstimate: item.tokenEstimate,
+                                chunkCount: item.chunkCount,
+                                summary: item.summary,
+                                timestamp: new Date(item.timestamp).toISOString(),
+                            })), null, 2),
+                        },
+                    ],
+                };
+            }
+            case 'read_content_chunk': {
+                if (!contentStore) {
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: JSON.stringify({ error: 'Content store not available' }),
+                            },
+                        ],
+                        isError: true,
+                    };
+                }
+                const chunkContentId = args?.contentId;
+                const chunkIdx = args?.chunkIndex;
+                if (!chunkContentId || chunkIdx === undefined) {
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: JSON.stringify({ error: 'contentId and chunkIndex are required' }),
+                            },
+                        ],
+                        isError: true,
+                    };
+                }
+                const chunkContent = await contentStore.retrieve(chunkContentId, chunkIdx);
+                if (chunkContent === null) {
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: JSON.stringify({
+                                    error: `Chunk not found: ${chunkContentId}[${chunkIdx}]`,
+                                }),
+                            },
+                        ],
+                        isError: true,
+                    };
+                }
+                const chunkMeta = await contentStore.getMeta(chunkContentId);
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify({
+                                contentId: chunkContentId,
+                                chunkIndex: chunkIdx,
+                                totalChunks: chunkMeta?.chunkCount ?? 1,
+                                hasNext: chunkMeta ? chunkIdx < chunkMeta.chunkCount - 1 : false,
+                                hasPrev: chunkIdx > 0,
+                                content: chunkContent,
+                            }, null, 2),
+                        },
+                    ],
+                };
+            }
+            case 'forget_content': {
+                if (!contentStore) {
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: JSON.stringify({ error: 'Content store not available' }),
+                            },
+                        ],
+                        isError: true,
+                    };
+                }
+                const forgetContentId = args?.contentId;
+                const forgetReason = args?.reason || 'User requested deletion';
+                if (!forgetContentId) {
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: JSON.stringify({ error: 'contentId is required' }),
+                            },
+                        ],
+                        isError: true,
+                    };
+                }
+                // Get meta before deletion for confirmation message
+                const forgetMeta = await contentStore.getMeta(forgetContentId);
+                if (!forgetMeta) {
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: JSON.stringify({
+                                    error: `Content not found: ${forgetContentId}`,
+                                }),
+                            },
+                        ],
+                        isError: true,
+                    };
+                }
+                const deleted = await contentStore.delete(forgetContentId);
+                console.error(`[forget_content] Deleted ${forgetContentId}: ${forgetMeta.summary.slice(0, 50)}... Reason: ${forgetReason}`);
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: deleted,
+                                contentId: forgetContentId,
+                                summary: forgetMeta.summary,
+                                message: `Content "${forgetMeta.summary.slice(0, 50)}..." has been permanently deleted and will no longer appear in searches.`,
+                            }, null, 2),
+                        },
+                    ],
+                };
+            }
+            // File read and content storage handlers
+            case 'read_file': {
+                if (!contentStore) {
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: JSON.stringify({ error: 'Content store not available' }),
+                            },
+                        ],
+                        isError: true,
+                    };
+                }
+                const filePath = args?.file_path;
+                if (!filePath) {
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: JSON.stringify({ error: 'file_path is required' }),
+                            },
+                        ],
+                        isError: true,
+                    };
+                }
+                // Resolve and validate path
+                const resolvedPath = path.resolve(filePath);
+                try {
+                    const stat = await fs.stat(resolvedPath);
+                    if (stat.isDirectory()) {
+                        return {
+                            content: [
+                                {
+                                    type: 'text',
+                                    text: JSON.stringify({
+                                        error: `Path is a directory, not a file: ${resolvedPath}`,
+                                    }),
+                                },
+                            ],
+                            isError: true,
+                        };
+                    }
+                }
+                catch (statError) {
+                    const code = statError.code;
+                    if (code === 'ENOENT') {
+                        return {
+                            content: [
+                                {
+                                    type: 'text',
+                                    text: JSON.stringify({ error: `File not found: ${resolvedPath}` }),
+                                },
+                            ],
+                            isError: true,
+                        };
+                    }
+                    if (code === 'EACCES') {
+                        return {
+                            content: [
+                                {
+                                    type: 'text',
+                                    text: JSON.stringify({ error: `Permission denied: ${resolvedPath}` }),
+                                },
+                            ],
+                            isError: true,
+                        };
+                    }
+                    throw statError;
+                }
+                const isPdf = resolvedPath.toLowerCase().endsWith('.pdf');
+                let fileContent;
+                let pdfPageCount;
+                if (isPdf) {
+                    // Extract text from PDF using pdfjs-dist (lazy-imported)
+                    let getDocument;
+                    try {
+                        const pdfjs = await import('pdfjs-dist/legacy/build/pdf.mjs');
+                        getDocument = pdfjs.getDocument;
+                    }
+                    catch {
+                        return {
+                            content: [
+                                {
+                                    type: 'text',
+                                    text: JSON.stringify({
+                                        error: 'PDF reading not available — pdfjs-dist not installed. Only text/code files can be read.',
+                                    }),
+                                },
+                            ],
+                            isError: true,
+                        };
+                    }
+                    try {
+                        const pdfBuffer = await fs.readFile(resolvedPath);
+                        const uint8 = new Uint8Array(pdfBuffer);
+                        const doc = await getDocument({ data: uint8, useSystemFonts: true }).promise;
+                        pdfPageCount = doc.numPages;
+                        const pages = [];
+                        for (let i = 1; i <= doc.numPages; i++) {
+                            const page = await doc.getPage(i);
+                            const content = await page.getTextContent();
+                            // Join text items with position-aware line breaks
+                            let pageText = '';
+                            let lastY = null;
+                            for (const item of content.items) {
+                                if (!('str' in item) || item.str === '')
+                                    continue;
+                                const y = Math.round(item.transform[5]);
+                                if (lastY !== null && lastY !== y) {
+                                    pageText += '\n';
+                                }
+                                else if (lastY === y && pageText.length > 0) {
+                                    pageText += ' ';
+                                }
+                                pageText += item.str;
+                                lastY = y;
+                            }
+                            pages.push(`[Page ${i}]\n${pageText}`);
+                        }
+                        fileContent = pages.join('\n\n');
+                        console.error(`[read_file] Extracted ${doc.numPages} pages from PDF: ${resolvedPath} (${fileContent.length} chars)`);
+                    }
+                    catch (pdfError) {
+                        return {
+                            content: [
+                                {
+                                    type: 'text',
+                                    text: JSON.stringify({
+                                        error: `Failed to parse PDF: ${pdfError.message}`,
+                                    }),
+                                },
+                            ],
+                            isError: true,
+                        };
+                    }
+                }
+                else {
+                    // Text file
+                    const encoding = args?.encoding || 'utf-8';
+                    try {
+                        fileContent = await fs.readFile(resolvedPath, encoding);
+                    }
+                    catch (readError) {
+                        return {
+                            content: [
+                                {
+                                    type: 'text',
+                                    text: JSON.stringify({
+                                        error: `Failed to read file: ${readError.message}`,
+                                    }),
+                                },
+                            ],
+                            isError: true,
+                        };
+                    }
+                    // Detect binary content (check for null bytes in first 8KB)
+                    const sample = fileContent.slice(0, 8192);
+                    if (sample.includes('\0')) {
+                        return {
+                            content: [
+                                {
+                                    type: 'text',
+                                    text: JSON.stringify({
+                                        error: `Binary file detected: ${resolvedPath}. Use the built-in Read tool for images and other binary files.`,
+                                    }),
+                                },
+                            ],
+                            isError: true,
+                        };
+                    }
+                }
+                const stored = await contentStore.store(fileContent, {
+                    sourceType: isPdf ? 'pdf_read' : 'file_read',
+                    sourceTool: 'read_file',
+                    metadata: {
+                        filePath: resolvedPath,
+                        ...(pdfPageCount !== undefined && { pdfPageCount }),
+                    },
+                });
+                // Get chunk previews for table of contents
+                const chunkPreviews = await contentStore.getChunkPreviews(stored.id);
+                console.error(`[read_file] Stored ${resolvedPath} as ${stored.id} (${stored.chunkCount} chunks, ~${stored.tokenEstimate} tokens)`);
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify({
+                                contentId: stored.id,
+                                filePath: resolvedPath,
+                                fileType: isPdf ? 'pdf' : 'text',
+                                ...(pdfPageCount !== undefined && { pdfPageCount }),
+                                summary: stored.summary,
+                                contentType: stored.contentType,
+                                chunkCount: stored.chunkCount,
+                                tokenEstimate: stored.tokenEstimate,
+                                originalSize: stored.originalSize,
+                                chunks: chunkPreviews,
+                                hint: `Use read_content_chunk("${stored.id}", N) to read a specific chunk by index. Use search_content("query") to find relevant chunks by content.`,
+                            }, null, 2),
+                        },
+                    ],
+                };
+            }
+            case 'store_content': {
+                if (!contentStore) {
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: JSON.stringify({ error: 'Content store not available' }),
+                            },
+                        ],
+                        isError: true,
+                    };
+                }
+                const storeText = args?.content;
+                if (!storeText) {
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: JSON.stringify({ error: 'content is required' }),
+                            },
+                        ],
+                        isError: true,
+                    };
+                }
+                const storeSource = args?.source || 'manual';
+                const storeFilePath = args?.file_path;
+                const stored = await contentStore.store(storeText, {
+                    sourceType: 'tool_result',
+                    sourceTool: 'store_content',
+                    metadata: {
+                        source: storeSource,
+                        ...(storeFilePath && { filePath: storeFilePath }),
+                    },
+                });
+                // Get chunk previews for navigation
+                const storeChunkPreviews = await contentStore.getChunkPreviews(stored.id);
+                console.error(`[store_content] Stored ${stored.id} from "${storeSource}" (${stored.chunkCount} chunks, ~${stored.tokenEstimate} tokens)`);
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify({
+                                contentId: stored.id,
+                                summary: stored.summary,
+                                contentType: stored.contentType,
+                                chunkCount: stored.chunkCount,
+                                tokenEstimate: stored.tokenEstimate,
+                                originalSize: stored.originalSize,
+                                chunks: storeChunkPreviews,
+                                hint: `Content stored and indexed. Use read_content_chunk("${stored.id}", N) to read a specific chunk by index. Use search_content("query") to find relevant chunks.`,
+                            }, null, 2),
+                        },
+                    ],
+                };
+            }
+            case 'detect_anomalies': {
+                if (!contentStore) {
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: JSON.stringify({ error: 'Content store not available' }),
+                            },
+                        ],
+                        isError: true,
+                    };
+                }
+                const anomalyContentId = args?.contentId;
+                const manualThreshold = args?.threshold;
+                if (!anomalyContentId) {
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: JSON.stringify({ error: 'contentId is required' }),
+                            },
+                        ],
+                        isError: true,
+                    };
+                }
+                const anomalyMeta = await contentStore.getMeta(anomalyContentId);
+                if (!anomalyMeta) {
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: JSON.stringify({
+                                    error: `Content not found: ${anomalyContentId}`,
+                                }),
+                            },
+                        ],
+                        isError: true,
+                    };
+                }
+                if (anomalyMeta.chunkCount < 2) {
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: JSON.stringify({
+                                    anomalies: [],
+                                    stats: {
+                                        totalChunks: anomalyMeta.chunkCount,
+                                        meanSimilarity: 1,
+                                        stdDev: 0,
+                                        adaptiveThreshold: 0.3,
+                                        embeddingCalls: 0,
+                                    },
+                                    message: 'Content has fewer than 2 chunks — anomaly detection requires at least 2.',
+                                }),
+                            },
+                        ],
+                    };
+                }
+                if (!(await embeddingsAvailable())) {
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: JSON.stringify({
+                                    error: 'Embeddings not available — @huggingface/transformers not installed',
+                                }),
+                            },
+                        ],
+                        isError: true,
+                    };
+                }
+                // Get embeddings for all chunks (generates missing ones)
+                const chunkEmbeddings = await contentStore.getEmbeddingsForContent(anomalyContentId);
+                if (!chunkEmbeddings || chunkEmbeddings.size === 0) {
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: JSON.stringify({
+                                    error: 'Could not generate embeddings for content',
+                                }),
+                            },
+                        ],
+                        isError: true,
+                    };
+                }
+                // Rolling window coherence scoring with ring buffer
+                const n = anomalyMeta.chunkCount;
+                const coherenceScores = [];
+                for (let i = 0; i < n; i++) {
+                    const curr = chunkEmbeddings.get(i);
+                    if (!curr) {
+                        coherenceScores.push(0);
+                        continue;
+                    }
+                    const prev = i > 0 ? chunkEmbeddings.get(i - 1) : null;
+                    const next = i < n - 1 ? chunkEmbeddings.get(i + 1) : null;
+                    const similarities = [];
+                    if (prev)
+                        similarities.push(cosineSimilarity(curr, prev));
+                    if (next)
+                        similarities.push(cosineSimilarity(curr, next));
+                    const avgSim = similarities.length > 0
+                        ? similarities.reduce((a, b) => a + b, 0) / similarities.length
+                        : 1;
+                    coherenceScores.push(avgSim);
+                }
+                // Compute adaptive threshold: max(mean - 2σ, 0.3)
+                const mean = coherenceScores.reduce((a, b) => a + b, 0) / coherenceScores.length;
+                const variance = coherenceScores.reduce((sum, s) => sum + (s - mean) ** 2, 0) / coherenceScores.length;
+                const stdDev = Math.sqrt(variance);
+                const adaptiveThreshold = Math.max(mean - 2 * stdDev, 0.3);
+                const effectiveThreshold = manualThreshold ?? adaptiveThreshold;
+                // Boundary relaxation factor (0.85x for first/last chunks)
+                const BOUNDARY_RELAX = 0.85;
+                // Find anomalies
+                const anomalies = [];
+                for (let i = 0; i < n; i++) {
+                    const isBoundary = i === 0 || i === n - 1;
+                    const chunkThreshold = isBoundary
+                        ? effectiveThreshold * BOUNDARY_RELAX
+                        : effectiveThreshold;
+                    const score = coherenceScores[i] ?? 0;
+                    if (score < chunkThreshold) {
+                        // Get preview of anomalous chunk
+                        const chunkText = await contentStore.retrieve(anomalyContentId, i);
+                        anomalies.push({
+                            chunkIndex: i,
+                            coherenceScore: Math.round(score * 1000) / 1000,
+                            threshold: Math.round(chunkThreshold * 1000) / 1000,
+                            preview: (chunkText || '').slice(0, 200),
+                        });
+                    }
+                }
+                console.error(`[detect_anomalies] ${anomalyContentId}: ${n} chunks, ${anomalies.length} anomalies, threshold=${Math.round(effectiveThreshold * 1000) / 1000}`);
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify({
+                                anomalies,
+                                stats: {
+                                    totalChunks: n,
+                                    meanSimilarity: Math.round(mean * 1000) / 1000,
+                                    stdDev: Math.round(stdDev * 1000) / 1000,
+                                    adaptiveThreshold: Math.round(adaptiveThreshold * 1000) / 1000,
+                                    effectiveThreshold: Math.round(effectiveThreshold * 1000) / 1000,
+                                    embeddingCalls: chunkEmbeddings.size,
+                                },
+                            }, null, 2),
+                        },
+                    ],
+                };
+            }
+            default:
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify({ error: `Unknown tool: ${name}` }),
+                        },
+                    ],
+                    isError: true,
+                };
+        }
+    }
+    catch (error) {
+        // Graceful error handling - return error objects, don't crash
+        const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify({ error: errorMessage }),
+                },
+            ],
+            isError: true,
+        };
+    }
+}
+//# sourceMappingURL=tool-handler.js.map