claude-conversation-memory-mcp 1.3.0 → 1.5.0

package/dist/tools/ToolHandlers.js

@@ -598,7 +598,7 @@ export class ToolHandlers {
         };
     }
     /**
-     * Query history of tool uses (bash commands, file edits, reads, etc.).
+     * Query history of tool uses (bash commands, file edits, reads, etc.) with pagination and filtering.
      *
      * Shows what tools were used during conversations and their results. Useful
      * for understanding what commands were run, what files were edited, and
@@ -608,72 +608,152 @@ export class ToolHandlers {
      * - `tool_name`: Optional filter by tool name (Bash, Edit, Write, Read)
      * - `file_path`: Optional filter by file path
      * - `limit`: Maximum number of results (default: 20)
+     * - `offset`: Skip N results for pagination (default: 0)
+     * - `include_content`: Include tool content in response (default: true, false for metadata only)
+     * - `max_content_length`: Maximum characters per content field (default: 500)
+     * - `date_range`: Filter by timestamp range [start, end]
+     * - `conversation_id`: Filter by specific conversation
+     * - `errors_only`: Show only failed tool uses (default: false)
      *
      * @returns Tool history containing:
      * - `tool_name`: Tool filter if applied
      * - `file_path`: File filter if applied
-     * - `tool_uses`: Array of tool uses with:
-     *   - `tool_use_id`: Tool use identifier
-     *   - `tool_name`: Name of the tool used
-     *   - `tool_input`: Input parameters to the tool
-     *   - `result`: Tool execution result with:
-     *     - `content`: Result content
-     *     - `is_error`: Whether the tool failed
-     *     - `stdout`: Standard output (for Bash)
-     *     - `stderr`: Standard error (for Bash)
-     *   - `timestamp`: When the tool was used
-     * - `total_found`: Number of tool uses returned
+     * - `tool_uses`: Array of tool uses (may have truncated content)
+     * - `total_found`: Number of results returned in this page
+     * - `total_in_database`: Total matching records in database
+     * - `has_more`: Whether more results exist beyond current page
+     * - `offset`: Current offset position
      *
      * @example
      * ```typescript
-     * const history = await handlers.getToolHistory({
+     * // Get first page of Bash commands
+     * const page1 = await handlers.getToolHistory({
      *   tool_name: 'Bash',
-     *   limit: 10
+     *   limit: 20,
+     *   offset: 0
      * });
-     * history.tool_uses.forEach(t => {
-     *   console.log(`${t.tool_name}: ${JSON.stringify(t.tool_input)}`);
-     *   console.log(`Success: ${!t.result.is_error}`);
+     *
+     * // Get metadata only (no content)
+     * const metadata = await handlers.getToolHistory({
+     *   include_content: false,
+     *   limit: 50
+     * });
+     *
+     * // Get errors from last 24 hours
+     * const errors = await handlers.getToolHistory({
+     *   errors_only: true,
+     *   date_range: [Date.now() - 86400000, Date.now()]
      * });
      * ```
      */
     async getToolHistory(args) {
         const typedArgs = args;
-        const { tool_name, file_path, limit = 20 } = typedArgs;
-        let sql = `
-      SELECT tu.*, tr.content as result_content, tr.is_error, tr.stdout, tr.stderr
-      FROM tool_uses tu
-      LEFT JOIN tool_results tr ON tu.id = tr.tool_use_id
-      WHERE 1=1
-    `;
+        const { tool_name, file_path, limit = 20, offset = 0, include_content = true, max_content_length = 500, date_range, conversation_id, errors_only = false, } = typedArgs;
+        // Helper function to truncate text with indicator
+        const truncateText = (text, maxLength) => {
+            if (!text) {
+                return { value: undefined, truncated: false };
+            }
+            if (text.length <= maxLength) {
+                return { value: text, truncated: false };
+            }
+            return {
+                value: text.substring(0, maxLength) + '... (truncated)',
+                truncated: true,
+            };
+        };
+        // Build WHERE clause for filters
+        let whereClause = "WHERE 1=1";
         const params = [];
         if (tool_name) {
-            sql += " AND tu.tool_name = ?";
+            whereClause += " AND tu.tool_name = ?";
             params.push(tool_name);
         }
         if (file_path) {
             const sanitized = sanitizeForLike(file_path);
-            sql += " AND tu.tool_input LIKE ? ESCAPE '\\'";
+            whereClause += " AND tu.tool_input LIKE ? ESCAPE '\\'";
             params.push(`%${sanitized}%`);
         }
-        sql += " ORDER BY tu.timestamp DESC LIMIT ?";
-        params.push(limit);
-        const toolUses = this.db.prepare(sql).all(...params);
+        if (date_range && date_range.length === 2) {
+            whereClause += " AND tu.timestamp BETWEEN ? AND ?";
+            params.push(date_range[0], date_range[1]);
+        }
+        if (conversation_id) {
+            whereClause += " AND tu.message_id IN (SELECT id FROM messages WHERE conversation_id = ?)";
+            params.push(conversation_id);
+        }
+        if (errors_only) {
+            whereClause += " AND tr.is_error = 1";
+        }
+        // Get total count of matching records
+        const countSql = `
+      SELECT COUNT(*) as total
+      FROM tool_uses tu
+      LEFT JOIN tool_results tr ON tu.id = tr.tool_use_id
+      ${whereClause}
+    `;
+        const countResult = this.db.prepare(countSql).get(...params);
+        const totalInDatabase = countResult.total;
+        // Get paginated results
+        const sql = `
+      SELECT tu.*, tr.content as result_content, tr.is_error, tr.stdout, tr.stderr
+      FROM tool_uses tu
+      LEFT JOIN tool_results tr ON tu.id = tr.tool_use_id
+      ${whereClause}
+      ORDER BY tu.timestamp DESC
+      LIMIT ? OFFSET ?
+    `;
+        const queryParams = [...params, limit, offset];
+        const toolUses = this.db.prepare(sql).all(...queryParams);
+        // Calculate pagination metadata
+        const hasMore = offset + toolUses.length < totalInDatabase;
         return {
             tool_name,
             file_path,
-            tool_uses: toolUses.map((t) => ({
-                tool_use_id: t.id,
-                tool_name: t.tool_name,
-                tool_input: JSON.parse(t.tool_input || "{}"),
-                result: {
-                    content: t.result_content,
+            tool_uses: toolUses.map((t) => {
+                // Parse tool input
+                const toolInput = JSON.parse(t.tool_input || "{}");
+                // Build result object based on include_content setting
+                const result = {
                     is_error: Boolean(t.is_error),
-                    stdout: t.stdout,
-                    stderr: t.stderr,
-                },
-                timestamp: new Date(t.timestamp).toISOString(),
-            })),
+                };
+                if (include_content) {
+                    // Truncate content fields if they exist
+                    const contentTrunc = truncateText(t.result_content, max_content_length);
+                    const stdoutTrunc = truncateText(t.stdout, max_content_length);
+                    const stderrTrunc = truncateText(t.stderr, max_content_length);
+                    if (contentTrunc.value !== undefined) {
+                        result.content = contentTrunc.value;
+                        if (contentTrunc.truncated) {
+                            result.content_truncated = true;
+                        }
+                    }
+                    if (stdoutTrunc.value !== undefined) {
+                        result.stdout = stdoutTrunc.value;
+                        if (stdoutTrunc.truncated) {
+                            result.stdout_truncated = true;
+                        }
+                    }
+                    if (stderrTrunc.value !== undefined) {
+                        result.stderr = stderrTrunc.value;
+                        if (stderrTrunc.truncated) {
+                            result.stderr_truncated = true;
+                        }
+                    }
+                }
+                // If include_content=false, only return is_error (no content, stdout, stderr)
+                return {
+                    tool_use_id: t.id,
+                    tool_name: t.tool_name,
+                    tool_input: toolInput,
+                    result,
+                    timestamp: new Date(t.timestamp).toISOString(),
+                };
+            }),
             total_found: toolUses.length,
+            total_in_database: totalInDatabase,
+            has_more: hasMore,
+            offset,
         };
     }
     /**
@@ -1329,5 +1409,307 @@ 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, 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 limit
+            const sortedResults = allResults.sort((a, b) => b.similarity - a.similarity).slice(0, limit);
+            return {
+                query,
+                results: sortedResults,
+                total_found: sortedResults.length,
+                projects_searched: projects.length,
+                search_stats: {
+                    claude_code_results: claudeCodeResults,
+                    codex_results: codexResults,
+                },
+                message: `Found ${sortedResults.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 typedArgs = args;
+        const { query, file_path: _file_path } = typedArgs;
+        const globalIndex = new GlobalIndex();
+        try {
+            const projects = globalIndex.getAllProjects();
+            // TODO: Implement cross-project decision search
+            // For now, return empty results with proper structure
+            return {
+                query,
+                decisions: [],
+                total_found: 0,
+                projects_searched: projects.length,
+                message: `Cross-project decision search not yet implemented (would search ${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 typedArgs = args;
+        const { query, mistake_type: _mistake_type } = typedArgs;
+        const globalIndex = new GlobalIndex();
+        try {
+            const projects = globalIndex.getAllProjects();
+            // TODO: Implement cross-project mistake search
+            // For now, return empty results with proper structure
+            return {
+                query,
+                mistakes: [],
+                total_found: 0,
+                projects_searched: projects.length,
+                message: `Cross-project mistake search not yet implemented (would search ${projects.length} project(s))`,
+            };
+        }
+        finally {
+            globalIndex.close();
+        }
+    }
 }
 //# sourceMappingURL=ToolHandlers.js.map