@grec0/memory-bank-mcp 0.0.2 → 0.0.4

package/dist/common/vectorStore.js

@@ -1,6 +1,7 @@
 /**
  * @fileoverview Vector store for Memory Bank using LanceDB
  * Manages storage and retrieval of code embeddings
+ * Uses snake_case for field names for LanceDB SQL compatibility
  */
 import * as lancedb from "@lancedb/lancedb";
 import * as fs from "fs";
@@ -130,7 +131,8 @@ export class VectorStore {
             return;
         }
         try {
-            await this.table.delete(`filePath = '${filePath}'`);
+            // Use snake_case field name for LanceDB SQL compatibility
+            await this.table.delete(`file_path = '${filePath}'`);
             console.error(`Deleted all chunks from file: ${filePath}`);
         }
         catch (error) {
@@ -152,15 +154,18 @@ export class VectorStore {
         try {
             // Start with vector search
             let query = this.table.search(queryVector).limit(topK);
-            // Apply filters if specified
+            // Apply filters if specified (using snake_case field names)
             if (options.filterByFile) {
-                query = query.where(`filePath LIKE '%${options.filterByFile}%'`);
+                query = query.where(`file_path LIKE '%${options.filterByFile}%'`);
             }
             if (options.filterByLanguage) {
                 query = query.where(`language = '${options.filterByLanguage}'`);
             }
             if (options.filterByType) {
-                query = query.where(`chunkType = '${options.filterByType}'`);
+                query = query.where(`chunk_type = '${options.filterByType}'`);
+            }
+            if (options.filterByProject) {
+                query = query.where(`project_id = '${options.filterByProject}'`);
             }
             // Execute search
             const results = await query.toArray();
@@ -174,16 +179,17 @@ export class VectorStore {
                     chunk: {
                         id: result.id,
                         vector: result.vector,
-                        filePath: result.filePath,
+                        file_path: result.file_path,
                         content: result.content,
-                        startLine: result.startLine,
-                        endLine: result.endLine,
-                        chunkType: result.chunkType,
+                        start_line: result.start_line,
+                        end_line: result.end_line,
+                        chunk_type: result.chunk_type,
                         name: result.name,
                         language: result.language,
-                        fileHash: result.fileHash,
+                        file_hash: result.file_hash,
                         timestamp: result.timestamp,
                         context: result.context,
+                        project_id: result.project_id,
                     },
                     score,
                     distance,
@@ -207,21 +213,23 @@ export class VectorStore {
         }
         try {
             const results = await this.table
-                .where(`filePath = '${filePath}'`)
+                .query()
+                .where(`file_path = '${filePath}'`)
                 .toArray();
             return results.map((r) => ({
                 id: r.id,
                 vector: r.vector,
-                filePath: r.filePath,
+                file_path: r.file_path,
                 content: r.content,
-                startLine: r.startLine,
-                endLine: r.endLine,
-                chunkType: r.chunkType,
+                start_line: r.start_line,
+                end_line: r.end_line,
+                chunk_type: r.chunk_type,
                 name: r.name,
                 language: r.language,
-                fileHash: r.fileHash,
+                file_hash: r.file_hash,
                 timestamp: r.timestamp,
                 context: r.context,
+                project_id: r.project_id,
             }));
         }
         catch (error) {
@@ -229,6 +237,56 @@ export class VectorStore {
             return [];
         }
     }
+    /**
+     * Gets all chunks, optionally filtered by project
+     */
+    async getAllChunks(projectId) {
+        await this.ensureInitialized();
+        if (!this.table) {
+            console.error("getAllChunks: No table exists");
+            return [];
+        }
+        try {
+            let query = this.table.query();
+            // Apply project filter using snake_case field name
+            if (projectId) {
+                query = query.where(`project_id = '${projectId}'`);
+                console.error(`getAllChunks: Filtering by project_id='${projectId}'`);
+            }
+            const results = await query.toArray();
+            console.error(`getAllChunks: Got ${results.length} results`);
+            // Debug: Check first result's content
+            if (results.length > 0) {
+                const first = results[0];
+                console.error(`getAllChunks: First result file_path=${first.file_path}, content length=${first.content?.length || 0}`);
+            }
+            return results.map((r) => ({
+                id: r.id,
+                vector: r.vector,
+                file_path: r.file_path,
+                content: r.content,
+                start_line: r.start_line,
+                end_line: r.end_line,
+                chunk_type: r.chunk_type,
+                name: r.name,
+                language: r.language,
+                file_hash: r.file_hash,
+                timestamp: r.timestamp,
+                context: r.context,
+                project_id: r.project_id,
+            }));
+        }
+        catch (error) {
+            console.error(`Error getting all chunks: ${error}`);
+            return [];
+        }
+    }
+    /**
+     * Gets chunks by project ID
+     */
+    async getChunksByProject(projectId) {
+        return this.getAllChunks(projectId);
+    }
     /**
      * Gets statistics about the vector store
      */
@@ -243,16 +301,15 @@ export class VectorStore {
             };
         }
         try {
-            // Use query().toArray() instead of direct toArray()
             const allChunks = await this.table.query().toArray();
             const uniqueFiles = new Set();
             const languageCounts = {};
             const typeCounts = {};
             let latestTimestamp = 0;
             for (const chunk of allChunks) {
-                uniqueFiles.add(chunk.filePath);
+                uniqueFiles.add(chunk.file_path);
                 languageCounts[chunk.language] = (languageCounts[chunk.language] || 0) + 1;
-                typeCounts[chunk.chunkType] = (typeCounts[chunk.chunkType] || 0) + 1;
+                typeCounts[chunk.chunk_type] = (typeCounts[chunk.chunk_type] || 0) + 1;
                 if (chunk.timestamp > latestTimestamp) {
                     latestTimestamp = chunk.timestamp;
                 }
@@ -307,12 +364,11 @@ export class VectorStore {
             return new Map();
         }
         try {
-            // Use query().toArray() instead of direct toArray()
             const allChunks = await this.table.query().toArray();
             const fileHashes = new Map();
             for (const chunk of allChunks) {
-                if (!fileHashes.has(chunk.filePath)) {
-                    fileHashes.set(chunk.filePath, chunk.fileHash);
+                if (!fileHashes.has(chunk.file_path)) {
+                    fileHashes.set(chunk.file_path, chunk.file_hash);
                 }
             }
             return fileHashes;

package/dist/index.js

@@ -10,6 +10,7 @@ import { z } from "zod";
 import { createEmbeddingService } from "./common/embeddingService.js";
 import { createVectorStore } from "./common/vectorStore.js";
 import { createIndexManager } from "./common/indexManager.js";
+import { createProjectKnowledgeService } from "./common/projectKnowledgeService.js";
 // Import tools
 import { indexCode } from "./tools/indexCode.js";
 import { searchMemory } from "./tools/searchMemory.js";
@@ -17,11 +18,14 @@ import { readFile } from "./tools/readFile.js";
 import { writeFile } from "./tools/writeFile.js";
 import { getStats } from "./tools/getStats.js";
 import { analyzeCoverage } from "./tools/analyzeCoverage.js";
+import { generateProjectDocs, generateProjectDocsToolDefinition } from "./tools/generateProjectDocs.js";
+import { getProjectDocs, getProjectDocsToolDefinition } from "./tools/getProjectDocs.js";
 import { VERSION } from "./common/version.js";
 // Global services
 let embeddingService;
 let vectorStore;
 let indexManager;
+let projectKnowledgeService;
 let workspaceRoot;
 // Create the MCP Server
 const server = new McpServer({
@@ -67,8 +71,8 @@ server.tool("memorybank_search", "Busca código relevante mediante búsqueda sem
     minScore: z
         .number()
         .optional()
-        .default(0.7)
-        .describe("Puntuación mínima de similitud (0-1). Valores más altos = resultados más relevantes"),
+        .default(0.4)
+        .describe("Puntuación mínima de similitud (0-1). por defecto usa 0.4 y basado en el resultado ajusta el valor"),
     filterByFile: z
         .string()
         .optional()
@@ -184,6 +188,47 @@ server.tool("memorybank_analyze_coverage", "Analiza la cobertura de indexación
         };
     }
 });
+// Tool: Generate Project Docs
+server.tool(generateProjectDocsToolDefinition.name, generateProjectDocsToolDefinition.description, {
+    projectId: z
+        .string()
+        .optional()
+        .describe("ID del proyecto (opcional, usa 'default' si no se especifica)"),
+    force: z
+        .boolean()
+        .optional()
+        .default(false)
+        .describe("Forzar regeneración de todos los documentos aunque no hayan cambiado"),
+}, async (args) => {
+    const result = await generateProjectDocs({
+        projectId: args.projectId,
+        force: args.force,
+    }, projectKnowledgeService, vectorStore);
+    return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+    };
+});
+// Tool: Get Project Docs
+server.tool(getProjectDocsToolDefinition.name, getProjectDocsToolDefinition.description, {
+    document: z
+        .string()
+        .optional()
+        .default("summary")
+        .describe("Documento específico a recuperar: projectBrief, productContext, systemPatterns, techContext, activeContext, progress, all, summary"),
+    format: z
+        .enum(["full", "summary"])
+        .optional()
+        .default("full")
+        .describe("Formato de salida: 'full' devuelve contenido completo, 'summary' devuelve resumen de todos los docs"),
+}, async (args) => {
+    const result = await getProjectDocs({
+        document: args.document,
+        format: args.format,
+    }, projectKnowledgeService);
+    return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+    };
+});
 /**
  * Validates and initializes environment
  */
@@ -208,6 +253,12 @@ async function validateEnvironment() {
     const embeddingModel = process.env.MEMORYBANK_EMBEDDING_MODEL || "text-embedding-3-small";
     const embeddingDimensions = process.env.MEMORYBANK_EMBEDDING_DIMENSIONS || "1536";
     console.error(`✓ Embedding model: ${embeddingModel} (${embeddingDimensions} dimensions)`);
+    // Project Knowledge Layer configuration
+    const reasoningModel = process.env.MEMORYBANK_REASONING_MODEL || "gpt-5-mini";
+    const reasoningEffort = process.env.MEMORYBANK_REASONING_EFFORT || "medium";
+    const autoUpdateDocs = process.env.MEMORYBANK_AUTO_UPDATE_DOCS === "true";
+    console.error(`✓ Reasoning model: ${reasoningModel} (effort: ${reasoningEffort})`);
+    console.error(`✓ Auto-update docs: ${autoUpdateDocs}`);
     // Initialize services
     console.error("\nInitializing services...");
     try {
@@ -218,6 +269,19 @@ async function validateEnvironment() {
         console.error("✓ Vector store initialized");
         indexManager = createIndexManager(embeddingService, vectorStore);
         console.error("✓ Index manager initialized");
+        // Initialize Project Knowledge Service
+        try {
+            projectKnowledgeService = createProjectKnowledgeService();
+            console.error("✓ Project Knowledge service initialized");
+            // Connect to Index Manager for auto-update hooks
+            indexManager.setProjectKnowledgeService(projectKnowledgeService);
+            indexManager.setAutoUpdateDocs(autoUpdateDocs);
+            console.error("✓ Project Knowledge service connected to Index Manager");
+        }
+        catch (error) {
+            console.error(`⚠ Warning: Project Knowledge service not available: ${error}`);
+            console.error("  Project documentation features will be disabled.");
+        }
     }
     catch (error) {
         console.error(`ERROR: Failed to initialize services: ${error}`);
@@ -241,12 +305,16 @@ async function startStdioServer() {
         await server.connect(transport);
         console.error("\n=== MCP Server Ready ===");
         console.error("Available tools:");
-        console.error("  - memorybank_index_code: Indexar código semánticamente");
-        console.error("  - memorybank_search: Buscar código por similitud semántica");
-        console.error("  - memorybank_read_file: Leer archivos del workspace");
-        console.error("  - memorybank_write_file: Escribir archivos y reindexar");
-        console.error("  - memorybank_get_stats: Obtener estadísticas del índice");
-        console.error("  - memorybank_analyze_coverage: Analizar cobertura de indexación");
+        console.error("  Core Memory Bank:");
+        console.error("    - memorybank_index_code: Indexar código semánticamente");
+        console.error("    - memorybank_search: Buscar código por similitud semántica");
+        console.error("    - memorybank_read_file: Leer archivos del workspace");
+        console.error("    - memorybank_write_file: Escribir archivos y reindexar");
+        console.error("    - memorybank_get_stats: Obtener estadísticas del índice");
+        console.error("    - memorybank_analyze_coverage: Analizar cobertura de indexación");
+        console.error("  Project Knowledge Layer:");
+        console.error("    - memorybank_generate_project_docs: Generar documentación con IA");
+        console.error("    - memorybank_get_project_docs: Leer documentación del proyecto");
         console.error("");
         console.error("Ready to accept requests...\n");
     }

package/dist/tools/analyzeCoverage.js

@@ -256,7 +256,7 @@ export async function analyzeCoverage(indexManager, vectorStore, workspaceRoot)
             if (indexed) {
                 // Check if file hash matches
                 const chunks = await vectorStore.getChunksByFile(file.path);
-                if (chunks.length > 0 && chunks[0].fileHash !== file.hash) {
+                if (chunks.length > 0 && chunks[0].file_hash !== file.hash) {
                     pendingFiles.add(file.path);
                 }
             }

package/dist/tools/generateProjectDocs.js

@@ -0,0 +1,133 @@
+/**
+ * @fileoverview Tool for generating project documentation
+ * Uses the Project Knowledge Service to create structured markdown docs
+ */
+/**
+ * Generates project documentation using AI reasoning
+ */
+export async function generateProjectDocs(params, projectKnowledgeService, vectorStore) {
+    try {
+        console.error("\n=== Generating Project Documentation ===");
+        console.error(`Project ID: ${params.projectId || "default"}`);
+        console.error(`Force regeneration: ${params.force || false}`);
+        // Get all chunks from the vector store
+        const chunks = await vectorStore.getAllChunks(params.projectId);
+        if (chunks.length === 0) {
+            return {
+                success: false,
+                message: "No indexed code found. Please run memorybank_index_code first to index your project.",
+                result: {
+                    success: false,
+                    documentsGenerated: [],
+                    documentsUpdated: [],
+                    documentsSkipped: [],
+                    totalReasoningTokens: 0,
+                    totalOutputTokens: 0,
+                    errors: ["No chunks available for documentation generation"],
+                },
+                tokenUsage: {
+                    reasoningTokens: 0,
+                    outputTokens: 0,
+                    estimatedCost: "$0.00",
+                },
+            };
+        }
+        console.error(`Found ${chunks.length} code chunks to analyze`);
+        // Generate documents
+        const result = await projectKnowledgeService.generateAllDocuments(chunks, params.force || false);
+        // Calculate estimated cost (approximate rates for gpt-5-mini)
+        // Reasoning tokens are typically more expensive
+        const reasoningCostPer1K = 0.003; // $0.003 per 1K reasoning tokens
+        const outputCostPer1K = 0.012; // $0.012 per 1K output tokens
+        const reasoningCost = (result.totalReasoningTokens / 1000) * reasoningCostPer1K;
+        const outputCost = (result.totalOutputTokens / 1000) * outputCostPer1K;
+        const totalCost = reasoningCost + outputCost;
+        // Build response message
+        let message = "";
+        if (result.documentsGenerated.length > 0) {
+            message += `Generated ${result.documentsGenerated.length} new document(s): ${result.documentsGenerated.join(", ")}. `;
+        }
+        if (result.documentsUpdated.length > 0) {
+            message += `Updated ${result.documentsUpdated.length} document(s): ${result.documentsUpdated.join(", ")}. `;
+        }
+        if (result.documentsSkipped.length > 0) {
+            message += `Skipped ${result.documentsSkipped.length} unchanged document(s). `;
+        }
+        if (result.errors.length > 0) {
+            message += `Errors: ${result.errors.join("; ")}`;
+        }
+        if (!message) {
+            message = "All documents are up to date.";
+        }
+        console.error(`\nGeneration complete:`);
+        console.error(`  - Generated: ${result.documentsGenerated.length}`);
+        console.error(`  - Updated: ${result.documentsUpdated.length}`);
+        console.error(`  - Skipped: ${result.documentsSkipped.length}`);
+        console.error(`  - Reasoning tokens: ${result.totalReasoningTokens}`);
+        console.error(`  - Output tokens: ${result.totalOutputTokens}`);
+        console.error(`  - Estimated cost: $${totalCost.toFixed(4)}`);
+        return {
+            success: result.success,
+            message,
+            result,
+            tokenUsage: {
+                reasoningTokens: result.totalReasoningTokens,
+                outputTokens: result.totalOutputTokens,
+                estimatedCost: `$${totalCost.toFixed(4)}`,
+            },
+        };
+    }
+    catch (error) {
+        console.error(`Error generating project docs: ${error.message}`);
+        return {
+            success: false,
+            message: `Failed to generate project documentation: ${error.message}`,
+            result: {
+                success: false,
+                documentsGenerated: [],
+                documentsUpdated: [],
+                documentsSkipped: [],
+                totalReasoningTokens: 0,
+                totalOutputTokens: 0,
+                errors: [error.message],
+            },
+            tokenUsage: {
+                reasoningTokens: 0,
+                outputTokens: 0,
+                estimatedCost: "$0.00",
+            },
+        };
+    }
+}
+/**
+ * Tool definition for MCP
+ */
+export const generateProjectDocsToolDefinition = {
+    name: "memorybank_generate_project_docs",
+    description: `Genera documentación estructurada del proyecto usando IA con razonamiento avanzado (gpt-5-mini).
+  
+Crea 6 documentos markdown que proporcionan una visión global del proyecto:
+- projectBrief.md: Descripción general del proyecto
+- productContext.md: Perspectiva de negocio y usuarios
+- systemPatterns.md: Patrones de arquitectura y diseño
+- techContext.md: Stack tecnológico y dependencias
+- activeContext.md: Estado actual de desarrollo
+- progress.md: Seguimiento de cambios
+
+Esta herramienta complementa la búsqueda semántica precisa con conocimiento global del proyecto.
+Útil para que agentes menos avanzados comprendan mejor el contexto completo.`,
+    inputSchema: {
+        type: "object",
+        properties: {
+            projectId: {
+                type: "string",
+                description: "ID del proyecto (opcional, usa 'default' si no se especifica)",
+            },
+            force: {
+                type: "boolean",
+                description: "Forzar regeneración de todos los documentos aunque no hayan cambiado",
+                default: false,
+            },
+        },
+    },
+};

package/dist/tools/getProjectDocs.js

@@ -0,0 +1,126 @@
+/**
+ * @fileoverview Tool for reading project documentation
+ * Retrieves generated markdown documents for project context
+ */
+const VALID_DOC_TYPES = [
+    "projectBrief",
+    "productContext",
+    "systemPatterns",
+    "techContext",
+    "activeContext",
+    "progress",
+];
+/**
+ * Retrieves project documentation
+ */
+export async function getProjectDocs(params, projectKnowledgeService) {
+    try {
+        const format = params.format || "full";
+        const requestedDoc = params.document?.toLowerCase();
+        // Check if any documents exist
+        if (!projectKnowledgeService.hasDocuments()) {
+            return {
+                success: false,
+                message: "No project documentation has been generated yet. Run memorybank_generate_project_docs first.",
+                stats: {
+                    documentCount: 0,
+                    totalReasoningTokens: 0,
+                    totalOutputTokens: 0,
+                },
+            };
+        }
+        // Get stats
+        const stats = projectKnowledgeService.getStats();
+        const statsResult = {
+            documentCount: stats.documentCount,
+            totalReasoningTokens: stats.totalReasoningTokens,
+            totalOutputTokens: stats.totalOutputTokens,
+            lastGenerated: stats.lastGenerated?.toISOString(),
+        };
+        // Handle summary request
+        if (requestedDoc === "summary" || format === "summary") {
+            const summary = projectKnowledgeService.getDocumentsSummary();
+            return {
+                success: true,
+                message: `Retrieved summary of ${stats.documentCount} project documents.`,
+                summary,
+                stats: statsResult,
+            };
+        }
+        // Handle "all" or no specific document
+        if (!requestedDoc || requestedDoc === "all") {
+            const documents = projectKnowledgeService.getAllDocuments();
+            return {
+                success: true,
+                message: `Retrieved ${documents.length} project documents.`,
+                documents,
+                stats: statsResult,
+            };
+        }
+        // Handle specific document request
+        // Normalize document name (allow both "projectBrief" and "projectbrief")
+        const normalizedDoc = VALID_DOC_TYPES.find(t => t.toLowerCase() === requestedDoc.replace(".md", "").replace("_", ""));
+        if (!normalizedDoc) {
+            return {
+                success: false,
+                message: `Invalid document type: "${params.document}". Valid types are: ${VALID_DOC_TYPES.join(", ")}`,
+                stats: statsResult,
+            };
+        }
+        const document = projectKnowledgeService.getDocument(normalizedDoc);
+        if (!document) {
+            return {
+                success: false,
+                message: `Document "${normalizedDoc}" has not been generated yet.`,
+                stats: statsResult,
+            };
+        }
+        return {
+            success: true,
+            message: `Retrieved document: ${normalizedDoc}`,
+            documents: [document],
+            stats: statsResult,
+        };
+    }
+    catch (error) {
+        console.error(`Error getting project docs: ${error.message}`);
+        return {
+            success: false,
+            message: `Failed to retrieve project documentation: ${error.message}`,
+        };
+    }
+}
+/**
+ * Tool definition for MCP
+ */
+export const getProjectDocsToolDefinition = {
+    name: "memorybank_get_project_docs",
+    description: `Lee la documentación del proyecto generada por IA.
+
+Recupera documentos markdown estructurados que proporcionan contexto global del proyecto:
+- projectBrief: Descripción general del proyecto
+- productContext: Perspectiva de negocio y usuarios
+- systemPatterns: Patrones de arquitectura y diseño
+- techContext: Stack tecnológico y dependencias
+- activeContext: Estado actual de desarrollo
+- progress: Seguimiento de cambios
+
+Usa esta herramienta al inicio de cada sesión para cargar contexto global.
+Complementa la búsqueda semántica precisa (memorybank_search) con visión de alto nivel.`,
+    inputSchema: {
+        type: "object",
+        properties: {
+            document: {
+                type: "string",
+                description: "Documento específico a recuperar. Opciones: projectBrief, productContext, systemPatterns, techContext, activeContext, progress, all, summary",
+                default: "summary",
+            },
+            format: {
+                type: "string",
+                enum: ["full", "summary"],
+                description: "Formato de salida: 'full' devuelve contenido completo, 'summary' devuelve resumen de todos los docs",
+                default: "full",
+            },
+        },
+    },
+};

package/dist/tools/index.js

@@ -10,3 +10,6 @@ export * from "./readFile.js";
 export * from "./writeFile.js";
 export * from "./getStats.js";
 export * from "./analyzeCoverage.js";
+// Export Project Knowledge Layer tools
+export * from "./generateProjectDocs.js";
+export * from "./getProjectDocs.js";

package/dist/tools/searchMemory.js

@@ -18,7 +18,7 @@ export async function searchMemory(params, indexManager) {
         }
         console.error(`\nSearching Memory Bank for: "${params.query}"`);
         console.error(`Top K: ${params.topK || 10}`);
-        console.error(`Min score: ${params.minScore || 0.7}`);
+        console.error(`Min score: ${params.minScore || 0.4}`);
         if (params.filterByFile) {
             console.error(`Filter by file: ${params.filterByFile}`);
         }
@@ -28,7 +28,7 @@ export async function searchMemory(params, indexManager) {
         // Search
         const results = await indexManager.search(params.query, {
             topK: params.topK || 10,
-            minScore: params.minScore !== undefined ? params.minScore : 0.7,
+            minScore: params.minScore !== undefined ? params.minScore : 0.4,
             filterByFile: params.filterByFile,
             filterByLanguage: params.filterByLanguage,
         });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@grec0/memory-bank-mcp",
-  "version": "0.0.2",
+  "version": "0.0.4",
   "description": "MCP server for semantic code indexing with Memory Bank - AI-powered codebase understanding",
   "license": "MIT",
   "author": "@grec0",
@@ -40,6 +40,7 @@
     "@lancedb/lancedb": "^0.9.0",
     "@modelcontextprotocol/sdk": "1.6.1",
     "@types/node": "^22",
+    "gpt-tokenizer": "3.4.0",
     "ignore": "^5.3.0",
     "openai": "^4.0.0",
     "zod": "^3.22.4",