@grec0/memory-bank-mcp 0.1.3 → 0.1.5

package/dist/common/projectKnowledgeService.js

@@ -362,7 +362,7 @@ ${chunk.content}
         return doc;
     }
     /**
-     * Generates all project documents
+     * Generates all project documents (in parallel for speed)
      */
     async generateAllDocuments(chunks, force = false) {
         const result = {
@@ -374,54 +374,65 @@ ${chunk.content}
             totalOutputTokens: 0,
             errors: [],
         };
-        // Get previous progress if exists
+        // Get previous progress if exists (read before parallel generation)
         let previousProgress;
         const progressPath = path.join(this.options.docsPath, "progress.md");
         if (fs.existsSync(progressPath)) {
             previousProgress = fs.readFileSync(progressPath, "utf-8");
         }
-        // Define generation order (some docs may depend on others conceptually)
-        const docOrder = [
-            "techContext", // Foundation - understand the tech stack first
-            "projectBrief", // High-level overview
-            "systemPatterns", // Architecture
-            "productContext", // Business/user perspective
-            "activeContext", // Current state
-            "progress", // Progress tracking (last, uses previous data)
+        // Prepare chunks for activeContext (recent only)
+        const recentChunks = [...chunks]
+            .sort((a, b) => b.timestamp - a.timestamp)
+            .slice(0, Math.min(30, chunks.length));
+        // All document types to generate
+        const docTypes = [
+            "techContext",
+            "projectBrief",
+            "systemPatterns",
+            "productContext",
+            "activeContext",
+            "progress",
         ];
-        for (const docType of docOrder) {
+        console.error(`\n🚀 Generating ${docTypes.length} documents in PARALLEL...`);
+        // Generate all documents in parallel
+        const generationPromises = docTypes.map(async (docType) => {
             try {
-                // For activeContext, use only recent chunks (by timestamp)
-                let docChunks = chunks;
-                if (docType === "activeContext") {
-                    // Sort by timestamp and take most recent
-                    docChunks = [...chunks]
-                        .sort((a, b) => b.timestamp - a.timestamp)
-                        .slice(0, Math.min(30, chunks.length));
-                }
+                // For activeContext, use only recent chunks
+                const docChunks = docType === "activeContext" ? recentChunks : chunks;
                 const existingMetadata = this.metadataCache.get(docType);
                 const isNew = !existingMetadata;
                 const doc = await this.generateDocument(docType, docChunks, force, docType === "progress" ? previousProgress : undefined);
-                if (doc) {
-                    result.totalReasoningTokens += doc.metadata.reasoningTokens;
-                    result.totalOutputTokens += doc.metadata.outputTokens;
-                    if (isNew) {
-                        result.documentsGenerated.push(docType);
-                    }
-                    else {
-                        result.documentsUpdated.push(docType);
-                    }
-                }
-                else {
-                    result.documentsSkipped.push(docType);
-                }
+                return { docType, doc, isNew, error: null };
             }
             catch (error) {
+                return { docType, doc: null, isNew: false, error: error };
+            }
+        });
+        // Wait for all documents to complete
+        const results = await Promise.all(generationPromises);
+        // Process results
+        for (const { docType, doc, isNew, error } of results) {
+            if (error) {
                 console.error(`Error generating ${docType}: ${error.message}`);
                 result.errors.push(`${docType}: ${error.message}`);
                 result.success = false;
+                continue;
+            }
+            if (doc) {
+                result.totalReasoningTokens += doc.metadata.reasoningTokens;
+                result.totalOutputTokens += doc.metadata.outputTokens;
+                if (isNew) {
+                    result.documentsGenerated.push(docType);
+                }
+                else {
+                    result.documentsUpdated.push(docType);
+                }
+            }
+            else {
+                result.documentsSkipped.push(docType);
             }
         }
+        console.error(`\n✅ Parallel generation complete: ${result.documentsGenerated.length + result.documentsUpdated.length} docs, ${result.totalReasoningTokens} reasoning + ${result.totalOutputTokens} output tokens`);
         return result;
     }
     /**
@@ -462,42 +473,53 @@ ${chunk.content}
             totalOutputTokens: 0,
             errors: [],
         };
-        // Get previous progress
+        // Get previous progress (read before parallel generation)
         let previousProgress;
         const progressPath = path.join(this.options.docsPath, "progress.md");
         if (fs.existsSync(progressPath)) {
             previousProgress = fs.readFileSync(progressPath, "utf-8");
         }
-        for (const docType of docsToUpdate) {
+        // Prepare recent chunks for activeContext
+        const recentChunks = [...chunks]
+            .sort((a, b) => b.timestamp - a.timestamp)
+            .slice(0, Math.min(30, chunks.length));
+        console.error(`\n🚀 Updating ${docsToUpdate.length} documents in PARALLEL...`);
+        // Generate docs in parallel
+        const updatePromises = docsToUpdate.map(async (docType) => {
             try {
-                let docChunks = chunks;
-                if (docType === "activeContext") {
-                    docChunks = [...chunks]
-                        .sort((a, b) => b.timestamp - a.timestamp)
-                        .slice(0, Math.min(30, chunks.length));
-                }
+                const docChunks = docType === "activeContext" ? recentChunks : chunks;
                 const existingMetadata = this.metadataCache.get(docType);
                 const isNew = !existingMetadata;
                 const doc = await this.generateDocument(docType, docChunks, true, // Force update for changed docs
                 docType === "progress" ? previousProgress : undefined);
-                if (doc) {
-                    result.totalReasoningTokens += doc.metadata.reasoningTokens;
-                    result.totalOutputTokens += doc.metadata.outputTokens;
-                    if (isNew) {
-                        result.documentsGenerated.push(docType);
-                    }
-                    else {
-                        result.documentsUpdated.push(docType);
-                    }
-                }
-                else {
-                    result.documentsSkipped.push(docType);
-                }
+                return { docType, doc, isNew, error: null };
             }
             catch (error) {
+                return { docType, doc: null, isNew: false, error: error };
+            }
+        });
+        // Wait for all
+        const updateResults = await Promise.all(updatePromises);
+        // Process results
+        for (const { docType, doc, isNew, error } of updateResults) {
+            if (error) {
                 console.error(`Error updating ${docType}: ${error.message}`);
                 result.errors.push(`${docType}: ${error.message}`);
                 result.success = false;
+                continue;
+            }
+            if (doc) {
+                result.totalReasoningTokens += doc.metadata.reasoningTokens;
+                result.totalOutputTokens += doc.metadata.outputTokens;
+                if (isNew) {
+                    result.documentsGenerated.push(docType);
+                }
+                else {
+                    result.documentsUpdated.push(docType);
+                }
+            }
+            else {
+                result.documentsSkipped.push(docType);
             }
         }
         // Mark docs we didn't update as skipped

package/dist/tools/analyzeCoverage.js

@@ -234,34 +234,40 @@ export async function analyzeCoverage(indexManager, vectorStore, workspaceRoot,
             console.error(`Error escaneando archivos: ${error}`);
             throw error;
         }
-        // 2. Get indexed files from vector store
-        console.error("Obteniendo archivos indexados...");
+        // 2. Get ALL chunks from vector store in ONE query (optimized)
+        console.error("Obteniendo todos los chunks indexados (query única)...");
         await vectorStore.initialize();
-        const fileHashes = await vectorStore.getFileHashes();
-        // 3. Get index metadata
-        const indexStats = await indexManager.getStats();
-        // 4. Build indexed files map with chunk counts
+        const queryStart = Date.now();
+        const allChunks = await vectorStore.getAllChunks(projectId);
+        console.error(`Query completada en ${Date.now() - queryStart}ms - ${allChunks.length} chunks`);
+        // 3. Build indexed files map from chunks (in memory - fast)
+        console.error("Procesando chunks en memoria...");
         const indexedFiles = new Map();
-        // Get chunks grouped by file from vector store
-        for (const [filePath, hash] of fileHashes) {
-            const chunks = await vectorStore.getChunksByFile(filePath);
-            if (chunks.length > 0) {
-                indexedFiles.set(filePath, {
-                    lastIndexed: chunks[0].timestamp,
-                    chunks: chunks.length,
+        for (const chunk of allChunks) {
+            const existing = indexedFiles.get(chunk.file_path);
+            if (!existing) {
+                indexedFiles.set(chunk.file_path, {
+                    lastIndexed: chunk.timestamp,
+                    chunks: 1,
+                    hash: chunk.file_hash,
                 });
             }
+            else {
+                existing.chunks++;
+                // Keep most recent timestamp
+                if (chunk.timestamp > existing.lastIndexed) {
+                    existing.lastIndexed = chunk.timestamp;
+                }
+            }
         }
-        // 5. Identify pending files (files that changed)
+        // 4. Get index stats
+        const indexStats = await indexManager.getStats();
+        // 5. Identify pending files (files that changed) - in memory comparison
         const pendingFiles = new Set();
         for (const file of allFiles) {
             const indexed = indexedFiles.get(file.path);
-            if (indexed) {
-                // Check if file hash matches
-                const chunks = await vectorStore.getChunksByFile(file.path);
-                if (chunks.length > 0 && chunks[0].file_hash !== file.hash) {
-                    pendingFiles.add(file.path);
-                }
+            if (indexed && indexed.hash !== file.hash) {
+                pendingFiles.add(file.path);
             }
         }
         console.error(`Archivos indexados: ${indexedFiles.size}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@grec0/memory-bank-mcp",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "description": "MCP server for semantic code indexing with Memory Bank - AI-powered codebase understanding",
   "license": "MIT",
   "author": "@grec0",