claude-conversation-memory-mcp 1.4.0 → 1.5.1

package/dist/tools/ToolHandlers.js

@@ -29,6 +29,32 @@ import { pathToProjectFolderName } from "../utils/sanitization.js";
 import { DeletionService } from "../storage/DeletionService.js";
 import { readdirSync } from "fs";
 import { join } from "path";
+/**
+ * Default similarity score used when semantic search is not available.
+ * This applies to SQL-based searches where semantic embeddings are not used.
+ */
+const DEFAULT_SIMILARITY_SCORE = 1.0;
+/**
+ * Pagination Patterns:
+ *
+ * This codebase uses two different pagination patterns based on data source:
+ *
+ * 1. SQL-based pagination (fetch+1):
+ *    - Fetch limit+1 records from database
+ *    - hasMore = results.length > limit
+ *    - Slice to limit if hasMore is true
+ *    - Use case: Single-database SQL queries (searchMistakes, linkCommitsToConversations)
+ *    - Advantage: Efficient, minimal data transfer
+ *
+ * 2. In-memory pagination (slice):
+ *    - Fetch all needed results (or limit+offset)
+ *    - Slice to get paginated subset: results.slice(offset, offset + limit)
+ *    - has_more = offset + limit < results.length
+ *    - Use case: Semantic search, cross-project aggregation
+ *    - Advantage: Allows sorting/filtering before pagination
+ *
+ * Both patterns are correct and optimized for their respective use cases.
+ */
 /**
  * Tool handlers for the conversation-memory MCP server.
  *
@@ -167,15 +193,101 @@ export class ToolHandlers {
      */
     async searchConversations(args) {
         const typedArgs = args;
-        const { query, limit = 10, date_range } = typedArgs;
-        const filter = {};
-        if (date_range) {
-            filter.date_range = date_range;
+        const { query, limit = 10, offset = 0, date_range, scope = 'all', conversation_id } = typedArgs;
+        // Handle global scope by delegating to searchAllConversations
+        if (scope === 'global') {
+            const { GlobalIndex } = await import("../storage/GlobalIndex.js");
+            const { SQLiteManager } = await import("../storage/SQLiteManager.js");
+            const { SemanticSearch } = await import("../search/SemanticSearch.js");
+            const globalIndex = new GlobalIndex();
+            const projects = globalIndex.getAllProjects();
+            const allResults = [];
+            for (const project of projects) {
+                let projectDb = null;
+                try {
+                    projectDb = new SQLiteManager({ dbPath: project.db_path, readOnly: true });
+                    const semanticSearch = new SemanticSearch(projectDb);
+                    const localResults = await semanticSearch.searchConversations(query, limit + offset);
+                    const filteredResults = date_range
+                        ? localResults.filter((r) => {
+                            const timestamp = r.message.timestamp;
+                            return timestamp >= date_range[0] && timestamp <= date_range[1];
+                        })
+                        : localResults;
+                    for (const result of filteredResults) {
+                        allResults.push({
+                            conversation_id: result.conversation.id,
+                            message_id: result.message.id,
+                            timestamp: new Date(result.message.timestamp).toISOString(),
+                            similarity: result.similarity,
+                            snippet: result.snippet,
+                            git_branch: result.conversation.git_branch,
+                            message_type: result.message.message_type,
+                            role: result.message.role,
+                        });
+                    }
+                }
+                finally {
+                    if (projectDb) {
+                        projectDb.close();
+                    }
+                }
+            }
+            allResults.sort((a, b) => b.similarity - a.similarity);
+            const paginatedResults = allResults.slice(offset, offset + limit);
+            return {
+                query,
+                results: paginatedResults,
+                total_found: paginatedResults.length,
+                has_more: offset + limit < allResults.length,
+                offset,
+                scope: 'global',
+            };
         }
-        const results = await this.memory.search(query, limit);
+        // Handle current session scope
+        if (scope === 'current') {
+            if (!conversation_id) {
+                throw new Error("conversation_id is required when scope='current'");
+            }
+            const results = await this.memory.search(query, limit + offset);
+            const filteredResults = results.filter(r => r.conversation.id === conversation_id);
+            const dateFilteredResults = date_range
+                ? filteredResults.filter(r => {
+                    const timestamp = r.message.timestamp;
+                    return timestamp >= date_range[0] && timestamp <= date_range[1];
+                })
+                : filteredResults;
+            const paginatedResults = dateFilteredResults.slice(offset, offset + limit);
+            return {
+                query,
+                results: paginatedResults.map((r) => ({
+                    conversation_id: r.conversation.id,
+                    message_id: r.message.id,
+                    timestamp: new Date(r.message.timestamp).toISOString(),
+                    similarity: r.similarity,
+                    snippet: r.snippet,
+                    git_branch: r.conversation.git_branch,
+                    message_type: r.message.message_type,
+                    role: r.message.role,
+                })),
+                total_found: paginatedResults.length,
+                has_more: offset + limit < dateFilteredResults.length,
+                offset,
+                scope: 'current',
+            };
+        }
+        // Handle 'all' scope (default) - all sessions in current project
+        const results = await this.memory.search(query, limit + offset);
+        const filteredResults = date_range
+            ? results.filter(r => {
+                const timestamp = r.message.timestamp;
+                return timestamp >= date_range[0] && timestamp <= date_range[1];
+            })
+            : results;
+        const paginatedResults = filteredResults.slice(offset, offset + limit);
         return {
             query,
-            results: results.map((r) => ({
+            results: paginatedResults.map((r) => ({
                 conversation_id: r.conversation.id,
                 message_id: r.message.id,
                 timestamp: new Date(r.message.timestamp).toISOString(),
@@ -185,7 +297,10 @@ export class ToolHandlers {
                 message_type: r.message.message_type,
                 role: r.message.role,
             })),
-            total_found: results.length,
+            total_found: paginatedResults.length,
+            has_more: offset + limit < filteredResults.length,
+            offset,
+            scope: 'all',
         };
     }
     /**
@@ -231,17 +346,49 @@ export class ToolHandlers {
      */
     async getDecisions(args) {
         const typedArgs = args;
-        const { query, file_path, limit = 10 } = typedArgs;
-        const results = await this.memory.searchDecisions(query, limit);
+        const { query, file_path, limit = 10, offset = 0, scope = 'all', conversation_id } = typedArgs;
+        // Handle global scope
+        if (scope === 'global') {
+            const globalResponse = await this.getAllDecisions({ query, file_path, limit, offset, source_type: 'all' });
+            return {
+                query,
+                file_path,
+                decisions: globalResponse.decisions.map(d => ({
+                    decision_id: d.decision_id,
+                    decision_text: d.decision_text,
+                    rationale: d.rationale,
+                    alternatives_considered: d.alternatives_considered,
+                    rejected_reasons: d.rejected_reasons,
+                    context: d.context,
+                    related_files: d.related_files,
+                    related_commits: d.related_commits,
+                    timestamp: d.timestamp,
+                    similarity: d.similarity,
+                })),
+                total_found: globalResponse.total_found,
+                has_more: globalResponse.has_more,
+                offset: globalResponse.offset,
+                scope: 'global',
+            };
+        }
+        const results = await this.memory.searchDecisions(query, limit + offset);
         // Filter by file if specified
         let filteredResults = results;
         if (file_path) {
             filteredResults = results.filter((r) => r.decision.related_files.includes(file_path));
         }
+        // Filter by conversation_id if scope is 'current'
+        if (scope === 'current') {
+            if (!conversation_id) {
+                throw new Error("conversation_id is required when scope='current'");
+            }
+            filteredResults = filteredResults.filter((r) => r.decision.conversation_id === conversation_id);
+        }
+        const paginatedResults = filteredResults.slice(offset, offset + limit);
         return {
             query,
             file_path,
-            decisions: filteredResults.map((r) => ({
+            decisions: paginatedResults.map((r) => ({
                 decision_id: r.decision.id,
                 decision_text: r.decision.decision_text,
                 rationale: r.decision.rationale,
@@ -253,7 +400,10 @@ export class ToolHandlers {
                 timestamp: new Date(r.decision.timestamp).toISOString(),
                 similarity: r.similarity,
             })),
-            total_found: filteredResults.length,
+            total_found: paginatedResults.length,
+            has_more: offset + limit < filteredResults.length,
+            offset,
+            scope,
         };
     }
     /**
@@ -442,24 +592,35 @@ export class ToolHandlers {
      */
     async linkCommitsToConversations(args) {
         const typedArgs = args;
-        const { query, conversation_id, limit = 20 } = typedArgs;
+        const { query, conversation_id, limit = 20, offset = 0, scope = 'all' } = typedArgs;
+        // Global scope not supported for git commits (project-specific)
+        if (scope === 'global') {
+            throw new Error("Global scope is not supported for linkCommitsToConversations (git commits are project-specific)");
+        }
         let sql = "SELECT * FROM git_commits WHERE 1=1";
         const params = [];
-        if (conversation_id) {
+        if (conversation_id || scope === 'current') {
+            const targetId = conversation_id || typedArgs.conversation_id;
+            if (!targetId) {
+                throw new Error("conversation_id is required when scope='current'");
+            }
             sql += " AND conversation_id = ?";
-            params.push(conversation_id);
+            params.push(targetId);
         }
         if (query) {
             sql += " AND message LIKE ?";
             params.push(`%${query}%`);
         }
-        sql += " ORDER BY timestamp DESC LIMIT ?";
-        params.push(limit);
+        sql += ` ORDER BY timestamp DESC LIMIT ? OFFSET ?`;
+        params.push(limit + 1); // Fetch one extra to determine has_more
+        params.push(offset);
         const commits = this.db.prepare(sql).all(...params);
+        const hasMore = commits.length > limit;
+        const results = hasMore ? commits.slice(0, limit) : commits;
         return {
             query,
             conversation_id,
-            commits: commits.map((c) => ({
+            commits: results.map((c) => ({
                 hash: c.hash.substring(0, 7),
                 full_hash: c.hash,
                 message: c.message,
@@ -469,7 +630,10 @@ export class ToolHandlers {
                 files_changed: JSON.parse(c.files_changed || "[]"),
                 conversation_id: c.conversation_id,
             })),
-            total_found: commits.length,
+            total_found: results.length,
+            has_more: hasMore,
+            offset,
+            scope,
         };
     }
     /**
@@ -511,7 +675,28 @@ export class ToolHandlers {
      */
     async searchMistakes(args) {
         const typedArgs = args;
-        const { query, mistake_type, limit = 10 } = typedArgs;
+        const { query, mistake_type, limit = 10, offset = 0, scope = 'all', conversation_id } = typedArgs;
+        // Handle global scope
+        if (scope === 'global') {
+            const globalResponse = await this.searchAllMistakes({ query, mistake_type, limit, offset, source_type: 'all' });
+            return {
+                query,
+                mistake_type,
+                mistakes: globalResponse.mistakes.map(m => ({
+                    mistake_id: m.mistake_id,
+                    mistake_type: m.mistake_type,
+                    what_went_wrong: m.what_went_wrong,
+                    correction: m.correction,
+                    user_correction_message: m.user_correction_message,
+                    files_affected: m.files_affected,
+                    timestamp: m.timestamp,
+                })),
+                total_found: globalResponse.total_found,
+                has_more: globalResponse.has_more,
+                offset: globalResponse.offset,
+                scope: 'global',
+            };
+        }
         const sanitized = sanitizeForLike(query);
         let sql = "SELECT * FROM mistakes WHERE what_went_wrong LIKE ? ESCAPE '\\'";
         const params = [`%${sanitized}%`];
@@ -519,13 +704,24 @@ export class ToolHandlers {
             sql += " AND mistake_type = ?";
             params.push(mistake_type);
         }
-        sql += " ORDER BY timestamp DESC LIMIT ?";
-        params.push(limit);
+        // Filter by conversation_id if scope is 'current'
+        if (scope === 'current') {
+            if (!conversation_id) {
+                throw new Error("conversation_id is required when scope='current'");
+            }
+            sql += " AND conversation_id = ?";
+            params.push(conversation_id);
+        }
+        sql += ` ORDER BY timestamp DESC LIMIT ? OFFSET ?`;
+        params.push(limit + 1); // Fetch one extra to determine has_more
+        params.push(offset);
         const mistakes = this.db.prepare(sql).all(...params);
+        const hasMore = mistakes.length > limit;
+        const results = hasMore ? mistakes.slice(0, limit) : mistakes;
         return {
             query,
             mistake_type,
-            mistakes: mistakes.map((m) => ({
+            mistakes: results.map((m) => ({
                 mistake_id: m.id,
                 mistake_type: m.mistake_type,
                 what_went_wrong: m.what_went_wrong,
@@ -534,7 +730,10 @@ export class ToolHandlers {
                 files_affected: JSON.parse(m.files_affected || "[]"),
                 timestamp: new Date(m.timestamp).toISOString(),
             })),
-            total_found: mistakes.length,
+            total_found: results.length,
+            has_more: hasMore,
+            offset,
+            scope,
         };
     }
     /**
@@ -793,8 +992,13 @@ export class ToolHandlers {
      */
     async findSimilarSessions(args) {
         const typedArgs = args;
-        const { query, limit = 5 } = typedArgs;
-        const results = await this.memory.search(query, limit * 3); // Get more to group by conversation
+        const { query, limit = 5, offset = 0, scope = 'all', conversation_id: _conversation_id } = typedArgs;
+        // Note: scope='global' and scope='current' have limited usefulness for finding similar SESSIONS
+        // but we implement them for API consistency
+        if (scope === 'current') {
+            throw new Error("scope='current' is not supported for findSimilarSessions (it finds sessions, not messages within a session)");
+        }
+        const results = await this.memory.search(query, (limit + offset) * 3); // Get more to group by conversation
         // Group by conversation
         const conversationMap = new Map();
         for (const result of results) {
@@ -819,13 +1023,16 @@ export class ToolHandlers {
                 });
             }
         }
-        const sessions = Array.from(conversationMap.values())
-            .sort((a, b) => b.relevance_score - a.relevance_score)
-            .slice(0, limit);
+        const allSessions = Array.from(conversationMap.values())
+            .sort((a, b) => b.relevance_score - a.relevance_score);
+        const sessions = allSessions.slice(offset, offset + limit);
         return {
             query,
             sessions,
             total_found: sessions.length,
+            has_more: offset + limit < allSessions.length,
+            offset,
+            scope,
         };
     }
     /**
@@ -869,20 +1076,24 @@ export class ToolHandlers {
      */
     async recallAndApply(args) {
         const typedArgs = args;
-        const { query, context_types = ["conversations", "decisions", "mistakes", "file_changes", "commits"], file_path, date_range, limit = 5 } = typedArgs;
+        const { query, context_types = ["conversations", "decisions", "mistakes", "file_changes", "commits"], file_path, date_range, limit = 5, offset = 0, scope = 'all', conversation_id } = typedArgs;
         const recalled = {};
         let totalItems = 0;
         const suggestions = [];
         // 1. Recall conversations if requested
         if (context_types.includes("conversations")) {
-            const searchResults = await this.memory.search(query, limit);
-            // Apply date filter if provided
-            const filteredResults = date_range
-                ? searchResults.filter(r => r.message.timestamp >= date_range[0] && r.message.timestamp <= date_range[1])
-                : searchResults;
-            recalled.conversations = filteredResults.map(result => ({
-                session_id: result.conversation.id || "unknown",
-                timestamp: new Date(result.message.timestamp).toISOString(),
+            // Use searchConversations with scope support
+            const convResponse = await this.searchConversations({
+                query,
+                limit,
+                offset,
+                date_range,
+                scope,
+                conversation_id,
+            });
+            recalled.conversations = convResponse.results.map(result => ({
+                session_id: result.conversation_id,
+                timestamp: result.timestamp,
                 snippet: result.snippet,
                 relevance_score: result.similarity,
             }));
@@ -893,25 +1104,24 @@ export class ToolHandlers {
         }
         // 2. Recall decisions if requested
         if (context_types.includes("decisions")) {
-            const decisions = this.db.getDatabase()
-                .prepare(`
-          SELECT id, decision_text, rationale, alternatives_considered, rejected_reasons, context, related_files, timestamp
-          FROM decisions
-          WHERE decision_text LIKE ? ${file_path ? 'AND related_files LIKE ?' : ''}
-          ${date_range ? 'AND timestamp BETWEEN ? AND ?' : ''}
-          ORDER BY timestamp DESC
-          LIMIT ?
-        `)
-                .all(`%${sanitizeForLike(query)}%`, ...(file_path ? [`%${sanitizeForLike(file_path)}%`] : []), ...(date_range ? [date_range[0], date_range[1]] : []), limit);
-            recalled.decisions = decisions.map(d => ({
-                decision_id: d.id,
-                type: d.context,
+            // Use getDecisions with scope support
+            const decisionsResponse = await this.getDecisions({
+                query,
+                file_path,
+                limit,
+                offset,
+                scope,
+                conversation_id,
+            });
+            recalled.decisions = decisionsResponse.decisions.map(d => ({
+                decision_id: d.decision_id,
+                type: d.context || 'unknown',
                 description: d.decision_text,
                 rationale: d.rationale || undefined,
-                alternatives: d.alternatives_considered ? JSON.parse(d.alternatives_considered) : undefined,
-                rejected_approaches: d.rejected_reasons ? JSON.parse(d.rejected_reasons) : undefined,
-                affects_components: JSON.parse(d.related_files),
-                timestamp: new Date(d.timestamp).toISOString(),
+                alternatives: d.alternatives_considered,
+                rejected_approaches: Object.values(d.rejected_reasons),
+                affects_components: d.related_files,
+                timestamp: d.timestamp,
             }));
             totalItems += recalled.decisions.length;
             if (recalled.decisions.length > 0) {
@@ -920,25 +1130,23 @@ export class ToolHandlers {
         }
         // 3. Recall mistakes if requested
         if (context_types.includes("mistakes")) {
-            const mistakes = this.db.getDatabase()
-                .prepare(`
-          SELECT id, mistake_type, what_went_wrong, correction, user_correction_message, files_affected, timestamp
-          FROM mistakes
-          WHERE what_went_wrong LIKE ? ${file_path ? 'AND files_affected LIKE ?' : ''}
-          ${date_range ? 'AND timestamp BETWEEN ? AND ?' : ''}
-          ORDER BY timestamp DESC
-          LIMIT ?
-        `)
-                .all(`%${sanitizeForLike(query)}%`, ...(file_path ? [`%${sanitizeForLike(file_path)}%`] : []), ...(date_range ? [date_range[0], date_range[1]] : []), limit);
-            recalled.mistakes = mistakes.map(m => ({
-                mistake_id: m.id,
+            // Use searchMistakes with scope support
+            const mistakesResponse = await this.searchMistakes({
+                query,
+                limit,
+                offset,
+                scope,
+                conversation_id,
+            });
+            recalled.mistakes = mistakesResponse.mistakes.map(m => ({
+                mistake_id: m.mistake_id,
                 type: m.mistake_type,
                 description: m.what_went_wrong,
                 what_happened: m.what_went_wrong,
                 how_fixed: m.correction || undefined,
                 lesson_learned: m.user_correction_message || undefined,
-                files_affected: JSON.parse(m.files_affected),
-                timestamp: new Date(m.timestamp).toISOString(),
+                files_affected: m.files_affected,
+                timestamp: m.timestamp,
             }));
             totalItems += recalled.mistakes.length;
             if (recalled.mistakes.length > 0) {
@@ -1409,5 +1617,397 @@ export class ToolHandlers {
             };
         }
     }
+    // ==================== Global Cross-Project Tools ====================
+    /**
+     * Index all projects (Claude Code + Codex).
+     *
+     * Discovers and indexes all projects from both Claude Code and Codex,
+     * registering them in a global index for cross-project search.
+     *
+     * @param args - Indexing arguments
+     * @returns Summary of all indexed projects
+     */
+    async indexAllProjects(args) {
+        const { GlobalIndex } = await import("../storage/GlobalIndex.js");
+        const { homedir } = await import("os");
+        const { join } = await import("path");
+        const { existsSync, readdirSync } = await import("fs");
+        const typedArgs = args;
+        const { include_codex = true, include_claude_code = true, codex_path = join(homedir(), ".codex"), claude_projects_path = join(homedir(), ".claude", "projects"), } = typedArgs;
+        const globalIndex = new GlobalIndex();
+        try {
+            const projects = [];
+            const errors = [];
+            let totalMessages = 0;
+            let totalConversations = 0;
+            let totalDecisions = 0;
+            let totalMistakes = 0;
+            // Index Codex if requested
+            if (include_codex && existsSync(codex_path)) {
+                try {
+                    const { CodexConversationParser } = await import("../parsers/CodexConversationParser.js");
+                    const { SQLiteManager } = await import("../storage/SQLiteManager.js");
+                    const { ConversationStorage } = await import("../storage/ConversationStorage.js");
+                    // Create dedicated database for Codex
+                    const codexDbPath = join(codex_path, ".codex-conversations-memory.db");
+                    const codexDb = new SQLiteManager({ dbPath: codexDbPath });
+                    const codexStorage = new ConversationStorage(codexDb);
+                    // Parse Codex sessions
+                    const parser = new CodexConversationParser();
+                    const parseResult = parser.parseSession(codex_path);
+                    // Store all parsed data
+                    await codexStorage.storeConversations(parseResult.conversations);
+                    await codexStorage.storeMessages(parseResult.messages);
+                    await codexStorage.storeToolUses(parseResult.tool_uses);
+                    await codexStorage.storeToolResults(parseResult.tool_results);
+                    await codexStorage.storeFileEdits(parseResult.file_edits);
+                    await codexStorage.storeThinkingBlocks(parseResult.thinking_blocks);
+                    // Get stats from the database
+                    const stats = codexDb.getDatabase()
+                        .prepare("SELECT COUNT(*) as count FROM conversations")
+                        .get();
+                    const messageStats = codexDb.getDatabase()
+                        .prepare("SELECT COUNT(*) as count FROM messages")
+                        .get();
+                    const decisionStats = codexDb.getDatabase()
+                        .prepare("SELECT COUNT(*) as count FROM decisions")
+                        .get();
+                    const mistakeStats = codexDb.getDatabase()
+                        .prepare("SELECT COUNT(*) as count FROM mistakes")
+                        .get();
+                    // Register in global index
+                    globalIndex.registerProject({
+                        project_path: codex_path,
+                        source_type: "codex",
+                        db_path: codexDbPath,
+                        message_count: messageStats.count,
+                        conversation_count: stats.count,
+                        decision_count: decisionStats.count,
+                        mistake_count: mistakeStats.count,
+                        metadata: {
+                            indexed_folders: parseResult.indexed_folders || [],
+                        },
+                    });
+                    projects.push({
+                        project_path: codex_path,
+                        source_type: "codex",
+                        message_count: messageStats.count,
+                        conversation_count: stats.count,
+                    });
+                    totalMessages += messageStats.count;
+                    totalConversations += stats.count;
+                    totalDecisions += decisionStats.count;
+                    totalMistakes += mistakeStats.count;
+                    // Close the Codex database
+                    codexDb.close();
+                }
+                catch (error) {
+                    errors.push({
+                        project_path: codex_path,
+                        error: error.message,
+                    });
+                }
+            }
+            // Index Claude Code projects if requested
+            if (include_claude_code && existsSync(claude_projects_path)) {
+                try {
+                    const projectFolders = readdirSync(claude_projects_path);
+                    for (const folder of projectFolders) {
+                        const folderPath = join(claude_projects_path, folder);
+                        try {
+                            // Try to determine the original project path from folder name
+                            const projectPath = folderPath; // Simplified for now
+                            // Index this project
+                            const indexResult = await this.indexConversations({
+                                project_path: projectPath,
+                            });
+                            if (indexResult.success) {
+                                // Register in global index
+                                globalIndex.registerProject({
+                                    project_path: projectPath,
+                                    source_type: "claude-code",
+                                    db_path: this.db.getDbPath(),
+                                    message_count: indexResult.stats.messages.count,
+                                    conversation_count: indexResult.stats.conversations.count,
+                                    decision_count: indexResult.stats.decisions.count,
+                                    mistake_count: indexResult.stats.mistakes.count,
+                                });
+                                projects.push({
+                                    project_path: projectPath,
+                                    source_type: "claude-code",
+                                    message_count: indexResult.stats.messages.count,
+                                    conversation_count: indexResult.stats.conversations.count,
+                                });
+                                totalMessages += indexResult.stats.messages.count;
+                                totalConversations += indexResult.stats.conversations.count;
+                                totalDecisions += indexResult.stats.decisions.count;
+                                totalMistakes += indexResult.stats.mistakes.count;
+                            }
+                        }
+                        catch (error) {
+                            errors.push({
+                                project_path: folder,
+                                error: error.message,
+                            });
+                        }
+                    }
+                }
+                catch (error) {
+                    errors.push({
+                        project_path: claude_projects_path,
+                        error: error.message,
+                    });
+                }
+            }
+            const stats = globalIndex.getGlobalStats();
+            return {
+                success: true,
+                global_index_path: globalIndex.getDbPath(),
+                projects_indexed: projects.length,
+                claude_code_projects: stats.claude_code_projects,
+                codex_projects: stats.codex_projects,
+                total_messages: totalMessages,
+                total_conversations: totalConversations,
+                total_decisions: totalDecisions,
+                total_mistakes: totalMistakes,
+                projects,
+                errors,
+                message: `Indexed ${projects.length} project(s): ${stats.claude_code_projects} Claude Code + ${stats.codex_projects} Codex`,
+            };
+        }
+        finally {
+            // Ensure GlobalIndex is always closed
+            globalIndex.close();
+        }
+    }
+    /**
+     * Search across all indexed projects.
+     *
+     * @param args - Search arguments
+     * @returns Search results from all projects
+     */
+    async searchAllConversations(args) {
+        const { GlobalIndex } = await import("../storage/GlobalIndex.js");
+        const { SQLiteManager } = await import("../storage/SQLiteManager.js");
+        const { SemanticSearch } = await import("../search/SemanticSearch.js");
+        const typedArgs = args;
+        const { query, limit = 20, offset = 0, date_range, source_type = "all" } = typedArgs;
+        const globalIndex = new GlobalIndex();
+        try {
+            const projects = globalIndex.getAllProjects(source_type === "all" ? undefined : source_type);
+            const allResults = [];
+            let claudeCodeResults = 0;
+            let codexResults = 0;
+            for (const project of projects) {
+                let projectDb = null;
+                try {
+                    // Open this project's database
+                    projectDb = new SQLiteManager({ dbPath: project.db_path, readOnly: true });
+                    const semanticSearch = new SemanticSearch(projectDb);
+                    // Search this specific project's database
+                    const localResults = await semanticSearch.searchConversations(query, limit);
+                    // Filter by date range if specified
+                    const filteredResults = date_range
+                        ? localResults.filter((r) => {
+                            const timestamp = r.message.timestamp;
+                            return timestamp >= date_range[0] && timestamp <= date_range[1];
+                        })
+                        : localResults;
+                    // Enrich results with project info
+                    for (const result of filteredResults) {
+                        allResults.push({
+                            conversation_id: result.conversation.id,
+                            message_id: result.message.id,
+                            timestamp: new Date(result.message.timestamp).toISOString(),
+                            similarity: result.similarity,
+                            snippet: result.snippet,
+                            git_branch: result.conversation.git_branch,
+                            message_type: result.message.message_type,
+                            role: result.message.role,
+                            project_path: project.project_path,
+                            source_type: project.source_type,
+                        });
+                        if (project.source_type === "claude-code") {
+                            claudeCodeResults++;
+                        }
+                        else {
+                            codexResults++;
+                        }
+                    }
+                }
+                catch (_error) {
+                    // Skip projects that fail to search
+                    continue;
+                }
+                finally {
+                    // Close project database
+                    if (projectDb) {
+                        projectDb.close();
+                    }
+                }
+            }
+            // Sort by similarity and paginate
+            const sortedResults = allResults.sort((a, b) => b.similarity - a.similarity);
+            const paginatedResults = sortedResults.slice(offset, offset + limit);
+            return {
+                query,
+                results: paginatedResults,
+                total_found: paginatedResults.length,
+                has_more: offset + limit < sortedResults.length,
+                offset,
+                projects_searched: projects.length,
+                search_stats: {
+                    claude_code_results: claudeCodeResults,
+                    codex_results: codexResults,
+                },
+                message: `Found ${paginatedResults.length} result(s) across ${projects.length} project(s)`,
+            };
+        }
+        finally {
+            // Ensure GlobalIndex is always closed
+            globalIndex.close();
+        }
+    }
+    /**
+     * Get decisions from all indexed projects.
+     *
+     * @param args - Query arguments
+     * @returns Decisions from all projects
+     */
+    async getAllDecisions(args) {
+        const { GlobalIndex } = await import("../storage/GlobalIndex.js");
+        const { SQLiteManager } = await import("../storage/SQLiteManager.js");
+        const typedArgs = args;
+        const { query, file_path, limit = 20, offset = 0, source_type = 'all' } = typedArgs;
+        const globalIndex = new GlobalIndex();
+        try {
+            const projects = globalIndex.getAllProjects(source_type === "all" ? undefined : source_type);
+            const allDecisions = [];
+            for (const project of projects) {
+                let projectDb = null;
+                try {
+                    projectDb = new SQLiteManager({ dbPath: project.db_path, readOnly: true });
+                    const sanitized = sanitizeForLike(query);
+                    let sql = "SELECT * FROM decisions WHERE decision_text LIKE ? ESCAPE '\\\\'";
+                    const params = [`%${sanitized}%`];
+                    if (file_path) {
+                        sql += " AND related_files LIKE ?";
+                        params.push(`%${file_path}%`);
+                    }
+                    sql += " ORDER BY timestamp DESC LIMIT ?";
+                    params.push(limit + offset + 1);
+                    const decisions = projectDb.prepare(sql).all(...params);
+                    for (const d of decisions) {
+                        allDecisions.push({
+                            decision_id: d.id,
+                            decision_text: d.decision_text,
+                            rationale: d.rationale,
+                            alternatives_considered: JSON.parse(d.alternatives_considered || "[]"),
+                            rejected_reasons: JSON.parse(d.rejected_reasons || "{}"),
+                            context: d.context,
+                            related_files: JSON.parse(d.related_files || "[]"),
+                            related_commits: JSON.parse(d.related_commits || "[]"),
+                            timestamp: new Date(d.timestamp).toISOString(),
+                            similarity: DEFAULT_SIMILARITY_SCORE,
+                            project_path: project.project_path,
+                            source_type: project.source_type,
+                        });
+                    }
+                }
+                catch (_error) {
+                    continue;
+                }
+                finally {
+                    if (projectDb) {
+                        projectDb.close();
+                    }
+                }
+            }
+            // Sort by timestamp and paginate
+            const sortedDecisions = allDecisions.sort((a, b) => new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime());
+            const paginatedDecisions = sortedDecisions.slice(offset, offset + limit);
+            return {
+                query,
+                decisions: paginatedDecisions,
+                total_found: paginatedDecisions.length,
+                has_more: offset + limit < sortedDecisions.length,
+                offset,
+                projects_searched: projects.length,
+                message: `Found ${paginatedDecisions.length} decision(s) across ${projects.length} project(s)`,
+            };
+        }
+        finally {
+            globalIndex.close();
+        }
+    }
+    /**
+     * Search mistakes across all indexed projects.
+     *
+     * @param args - Search arguments
+     * @returns Mistakes from all projects
+     */
+    async searchAllMistakes(args) {
+        const { GlobalIndex } = await import("../storage/GlobalIndex.js");
+        const { SQLiteManager } = await import("../storage/SQLiteManager.js");
+        const typedArgs = args;
+        const { query, mistake_type, limit = 20, offset = 0, source_type = 'all' } = typedArgs;
+        const globalIndex = new GlobalIndex();
+        try {
+            const projects = globalIndex.getAllProjects(source_type === "all" ? undefined : source_type);
+            const allMistakes = [];
+            for (const project of projects) {
+                let projectDb = null;
+                try {
+                    projectDb = new SQLiteManager({ dbPath: project.db_path, readOnly: true });
+                    const sanitized = sanitizeForLike(query);
+                    let sql = "SELECT * FROM mistakes WHERE what_went_wrong LIKE ? ESCAPE '\\\\'";
+                    const params = [`%${sanitized}%`];
+                    if (mistake_type) {
+                        sql += " AND mistake_type = ?";
+                        params.push(mistake_type);
+                    }
+                    sql += " ORDER BY timestamp DESC LIMIT ?";
+                    params.push(limit + offset + 1);
+                    const mistakes = projectDb.prepare(sql).all(...params);
+                    for (const m of mistakes) {
+                        allMistakes.push({
+                            mistake_id: m.id,
+                            mistake_type: m.mistake_type,
+                            what_went_wrong: m.what_went_wrong,
+                            correction: m.correction,
+                            user_correction_message: m.user_correction_message,
+                            files_affected: JSON.parse(m.files_affected || "[]"),
+                            timestamp: new Date(m.timestamp).toISOString(),
+                            project_path: project.project_path,
+                            source_type: project.source_type,
+                        });
+                    }
+                }
+                catch (_error) {
+                    continue;
+                }
+                finally {
+                    if (projectDb) {
+                        projectDb.close();
+                    }
+                }
+            }
+            // Sort by timestamp and paginate
+            const sortedMistakes = allMistakes.sort((a, b) => new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime());
+            const paginatedMistakes = sortedMistakes.slice(offset, offset + limit);
+            return {
+                query,
+                mistakes: paginatedMistakes,
+                total_found: paginatedMistakes.length,
+                has_more: offset + limit < sortedMistakes.length,
+                offset,
+                projects_searched: projects.length,
+                message: `Found ${paginatedMistakes.length} mistake(s) across ${projects.length} project(s)`,
+            };
+        }
+        finally {
+            globalIndex.close();
+        }
+    }
 }
 //# sourceMappingURL=ToolHandlers.js.map