claude-conversation-memory-mcp 1.5.0 → 1.6.4

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,106 @@ 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,
+                        });
+                    }
+                }
+                catch (_error) {
+                    // Skip projects that fail to search (embedding errors, etc.)
+                    // Continue to next project
+                    continue;
+                }
+                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 +302,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 +351,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 +405,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,
         };
     }
     /**
@@ -356,7 +511,7 @@ export class ToolHandlers {
      */
     async getFileEvolution(args) {
         const typedArgs = args;
-        const { file_path, include_decisions = true, include_commits = true } = typedArgs;
+        const { file_path, include_decisions = true, include_commits = true, limit = 50, offset = 0 } = typedArgs;
         const timeline = this.memory.getFileTimeline(file_path);
         const events = [];
         timeline.edits.forEach((edit) => {
@@ -396,10 +551,13 @@ export class ToolHandlers {
         }
         // Sort by timestamp (descending - most recent first)
         events.sort((a, b) => new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime());
+        // Apply pagination
+        const paginatedEvents = events.slice(offset, offset + limit);
         return {
             file_path,
             total_edits: timeline.edits.length,
-            timeline: events,
+            timeline: paginatedEvents,
+            has_more: offset + limit < events.length,
         };
     }
     /**
@@ -442,24 +600,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 +638,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 +683,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 +712,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 +738,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 +1000,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 +1031,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 +1084,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 +1112,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 +1138,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) {
@@ -1425,7 +1641,7 @@ export class ToolHandlers {
         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 { include_codex = true, include_claude_code = true, codex_path = join(homedir(), ".codex"), claude_projects_path = join(homedir(), ".claude", "projects"), incremental = true, } = typedArgs;
         const globalIndex = new GlobalIndex();
         try {
             const projects = [];
@@ -1440,13 +1656,24 @@ export class ToolHandlers {
                     const { CodexConversationParser } = await import("../parsers/CodexConversationParser.js");
                     const { SQLiteManager } = await import("../storage/SQLiteManager.js");
                     const { ConversationStorage } = await import("../storage/ConversationStorage.js");
+                    const { SemanticSearch } = await import("../search/SemanticSearch.js");
+                    const { DecisionExtractor } = await import("../parsers/DecisionExtractor.js");
+                    const { MistakeExtractor } = await import("../parsers/MistakeExtractor.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);
+                    // Get last indexed time for incremental mode
+                    let codexLastIndexedMs;
+                    if (incremental) {
+                        const existingProject = globalIndex.getProject(codex_path);
+                        if (existingProject) {
+                            codexLastIndexedMs = existingProject.last_indexed;
+                        }
+                    }
                     // Parse Codex sessions
                     const parser = new CodexConversationParser();
-                    const parseResult = parser.parseSession(codex_path);
+                    const parseResult = parser.parseSession(codex_path, undefined, codexLastIndexedMs);
                     // Store all parsed data
                     await codexStorage.storeConversations(parseResult.conversations);
                     await codexStorage.storeMessages(parseResult.messages);
@@ -1454,6 +1681,25 @@ export class ToolHandlers {
                     await codexStorage.storeToolResults(parseResult.tool_results);
                     await codexStorage.storeFileEdits(parseResult.file_edits);
                     await codexStorage.storeThinkingBlocks(parseResult.thinking_blocks);
+                    // Extract and store decisions
+                    const decisionExtractor = new DecisionExtractor();
+                    const decisions = decisionExtractor.extractDecisions(parseResult.messages, parseResult.thinking_blocks);
+                    await codexStorage.storeDecisions(decisions);
+                    // Extract and store mistakes
+                    const mistakeExtractor = new MistakeExtractor();
+                    const mistakes = mistakeExtractor.extractMistakes(parseResult.messages, parseResult.tool_results);
+                    await codexStorage.storeMistakes(mistakes);
+                    // Generate embeddings for semantic search
+                    try {
+                        const semanticSearch = new SemanticSearch(codexDb);
+                        await semanticSearch.indexMessages(parseResult.messages, incremental);
+                        await semanticSearch.indexDecisions(decisions, incremental);
+                        console.log(`✓ Generated embeddings for Codex project`);
+                    }
+                    catch (embedError) {
+                        console.warn("⚠️ Embedding generation failed for Codex:", embedError.message);
+                        console.warn("   FTS fallback will be used for search");
+                    }
                     // Get stats from the database
                     const stats = codexDb.getDatabase()
                         .prepare("SELECT COUNT(*) as count FROM conversations")
@@ -1503,38 +1749,102 @@ export class ToolHandlers {
             // Index Claude Code projects if requested
             if (include_claude_code && existsSync(claude_projects_path)) {
                 try {
+                    const { SQLiteManager } = await import("../storage/SQLiteManager.js");
+                    const { ConversationStorage } = await import("../storage/ConversationStorage.js");
+                    const { ConversationParser } = await import("../parsers/ConversationParser.js");
+                    const { DecisionExtractor } = await import("../parsers/DecisionExtractor.js");
+                    const { MistakeExtractor } = await import("../parsers/MistakeExtractor.js");
+                    const { statSync } = await import("fs");
                     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;
+                            // Skip if not a directory
+                            if (!statSync(folderPath).isDirectory()) {
+                                continue;
+                            }
+                            // Create dedicated database for this Claude Code project
+                            const projectDbPath = join(folderPath, ".claude-conversations-memory.db");
+                            const projectDb = new SQLiteManager({ dbPath: projectDbPath });
+                            const projectStorage = new ConversationStorage(projectDb);
+                            // Get last indexed time for incremental mode
+                            let lastIndexedMs;
+                            if (incremental) {
+                                const existingProject = globalIndex.getProject(folderPath);
+                                if (existingProject) {
+                                    lastIndexedMs = existingProject.last_indexed;
+                                }
+                            }
+                            // Parse Claude Code conversations directly from this folder
+                            const parser = new ConversationParser();
+                            const parseResult = parser.parseFromFolder(folderPath, undefined, lastIndexedMs);
+                            // Skip empty projects
+                            if (parseResult.messages.length === 0) {
+                                projectDb.close();
+                                continue;
+                            }
+                            // Store all parsed data
+                            await projectStorage.storeConversations(parseResult.conversations);
+                            await projectStorage.storeMessages(parseResult.messages);
+                            await projectStorage.storeToolUses(parseResult.tool_uses);
+                            await projectStorage.storeToolResults(parseResult.tool_results);
+                            await projectStorage.storeFileEdits(parseResult.file_edits);
+                            await projectStorage.storeThinkingBlocks(parseResult.thinking_blocks);
+                            // Extract and store decisions
+                            const decisionExtractor = new DecisionExtractor();
+                            const decisions = decisionExtractor.extractDecisions(parseResult.messages, parseResult.thinking_blocks);
+                            await projectStorage.storeDecisions(decisions);
+                            // Extract and store mistakes
+                            const mistakeExtractor = new MistakeExtractor();
+                            const mistakes = mistakeExtractor.extractMistakes(parseResult.messages, parseResult.tool_results);
+                            await projectStorage.storeMistakes(mistakes);
+                            // Generate embeddings for semantic search
+                            try {
+                                const { SemanticSearch } = await import("../search/SemanticSearch.js");
+                                const semanticSearch = new SemanticSearch(projectDb);
+                                await semanticSearch.indexMessages(parseResult.messages, incremental);
+                                await semanticSearch.indexDecisions(decisions, incremental);
+                                console.log(`✓ Generated embeddings for project: ${folder}`);
+                            }
+                            catch (embedError) {
+                                console.warn(`⚠️ Embedding generation failed for ${folder}:`, embedError.message);
+                                console.warn("   FTS fallback will be used for search");
                             }
+                            // Get stats from the database
+                            const stats = projectDb.getDatabase()
+                                .prepare("SELECT COUNT(*) as count FROM conversations")
+                                .get();
+                            const messageStats = projectDb.getDatabase()
+                                .prepare("SELECT COUNT(*) as count FROM messages")
+                                .get();
+                            const decisionStats = projectDb.getDatabase()
+                                .prepare("SELECT COUNT(*) as count FROM decisions")
+                                .get();
+                            const mistakeStats = projectDb.getDatabase()
+                                .prepare("SELECT COUNT(*) as count FROM mistakes")
+                                .get();
+                            // Register in global index with the project-specific database path
+                            globalIndex.registerProject({
+                                project_path: folderPath,
+                                source_type: "claude-code",
+                                db_path: projectDbPath,
+                                message_count: messageStats.count,
+                                conversation_count: stats.count,
+                                decision_count: decisionStats.count,
+                                mistake_count: mistakeStats.count,
+                            });
+                            projects.push({
+                                project_path: folderPath,
+                                source_type: "claude-code",
+                                message_count: messageStats.count,
+                                conversation_count: stats.count,
+                            });
+                            totalMessages += messageStats.count;
+                            totalConversations += stats.count;
+                            totalDecisions += decisionStats.count;
+                            totalMistakes += mistakeStats.count;
+                            // Close the project database
+                            projectDb.close();
                         }
                         catch (error) {
                             errors.push({
@@ -1583,7 +1893,7 @@ export class ToolHandlers {
         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 { 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);
@@ -1638,18 +1948,21 @@ export class ToolHandlers {
                     }
                 }
             }
-            // Sort by similarity and limit
-            const sortedResults = allResults.sort((a, b) => b.similarity - a.similarity).slice(0, limit);
+            // 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: sortedResults,
-                total_found: sortedResults.length,
+                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 ${sortedResults.length} result(s) across ${projects.length} project(s)`,
+                message: `Found ${paginatedResults.length} result(s) across ${projects.length} project(s)`,
             };
         }
         finally {
@@ -1665,19 +1978,64 @@ export class ToolHandlers {
      */
     async getAllDecisions(args) {
         const { GlobalIndex } = await import("../storage/GlobalIndex.js");
+        const { SQLiteManager } = await import("../storage/SQLiteManager.js");
         const typedArgs = args;
-        const { query, file_path: _file_path } = typedArgs;
+        const { query, file_path, limit = 20, offset = 0, source_type = 'all' } = typedArgs;
         const globalIndex = new GlobalIndex();
         try {
-            const projects = globalIndex.getAllProjects();
-            // TODO: Implement cross-project decision search
-            // For now, return empty results with proper structure
+            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: [],
-                total_found: 0,
+                decisions: paginatedDecisions,
+                total_found: paginatedDecisions.length,
+                has_more: offset + limit < sortedDecisions.length,
+                offset,
                 projects_searched: projects.length,
-                message: `Cross-project decision search not yet implemented (would search ${projects.length} project(s))`,
+                message: `Found ${paginatedDecisions.length} decision(s) across ${projects.length} project(s)`,
             };
         }
         finally {
@@ -1692,19 +2050,61 @@ export class ToolHandlers {
      */
     async searchAllMistakes(args) {
         const { GlobalIndex } = await import("../storage/GlobalIndex.js");
+        const { SQLiteManager } = await import("../storage/SQLiteManager.js");
         const typedArgs = args;
-        const { query, mistake_type: _mistake_type } = typedArgs;
+        const { query, mistake_type, limit = 20, offset = 0, source_type = 'all' } = typedArgs;
         const globalIndex = new GlobalIndex();
         try {
-            const projects = globalIndex.getAllProjects();
-            // TODO: Implement cross-project mistake search
-            // For now, return empty results with proper structure
+            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: [],
-                total_found: 0,
+                mistakes: paginatedMistakes,
+                total_found: paginatedMistakes.length,
+                has_more: offset + limit < sortedMistakes.length,
+                offset,
                 projects_searched: projects.length,
-                message: `Cross-project mistake search not yet implemented (would search ${projects.length} project(s))`,
+                message: `Found ${paginatedMistakes.length} mistake(s) across ${projects.length} project(s)`,
             };
         }
         finally {