@grec0/memory-bank-mcp 0.0.2 → 0.0.4

package/dist/common/indexManager.js

@@ -14,11 +14,29 @@ export class IndexManager {
     vectorStore;
     metadataPath;
     metadata;
+    projectKnowledgeService = null;
+    autoUpdateDocs = false;
     constructor(embeddingService, vectorStore, storagePath = ".memorybank") {
         this.embeddingService = embeddingService;
         this.vectorStore = vectorStore;
         this.metadataPath = path.join(storagePath, "index-metadata.json");
         this.metadata = this.loadMetadata();
+        // Check if auto-update docs is enabled via environment variable
+        this.autoUpdateDocs = process.env.MEMORYBANK_AUTO_UPDATE_DOCS === "true";
+    }
+    /**
+     * Sets the Project Knowledge Service for auto-generating docs
+     */
+    setProjectKnowledgeService(service) {
+        this.projectKnowledgeService = service;
+        console.error("Project Knowledge Service attached to Index Manager");
+    }
+    /**
+     * Enables or disables auto-update of project docs after indexing
+     */
+    setAutoUpdateDocs(enabled) {
+        this.autoUpdateDocs = enabled;
+        console.error(`Auto-update project docs: ${enabled ? "enabled" : "disabled"}`);
     }
     /**
      * Loads index metadata from disk
@@ -73,7 +91,7 @@ export class IndexManager {
     /**
      * Indexes a single file
      */
-    async indexFile(file, forceReindex = false) {
+    async indexFile(file, forceReindex = false, projectId = "default") {
         try {
             // Check if file needs reindexing
             if (!this.needsReindexing(file, forceReindex)) {
@@ -83,16 +101,17 @@ export class IndexManager {
             console.error(`Indexing: ${file.path}`);
             // Read file content
             const content = fs.readFileSync(file.absolutePath, "utf-8");
-            // Get chunk size from environment or use defaults
-            const maxChunkSize = parseInt(process.env.MEMORYBANK_CHUNK_SIZE || "1000");
-            const chunkOverlap = parseInt(process.env.MEMORYBANK_CHUNK_OVERLAP || "200");
-            // Chunk the code
+            // Get token limits from environment or use defaults
+            // text-embedding-3-small has 8192 token limit, default to 7500 for safety
+            const maxTokens = parseInt(process.env.MEMORYBANK_MAX_TOKENS || "7500");
+            const chunkOverlapTokens = parseInt(process.env.MEMORYBANK_CHUNK_OVERLAP_TOKENS || "200");
+            // Chunk the code using token-based chunking
             const chunks = chunkCode({
                 filePath: file.path,
                 content,
                 language: file.language,
-                maxChunkSize,
-                chunkOverlap,
+                maxTokens,
+                chunkOverlapTokens,
             });
             if (chunks.length === 0) {
                 console.error(`Warning: No chunks created for ${file.path}`);
@@ -106,21 +125,24 @@ export class IndexManager {
             }));
             const embeddings = await this.embeddingService.generateBatchEmbeddings(embeddingInputs);
             console.error(`  Generated ${embeddings.length} embeddings`);
-            // Prepare chunk records for storage
+            // Prepare chunk records for storage (using snake_case for LanceDB)
+            // Note: All fields must have non-undefined values for LanceDB Arrow conversion
             const timestamp = Date.now();
+            console.error(`  Storing chunks with project_id: '${projectId}'`);
             const chunkRecords = chunks.map((chunk, i) => ({
                 id: chunk.id,
                 vector: embeddings[i].vector,
-                filePath: chunk.filePath,
+                file_path: chunk.filePath,
                 content: chunk.content,
-                startLine: chunk.startLine,
-                endLine: chunk.endLine,
-                chunkType: chunk.chunkType,
-                name: chunk.name,
+                start_line: chunk.startLine,
+                end_line: chunk.endLine,
+                chunk_type: chunk.chunkType,
+                name: chunk.name || "", // Ensure non-undefined for LanceDB
                 language: chunk.language,
-                fileHash: file.hash,
+                file_hash: file.hash,
                 timestamp,
-                context: chunk.context,
+                context: chunk.context || "", // Ensure non-undefined for LanceDB
+                project_id: projectId,
             }));
             // Delete old chunks for this file
             await this.vectorStore.deleteChunksByFile(file.path);
@@ -143,14 +165,37 @@ export class IndexManager {
             return { chunksCreated: 0, error: errorMsg };
         }
     }
+    /**
+     * Derives a project ID from the root path if not provided
+     */
+    deriveProjectId(rootPath, providedId) {
+        if (providedId) {
+            return providedId;
+        }
+        // Use the directory name as project ID
+        const dirName = path.basename(path.resolve(rootPath));
+        // Sanitize: remove special chars, lowercase, replace spaces with dashes
+        const sanitized = dirName
+            .toLowerCase()
+            .replace(/[^a-z0-9-_]/g, "-")
+            .replace(/-+/g, "-")
+            .replace(/^-|-$/g, "");
+        return sanitized || "default";
+    }
     /**
      * Indexes multiple files or a directory
      */
     async indexFiles(options) {
         const startTime = Date.now();
+        const projectId = this.deriveProjectId(options.rootPath, options.projectId);
+        const shouldAutoUpdateDocs = options.autoUpdateDocs !== undefined
+            ? options.autoUpdateDocs
+            : this.autoUpdateDocs;
         console.error(`\n=== Starting indexing process ===`);
         console.error(`Root path: ${options.rootPath}`);
+        console.error(`Project ID: ${projectId}`);
         console.error(`Force reindex: ${options.forceReindex || false}`);
+        console.error(`Auto-update docs: ${shouldAutoUpdateDocs}`);
         // Initialize vector store
         await this.vectorStore.initialize();
         // Scan files
@@ -163,6 +208,7 @@ export class IndexManager {
             console.error("No files found to index");
             return {
                 filesProcessed: 0,
+                changedFiles: [],
                 chunksCreated: 0,
                 errors: [],
                 duration: Date.now() - startTime,
@@ -175,6 +221,7 @@ export class IndexManager {
             console.error("All files are up to date");
             return {
                 filesProcessed: 0,
+                changedFiles: [],
                 chunksCreated: 0,
                 errors: [],
                 duration: Date.now() - startTime,
@@ -182,37 +229,60 @@ export class IndexManager {
         }
         // Index files
         const errors = [];
+        const changedFiles = [];
         let totalChunks = 0;
         let processedFiles = 0;
         for (let i = 0; i < filesToIndex.length; i++) {
             const file = filesToIndex[i];
             console.error(`\n[${i + 1}/${filesToIndex.length}] Processing ${file.path}`);
-            const result = await this.indexFile(file, options.forceReindex || false);
+            const result = await this.indexFile(file, options.forceReindex || false, projectId);
             if (result.error) {
                 errors.push(result.error);
             }
             else {
                 processedFiles++;
                 totalChunks += result.chunksCreated;
+                changedFiles.push(file.path);
             }
         }
-        const duration = Date.now() - startTime;
+        const indexDuration = Date.now() - startTime;
         console.error(`\n=== Indexing complete ===`);
         console.error(`Files processed: ${processedFiles}`);
         console.error(`Chunks created: ${totalChunks}`);
         console.error(`Errors: ${errors.length}`);
-        console.error(`Duration: ${(duration / 1000).toFixed(2)}s`);
+        console.error(`Duration: ${(indexDuration / 1000).toFixed(2)}s`);
+        // Run post-indexing hook to update project documentation
+        let docsGeneration;
+        if (shouldAutoUpdateDocs && this.projectKnowledgeService && changedFiles.length > 0) {
+            console.error(`\n=== Updating project documentation ===`);
+            try {
+                // Get all chunks for the project
+                const allChunks = await this.vectorStore.getAllChunks(projectId);
+                // Update docs incrementally based on changed files
+                docsGeneration = await this.projectKnowledgeService.updateDocuments(allChunks, changedFiles);
+                console.error(`Docs updated: ${docsGeneration.documentsUpdated.length}`);
+                console.error(`Docs generated: ${docsGeneration.documentsGenerated.length}`);
+                console.error(`Reasoning tokens: ${docsGeneration.totalReasoningTokens}`);
+            }
+            catch (error) {
+                console.error(`Warning: Failed to update project docs: ${error.message}`);
+                errors.push(`Project docs update failed: ${error.message}`);
+            }
+        }
+        const totalDuration = Date.now() - startTime;
         return {
             filesProcessed: processedFiles,
+            changedFiles,
             chunksCreated: totalChunks,
             errors,
-            duration,
+            duration: totalDuration,
+            docsGeneration,
         };
     }
     /**
      * Re-indexes a specific file by path
      */
-    async reindexFile(filePath, rootPath) {
+    async reindexFile(filePath, rootPath, projectId) {
         try {
             // Scan the specific file
             const file = scanSingleFile(filePath, rootPath);
@@ -223,10 +293,12 @@ export class IndexManager {
                     error: "File not found or not a code file",
                 };
             }
+            // Derive project ID from root path if not provided
+            const resolvedProjectId = this.deriveProjectId(rootPath, projectId);
             // Initialize vector store
             await this.vectorStore.initialize();
             // Index the file
-            const result = await this.indexFile(file, true);
+            const result = await this.indexFile(file, true, resolvedProjectId);
             if (result.error) {
                 return {
                     success: false,
@@ -286,11 +358,11 @@ export class IndexManager {
         });
         // Format results
         return results.map((result) => ({
-            filePath: result.chunk.filePath,
+            filePath: result.chunk.file_path,
             content: result.chunk.content,
-            startLine: result.chunk.startLine,
-            endLine: result.chunk.endLine,
-            chunkType: result.chunk.chunkType,
+            startLine: result.chunk.start_line,
+            endLine: result.chunk.end_line,
+            chunkType: result.chunk.chunk_type,
             name: result.chunk.name,
             language: result.chunk.language,
             score: result.score,

package/dist/common/logger.js

@@ -0,0 +1,54 @@
+/**
+ * @fileoverview Structured logger for Memory Bank MCP
+ * Ensures all logs are written to stderr to avoid breaking JSON-RPC on stdout
+ */
+export var LogLevel;
+(function (LogLevel) {
+    LogLevel[LogLevel["DEBUG"] = 0] = "DEBUG";
+    LogLevel[LogLevel["INFO"] = 1] = "INFO";
+    LogLevel[LogLevel["WARN"] = 2] = "WARN";
+    LogLevel[LogLevel["ERROR"] = 3] = "ERROR";
+})(LogLevel || (LogLevel = {}));
+export class Logger {
+    static instance;
+    level = LogLevel.INFO;
+    constructor() { }
+    static getInstance() {
+        if (!Logger.instance) {
+            Logger.instance = new Logger();
+        }
+        return Logger.instance;
+    }
+    setLevel(level) {
+        this.level = level;
+    }
+    formatMessage(level, message) {
+        const timestamp = new Date().toISOString();
+        return `[${timestamp}] [${level}] ${message}`;
+    }
+    debug(message) {
+        if (this.level <= LogLevel.DEBUG) {
+            console.error(this.formatMessage("DEBUG", message));
+        }
+    }
+    info(message) {
+        if (this.level <= LogLevel.INFO) {
+            console.error(this.formatMessage("INFO", message));
+        }
+    }
+    warn(message) {
+        if (this.level <= LogLevel.WARN) {
+            console.error(this.formatMessage("WARN", message));
+        }
+    }
+    error(message, error) {
+        if (this.level <= LogLevel.ERROR) {
+            const errorMsg = error ? ` ${error instanceof Error ? error.message : String(error)}` : "";
+            console.error(this.formatMessage("ERROR", message + errorMsg));
+            if (error instanceof Error && error.stack) {
+                console.error(error.stack);
+            }
+        }
+    }
+}
+export const logger = Logger.getInstance();