@grec0/memory-bank-mcp 0.0.2 → 0.0.3

package/dist/common/embeddingService.js

@@ -2,6 +2,7 @@
  * @fileoverview Embedding service for Memory Bank using OpenAI
  * Generates vector embeddings for code chunks
  */
+import { logger } from "./logger.js";
 import OpenAI from "openai";
 import * as crypto from "crypto";
 import * as fs from "fs";
@@ -49,7 +50,7 @@ export class EmbeddingService {
         }
     }
     /**
-     * Saves embedding cache to disk
+     * Saves embedding cache to disk using streams to handle large files
      */
     saveCache() {
         try {
@@ -58,8 +59,16 @@ export class EmbeddingService {
                 fs.mkdirSync(dir, { recursive: true });
             }
             const entries = Array.from(this.cache.values());
-            fs.writeFileSync(this.options.cachePath, JSON.stringify(entries, null, 2));
-            console.error(`Saved ${entries.length} embeddings to cache`);
+            const stream = fs.createWriteStream(this.options.cachePath, { encoding: 'utf8' });
+            stream.write('[\n');
+            entries.forEach((entry, index) => {
+                const isLast = index === entries.length - 1;
+                const line = JSON.stringify(entry) + (isLast ? '' : ',\n');
+                stream.write(line);
+            });
+            stream.write('\n]');
+            stream.end();
+            console.error(`Updated embedding cache (Total: ${entries.length} entries)`);
         }
         catch (error) {
             console.error(`Warning: Could not save embedding cache: ${error}`);
@@ -136,14 +145,14 @@ export class EmbeddingService {
                 // Check if it's a rate limit error
                 if (error?.status === 429 || error?.code === "rate_limit_exceeded") {
                     const backoffMs = Math.pow(2, attempt) * 1000; // Exponential backoff
-                    console.error(`Rate limit hit, retrying in ${backoffMs}ms (attempt ${attempt + 1}/${maxRetries})`);
+                    logger.warn(`Rate limit hit, retrying in ${backoffMs}ms (attempt ${attempt + 1}/${maxRetries})`);
                     await this.sleep(backoffMs);
                     continue;
                 }
                 // Check if it's a temporary error
                 if (error?.status >= 500 && error?.status < 600) {
                     const backoffMs = Math.pow(2, attempt) * 1000;
-                    console.error(`Server error ${error.status}, retrying in ${backoffMs}ms (attempt ${attempt + 1}/${maxRetries})`);
+                    logger.warn(`Server error ${error.status}, retrying in ${backoffMs}ms (attempt ${attempt + 1}/${maxRetries})`);
                     await this.sleep(backoffMs);
                     continue;
                 }
@@ -185,9 +194,10 @@ export class EmbeddingService {
     /**
      * Generates embeddings for multiple chunks in batches
      */
-    async generateBatchEmbeddings(chunks) {
+    async generateBatchEmbeddings(chunks, options = {}) {
         const results = [];
         const toGenerate = [];
+        const shouldSave = options.autoSave !== undefined ? options.autoSave : true;
         // Check cache and collect chunks that need generation
         for (let i = 0; i < chunks.length; i++) {
             const chunk = chunks[i];
@@ -204,41 +214,43 @@ export class EmbeddingService {
                 toGenerate.push({ ...chunk, index: i });
             }
         }
-        console.error(`Generating embeddings: ${toGenerate.length} new, ${chunks.length - toGenerate.length} cached`);
-        // Process in batches
-        for (let i = 0; i < toGenerate.length; i += this.options.batchSize) {
-            const batch = toGenerate.slice(i, i + this.options.batchSize);
-            const batchTexts = batch.map((item) => item.content);
-            console.error(`Processing batch ${Math.floor(i / this.options.batchSize) + 1}/${Math.ceil(toGenerate.length / this.options.batchSize)}`);
-            try {
-                const vectors = await this.generateBatchWithRetry(batchTexts);
-                // Store results and cache
-                for (let j = 0; j < batch.length; j++) {
-                    const item = batch[j];
-                    const vector = vectors[j];
-                    // Cache the result
-                    this.cacheEmbedding(item.id, item.content, vector);
-                    // Estimate tokens
-                    const tokens = Math.ceil(item.content.length / 4);
-                    results[item.index] = {
-                        chunkId: item.id,
-                        vector,
-                        model: this.options.model,
-                        tokens,
-                    };
+        if (toGenerate.length > 0) {
+            logger.info(`Generating embeddings: ${toGenerate.length} new, ${chunks.length - toGenerate.length} cached`);
+            // Process in batches
+            for (let i = 0; i < toGenerate.length; i += this.options.batchSize) {
+                const batch = toGenerate.slice(i, i + this.options.batchSize);
+                const batchTexts = batch.map((item) => item.content);
+                logger.info(`Processing batch ${Math.floor(i / this.options.batchSize) + 1}/${Math.ceil(toGenerate.length / this.options.batchSize)}`);
+                try {
+                    const vectors = await this.generateBatchWithRetry(batchTexts);
+                    // Store results and cache
+                    for (let j = 0; j < batch.length; j++) {
+                        const item = batch[j];
+                        const vector = vectors[j];
+                        // Cache the result
+                        this.cacheEmbedding(item.id, item.content, vector);
+                        // Estimate tokens
+                        const tokens = Math.ceil(item.content.length / 4);
+                        results[item.index] = {
+                            chunkId: item.id,
+                            vector,
+                            model: this.options.model,
+                            tokens,
+                        };
+                    }
+                }
+                catch (error) {
+                    logger.error(`Error generating batch embeddings:`, error);
+                    throw error;
+                }
+                // Small delay between batches to avoid rate limits
+                if (i + this.options.batchSize < toGenerate.length) {
+                    await this.sleep(100);
                 }
-            }
-            catch (error) {
-                console.error(`Error generating batch embeddings: ${error}`);
-                throw error;
-            }
-            // Small delay between batches to avoid rate limits
-            if (i + this.options.batchSize < toGenerate.length) {
-                await this.sleep(100);
             }
         }
         // Save cache after batch processing
-        if (this.options.enableCache && toGenerate.length > 0) {
+        if (shouldSave && this.options.enableCache && toGenerate.length > 0) {
             this.saveCache();
         }
         return results;
@@ -256,7 +268,7 @@ export class EmbeddingService {
             return response.data[0].embedding;
         }
         catch (error) {
-            console.error(`Error generating query embedding: ${error}`);
+            logger.error(`Error generating query embedding:`, error);
             throw error;
         }
     }
@@ -268,7 +280,7 @@ export class EmbeddingService {
         if (fs.existsSync(this.options.cachePath)) {
             fs.unlinkSync(this.options.cachePath);
         }
-        console.error("Embedding cache cleared");
+        logger.info("Embedding cache cleared");
     }
     /**
      * Gets cache statistics

package/dist/common/fileScanner.js

@@ -6,6 +6,7 @@ import * as fs from "fs";
 import * as path from "path";
 import * as crypto from "crypto";
 import ignoreLib from "ignore";
+import { logger } from "./logger.js";
 // Handle ignore library export
 const ignore = typeof ignoreLib === 'function' ? ignoreLib : ignoreLib.default;
 // Language detection by file extension
@@ -76,10 +77,10 @@ export function loadIgnorePatterns(rootPath) {
         try {
             const gitignoreContent = fs.readFileSync(gitignorePath, "utf-8");
             ig.add(gitignoreContent);
-            console.error(`Loaded .gitignore patterns from ${gitignorePath}`);
+            logger.debug(`Loaded .gitignore patterns from ${gitignorePath}`);
         }
         catch (error) {
-            console.error(`Warning: Could not read .gitignore: ${error}`);
+            logger.warn(`Could not read .gitignore: ${error}`);
         }
     }
     // Load .memoryignore if exists
@@ -88,19 +89,19 @@ export function loadIgnorePatterns(rootPath) {
         try {
             const memoryignoreContent = fs.readFileSync(memoryignorePath, "utf-8");
             ig.add(memoryignoreContent);
-            console.error(`Loaded .memoryignore patterns from ${memoryignorePath}`);
+            logger.debug(`Loaded .memoryignore patterns from ${memoryignorePath}`);
         }
         catch (error) {
-            console.error(`Warning: Could not read .memoryignore: ${error}`);
+            logger.warn(`Could not read .memoryignore: ${error}`);
         }
     }
     return ig;
 }
 /**
- * Calculates SHA-256 hash of file content
+ * Calculates SHA-256 hash of file content asynchronously
  */
-export function calculateFileHash(filePath) {
-    const content = fs.readFileSync(filePath);
+export async function calculateFileHash(filePath) {
+    const content = await fs.promises.readFile(filePath);
     return crypto.createHash("sha256").update(content).digest("hex");
 }
 /**
@@ -138,17 +139,20 @@ export function isCodeFile(filePath) {
     return codeFileNames.has(basename);
 }
 /**
- * Recursively scans directory for code files
+ * Recursively scans directory for code files asynchronously
  */
-function scanDirectoryRecursive(dirPath, rootPath, ig, options, results) {
+async function scanDirectoryRecursive(dirPath, rootPath, ig, options, results, concurrencyLimit = 20) {
     let entries;
     try {
-        entries = fs.readdirSync(dirPath, { withFileTypes: true });
+        entries = await fs.promises.readdir(dirPath, { withFileTypes: true });
     }
     catch (error) {
-        console.error(`Warning: Could not read directory ${dirPath}: ${error}`);
+        logger.warn(`Could not read directory ${dirPath}: ${error}`);
         return;
     }
+    // Process subdirectories sequentially to avoid recursion explosion
+    // but process files in current directory in parallel
+    const filesToProcess = [];
     for (const entry of entries) {
         const fullPath = path.join(dirPath, entry.name);
         const relativePath = path.relative(rootPath, fullPath);
@@ -163,23 +167,35 @@ function scanDirectoryRecursive(dirPath, rootPath, ig, options, results) {
         }
         if (entry.isDirectory()) {
             if (options.recursive) {
-                scanDirectoryRecursive(fullPath, rootPath, ig, options, results);
+                await scanDirectoryRecursive(fullPath, rootPath, ig, options, results, concurrencyLimit);
             }
         }
         else if (entry.isFile()) {
+            filesToProcess.push(entry);
+        }
+    }
+    // Process files in batches
+    for (let i = 0; i < filesToProcess.length; i += concurrencyLimit) {
+        const batch = filesToProcess.slice(i, i + concurrencyLimit);
+        await Promise.all(batch.map(async (entry) => {
+            const fullPath = path.join(dirPath, entry.name);
+            // Calculate relative path from PROJECT root (not just scan root)
+            // And strictly normalize to forward slashes for consistency
+            const relativePathRaw = path.relative(options.projectRoot, fullPath);
+            const relativePath = relativePathRaw.split(path.sep).join("/");
             try {
                 // Check if it's a code file
                 if (!isCodeFile(fullPath)) {
-                    continue;
+                    return;
                 }
-                const stats = fs.statSync(fullPath);
+                const stats = await fs.promises.stat(fullPath);
                 // Check file size limit
                 if (stats.size > options.maxFileSize) {
-                    console.error(`Skipping large file (${stats.size} bytes): ${relativePath}`);
-                    continue;
+                    logger.warn(`Skipping large file (${stats.size} bytes): ${relativePath}`);
+                    return;
                 }
                 // Calculate hash and collect metadata
-                const hash = calculateFileHash(fullPath);
+                const hash = await calculateFileHash(fullPath);
                 const language = detectLanguage(fullPath);
                 const extension = path.extname(fullPath);
                 results.push({
@@ -193,17 +209,18 @@ function scanDirectoryRecursive(dirPath, rootPath, ig, options, results) {
                 });
             }
             catch (error) {
-                console.error(`Warning: Could not process file ${fullPath}: ${error}`);
+                logger.warn(`Could not process file ${fullPath}: ${error}`);
             }
-        }
+        }));
     }
 }
 /**
- * Scans workspace for code files
+ * Scans workspace for code files asynchronously
  */
-export function scanFiles(options) {
+export async function scanFiles(options) {
     const fullOptions = {
         rootPath: options.rootPath,
+        projectRoot: options.projectRoot || options.rootPath,
         recursive: options.recursive !== undefined ? options.recursive : true,
         includeHidden: options.includeHidden !== undefined ? options.includeHidden : false,
         maxFileSize: options.maxFileSize || 10 * 1024 * 1024, // 10MB default
@@ -212,23 +229,23 @@ export function scanFiles(options) {
     if (!fs.existsSync(fullOptions.rootPath)) {
         throw new Error(`Root path does not exist: ${fullOptions.rootPath}`);
     }
-    const stats = fs.statSync(fullOptions.rootPath);
+    const stats = await fs.promises.stat(fullOptions.rootPath);
     if (!stats.isDirectory()) {
         throw new Error(`Root path is not a directory: ${fullOptions.rootPath}`);
     }
-    console.error(`Scanning files in: ${fullOptions.rootPath}`);
+    logger.info(`Scanning files in: ${fullOptions.rootPath}`);
     // Load ignore patterns
     const ig = loadIgnorePatterns(fullOptions.rootPath);
     // Scan files
     const results = [];
-    scanDirectoryRecursive(fullOptions.rootPath, fullOptions.rootPath, ig, fullOptions, results);
-    console.error(`Found ${results.length} code files to index`);
+    await scanDirectoryRecursive(fullOptions.rootPath, fullOptions.rootPath, ig, fullOptions, results);
+    logger.info(`Found ${results.length} code files to index`);
     return results;
 }
 /**
  * Scans a single file and returns its metadata
  */
-export function scanSingleFile(filePath, rootPath) {
+export async function scanSingleFile(filePath, rootPath, projectRoot) {
     try {
         if (!fs.existsSync(filePath)) {
             throw new Error(`File does not exist: ${filePath}`);
@@ -240,10 +257,12 @@ export function scanSingleFile(filePath, rootPath) {
         if (!isCodeFile(filePath)) {
             return null;
         }
-        const hash = calculateFileHash(filePath);
+        const hash = await calculateFileHash(filePath);
         const language = detectLanguage(filePath);
         const extension = path.extname(filePath);
-        const relativePath = path.relative(rootPath, filePath);
+        // Calculate relative path from PROJECT root
+        const relativePathRaw = path.relative(projectRoot || rootPath, filePath);
+        const relativePath = relativePathRaw.split(path.sep).join("/");
         return {
             path: relativePath,
             absolutePath: filePath,
@@ -255,7 +274,7 @@ export function scanSingleFile(filePath, rootPath) {
         };
     }
     catch (error) {
-        console.error(`Error scanning file ${filePath}: ${error}`);
+        logger.error(`Error scanning file ${filePath}:`, error);
         return null;
     }
 }

package/dist/common/indexManager.js

@@ -6,6 +6,8 @@ import * as fs from "fs";
 import * as path from "path";
 import { scanFiles, scanSingleFile } from "./fileScanner.js";
 import { chunkCode } from "./chunker.js";
+import { logger } from "./logger.js";
+import * as crypto from "crypto";
 /**
  * Index manager coordinating the entire indexing pipeline
  */
@@ -14,12 +16,22 @@ export class IndexManager {
     vectorStore;
     metadataPath;
     metadata;
-    constructor(embeddingService, vectorStore, storagePath = ".memorybank") {
+    projectRoot;
+    projectId;
+    constructor(embeddingService, vectorStore, storagePath = ".memorybank", projectRoot) {
         this.embeddingService = embeddingService;
         this.vectorStore = vectorStore;
         this.metadataPath = path.join(storagePath, "index-metadata.json");
+        this.projectRoot = projectRoot || process.cwd();
+        this.projectId = this.generateProjectId(this.projectRoot);
         this.metadata = this.loadMetadata();
     }
+    /**
+     * Generates a unique project ID from the project root path
+     */
+    generateProjectId(projectRoot) {
+        return crypto.createHash("sha256").update(projectRoot).digest("hex").substring(0, 16);
+    }
     /**
      * Loads index metadata from disk
      */
@@ -31,7 +43,7 @@ export class IndexManager {
             }
         }
         catch (error) {
-            console.error(`Warning: Could not load index metadata: ${error}`);
+            logger.warn(`Could not load index metadata: ${error}`);
         }
         return {
             version: "1.0",
@@ -51,7 +63,7 @@ export class IndexManager {
             fs.writeFileSync(this.metadataPath, JSON.stringify(this.metadata, null, 2));
         }
         catch (error) {
-            console.error(`Warning: Could not save index metadata: ${error}`);
+            logger.warn(`Could not save index metadata: ${error}`);
         }
     }
     /**
@@ -73,14 +85,14 @@ export class IndexManager {
     /**
      * Indexes a single file
      */
-    async indexFile(file, forceReindex = false) {
+    async indexFile(file, forceReindex = false, saveMetadata = true) {
         try {
             // Check if file needs reindexing
             if (!this.needsReindexing(file, forceReindex)) {
-                console.error(`Skipping ${file.path} (no changes)`);
+                logger.debug(`Skipping ${file.path} (no changes)`);
                 return { chunksCreated: 0 };
             }
-            console.error(`Indexing: ${file.path}`);
+            logger.info(`Indexing: ${file.path}`);
             // Read file content
             const content = fs.readFileSync(file.absolutePath, "utf-8");
             // Get chunk size from environment or use defaults
@@ -95,20 +107,26 @@ export class IndexManager {
                 chunkOverlap,
             });
             if (chunks.length === 0) {
-                console.error(`Warning: No chunks created for ${file.path}`);
+                logger.warn(`No chunks created for ${file.path}`);
+                return { chunksCreated: 0 };
+            }
+            logger.debug(`  Created ${chunks.length} chunks`);
+            // Filter out invalid chunks (fail-safe)
+            const validChunks = chunks.filter(c => c.content && c.content.trim().length > 0 && c.content.trim() !== "}");
+            if (validChunks.length === 0) {
+                logger.warn(`No valid chunks after filtering for ${file.path}`);
                 return { chunksCreated: 0 };
             }
-            console.error(`  Created ${chunks.length} chunks`);
             // Generate embeddings
-            const embeddingInputs = chunks.map((chunk) => ({
+            const embeddingInputs = validChunks.map((chunk) => ({
                 id: chunk.id,
                 content: chunk.content,
             }));
             const embeddings = await this.embeddingService.generateBatchEmbeddings(embeddingInputs);
-            console.error(`  Generated ${embeddings.length} embeddings`);
+            logger.debug(`  Generated ${embeddings.length} embeddings`);
             // Prepare chunk records for storage
             const timestamp = Date.now();
-            const chunkRecords = chunks.map((chunk, i) => ({
+            const chunkRecords = validChunks.map((chunk, i) => ({
                 id: chunk.id,
                 vector: embeddings[i].vector,
                 filePath: chunk.filePath,
@@ -116,17 +134,18 @@ export class IndexManager {
                 startLine: chunk.startLine,
                 endLine: chunk.endLine,
                 chunkType: chunk.chunkType,
-                name: chunk.name,
+                name: chunk.name || "",
                 language: chunk.language,
                 fileHash: file.hash,
                 timestamp,
                 context: chunk.context,
+                projectId: this.projectId,
             }));
             // Delete old chunks for this file
-            await this.vectorStore.deleteChunksByFile(file.path);
+            await this.vectorStore.deleteChunksByFile(file.path, this.projectId);
             // Insert new chunks
             await this.vectorStore.insertChunks(chunkRecords);
-            console.error(`  Stored ${chunkRecords.length} chunks in vector store`);
+            logger.debug(`  Stored ${chunkRecords.length} chunks in vector store`);
             // Update metadata
             this.metadata.files[file.path] = {
                 hash: file.hash,
@@ -134,12 +153,14 @@ export class IndexManager {
                 chunkCount: chunks.length,
             };
             this.metadata.lastIndexed = timestamp;
-            this.saveMetadata();
+            if (saveMetadata) {
+                this.saveMetadata();
+            }
             return { chunksCreated: chunks.length };
         }
         catch (error) {
             const errorMsg = `Error indexing ${file.path}: ${error}`;
-            console.error(errorMsg);
+            logger.error(errorMsg);
             return { chunksCreated: 0, error: errorMsg };
         }
     }
@@ -148,19 +169,20 @@ export class IndexManager {
      */
     async indexFiles(options) {
         const startTime = Date.now();
-        console.error(`\n=== Starting indexing process ===`);
-        console.error(`Root path: ${options.rootPath}`);
-        console.error(`Force reindex: ${options.forceReindex || false}`);
+        logger.info(`=== Starting indexing process ===`);
+        logger.info(`Root path: ${options.rootPath}`);
+        logger.info(`Force reindex: ${options.forceReindex || false}`);
         // Initialize vector store
         await this.vectorStore.initialize();
         // Scan files
-        console.error(`\nScanning files...`);
-        const files = scanFiles({
+        logger.info(`Scanning files...`);
+        const files = await scanFiles({
             rootPath: options.rootPath,
+            projectRoot: options.projectRoot,
             recursive: options.recursive !== undefined ? options.recursive : true,
         });
         if (files.length === 0) {
-            console.error("No files found to index");
+            logger.warn("No files found to index");
             return {
                 filesProcessed: 0,
                 chunksCreated: 0,
@@ -170,9 +192,9 @@ export class IndexManager {
         }
         // Filter files that need reindexing
         const filesToIndex = files.filter((file) => this.needsReindexing(file, options.forceReindex || false));
-        console.error(`\nFound ${files.length} files, ${filesToIndex.length} need indexing`);
+        logger.info(`Found ${files.length} files, ${filesToIndex.length} need indexing`);
         if (filesToIndex.length === 0) {
-            console.error("All files are up to date");
+            logger.info("All files are up to date");
             return {
                 filesProcessed: 0,
                 chunksCreated: 0,
@@ -180,28 +202,45 @@ export class IndexManager {
                 duration: Date.now() - startTime,
             };
         }
-        // Index files
+        // Index files in batches
         const errors = [];
         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);
-            if (result.error) {
-                errors.push(result.error);
+        const batchSize = 5; // Concurrency limit
+        for (let i = 0; i < filesToIndex.length; i += batchSize) {
+            const batch = filesToIndex.slice(i, i + batchSize);
+            const batchNum = Math.floor(i / batchSize) + 1;
+            const totalBatches = Math.ceil(filesToIndex.length / batchSize);
+            logger.info(`Processing batch ${batchNum}/${totalBatches} (${batch.length} files)`);
+            const batchPromises = batch.map(async (file, index) => {
+                logger.debug(`[${i + index + 1}/${filesToIndex.length}] Processing ${file.path}`);
+                return this.indexFile(file, options.forceReindex || false, false); // Don't save metadata per file
+            });
+            const results = await Promise.all(batchPromises);
+            // Process results
+            for (const result of results) {
+                if (result.error) {
+                    errors.push(result.error);
+                }
+                else {
+                    processedFiles++;
+                    totalChunks += result.chunksCreated;
+                }
             }
-            else {
-                processedFiles++;
-                totalChunks += result.chunksCreated;
+            // Save metadata and embedding cache after each batch
+            this.saveMetadata();
+            this.embeddingService.saveCache();
+            // Small delay between batches
+            if (i + batchSize < filesToIndex.length) {
+                await new Promise(resolve => setTimeout(resolve, 100));
             }
         }
         const duration = 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`);
+        logger.info(`=== Indexing complete ===`);
+        logger.info(`Files processed: ${processedFiles}`);
+        logger.info(`Chunks created: ${totalChunks}`);
+        logger.info(`Errors: ${errors.length}`);
+        logger.info(`Duration: ${(duration / 1000).toFixed(2)}s`);
         return {
             filesProcessed: processedFiles,
             chunksCreated: totalChunks,
@@ -212,10 +251,10 @@ export class IndexManager {
     /**
      * Re-indexes a specific file by path
      */
-    async reindexFile(filePath, rootPath) {
+    async reindexFile(filePath, rootPath, projectRoot) {
         try {
             // Scan the specific file
-            const file = scanSingleFile(filePath, rootPath);
+            const file = await scanSingleFile(filePath, rootPath, projectRoot);
             if (!file) {
                 return {
                     success: false,
@@ -310,23 +349,23 @@ export class IndexManager {
         this.saveMetadata();
         // Clear embedding cache
         this.embeddingService.clearCache();
-        console.error("Index cleared");
+        logger.info("Index cleared");
     }
     /**
      * Removes a file from the index
      */
     async removeFile(filePath) {
         await this.vectorStore.initialize();
-        await this.vectorStore.deleteChunksByFile(filePath);
+        await this.vectorStore.deleteChunksByFile(filePath, this.projectId);
         delete this.metadata.files[filePath];
         this.saveMetadata();
-        console.error(`Removed ${filePath} from index`);
+        logger.info(`Removed ${filePath} from index`);
     }
 }
 /**
  * Creates an index manager from environment variables
  */
-export function createIndexManager(embeddingService, vectorStore) {
+export function createIndexManager(embeddingService, vectorStore, workspaceRoot) {
     const storagePath = process.env.MEMORYBANK_STORAGE_PATH || ".memorybank";
-    return new IndexManager(embeddingService, vectorStore, storagePath);
+    return new IndexManager(embeddingService, vectorStore, storagePath, workspaceRoot);
 }