@grec0/memory-bank-mcp 0.1.7 → 0.1.8

package/dist/common/indexManager.js

@@ -302,7 +302,7 @@ export class IndexManager {
                 // 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);
+                docsGeneration = await this.projectKnowledgeService.updateDocuments(projectId, allChunks, changedFiles);
                 console.error(`Docs updated: ${docsGeneration.documentsUpdated.length}`);
                 console.error(`Docs generated: ${docsGeneration.documentsGenerated.length}`);
                 console.error(`Reasoning tokens: ${docsGeneration.totalReasoningTokens}`);

package/dist/common/projectKnowledgeService.js

@@ -133,7 +133,7 @@ Generate a markdown document tracking project documentation progress.`,
 export class ProjectKnowledgeService {
     client;
     options;
-    metadataCache;
+    metadataCacheByProject;
     constructor(apiKey, options) {
         if (!apiKey) {
             throw new Error("OpenAI API key is required for Project Knowledge Service");
@@ -142,55 +142,72 @@ export class ProjectKnowledgeService {
         this.options = {
             model: options?.model || "gpt-5-mini",
             reasoningEffort: options?.reasoningEffort || "medium",
-            docsPath: options?.docsPath || ".memorybank/project-docs",
+            storagePath: options?.storagePath || ".memorybank",
             enableSummary: options?.enableSummary !== undefined ? options.enableSummary : true,
             maxChunksPerDoc: options?.maxChunksPerDoc || 50,
         };
-        this.metadataCache = new Map();
-        this.ensureDocsDirectory();
-        this.loadMetadata();
+        this.metadataCacheByProject = new Map();
     }
     /**
-     * Ensures the docs directory exists
+     * Gets the docs path for a specific project
+     */
+    getProjectDocsPath(projectId) {
+        return path.join(this.options.storagePath, "projects", projectId, "docs");
+    }
+    /**
+     * Ensures the docs directory exists for a project
      */
-    ensureDocsDirectory() {
-        if (!fs.existsSync(this.options.docsPath)) {
-            fs.mkdirSync(this.options.docsPath, { recursive: true });
-            console.error(`Created project docs directory: ${this.options.docsPath}`);
+    ensureProjectDocsDirectory(projectId) {
+        const docsPath = this.getProjectDocsPath(projectId);
+        if (!fs.existsSync(docsPath)) {
+            fs.mkdirSync(docsPath, { recursive: true });
+            console.error(`Created project docs directory: ${docsPath}`);
         }
+        return docsPath;
     }
     /**
-     * Loads metadata for all documents
+     * Loads metadata for a specific project
      */
-    loadMetadata() {
-        const metadataPath = path.join(this.options.docsPath, "metadata.json");
+    loadProjectMetadata(projectId) {
+        if (this.metadataCacheByProject.has(projectId)) {
+            return this.metadataCacheByProject.get(projectId);
+        }
+        const docsPath = this.getProjectDocsPath(projectId);
+        const metadataPath = path.join(docsPath, "metadata.json");
+        const cache = new Map();
         try {
             if (fs.existsSync(metadataPath)) {
                 const data = JSON.parse(fs.readFileSync(metadataPath, "utf-8"));
                 for (const [type, metadata] of Object.entries(data)) {
-                    this.metadataCache.set(type, metadata);
+                    cache.set(type, metadata);
                 }
-                console.error(`Loaded metadata for ${this.metadataCache.size} project documents`);
+                console.error(`Loaded metadata for ${cache.size} documents (project: ${projectId})`);
             }
         }
         catch (error) {
-            console.error(`Warning: Could not load project docs metadata: ${error}`);
+            console.error(`Warning: Could not load project docs metadata for ${projectId}: ${error}`);
         }
+        this.metadataCacheByProject.set(projectId, cache);
+        return cache;
     }
     /**
-     * Saves metadata for all documents
+     * Saves metadata for a specific project
      */
-    saveMetadata() {
-        const metadataPath = path.join(this.options.docsPath, "metadata.json");
+    saveProjectMetadata(projectId) {
+        const docsPath = this.ensureProjectDocsDirectory(projectId);
+        const metadataPath = path.join(docsPath, "metadata.json");
+        const cache = this.metadataCacheByProject.get(projectId);
+        if (!cache)
+            return;
         try {
             const data = {};
-            for (const [type, metadata] of this.metadataCache) {
+            for (const [type, metadata] of cache) {
                 data[type] = metadata;
             }
             fs.writeFileSync(metadataPath, JSON.stringify(data, null, 2));
         }
         catch (error) {
-            console.error(`Warning: Could not save project docs metadata: ${error}`);
+            console.error(`Warning: Could not save project docs metadata for ${projectId}: ${error}`);
         }
     }
     /**
@@ -315,18 +332,20 @@ ${chunk.content}
         };
     }
     /**
-     * Generates a single document
+     * Generates a single document for a specific project
      */
-    async generateDocument(type, chunks, force = false, previousProgress) {
+    async generateDocument(projectId, type, chunks, force = false, previousProgress) {
         const definition = DOC_DEFINITIONS[type];
         const inputHash = this.hashChunks(chunks);
+        const docsPath = this.ensureProjectDocsDirectory(projectId);
+        const metadataCache = this.loadProjectMetadata(projectId);
         // Check if regeneration is needed
-        const existingMetadata = this.metadataCache.get(type);
+        const existingMetadata = metadataCache.get(type);
         if (!force && existingMetadata && existingMetadata.lastInputHash === inputHash) {
             console.error(`Skipping ${type}: No changes detected`);
             return null;
         }
-        console.error(`Generating document: ${definition.title}`);
+        console.error(`Generating document: ${definition.title} (project: ${projectId})`);
         console.error(`  Input chunks: ${chunks.length}`);
         // Prepare prompt
         const chunksText = this.prepareChunksForPrompt(chunks, this.options.maxChunksPerDoc);
@@ -353,18 +372,18 @@ ${chunk.content}
             },
         };
         // Save document
-        const docPath = path.join(this.options.docsPath, definition.filename);
+        const docPath = path.join(docsPath, definition.filename);
         fs.writeFileSync(docPath, doc.content);
         // Update metadata
-        this.metadataCache.set(type, doc.metadata);
-        this.saveMetadata();
+        metadataCache.set(type, doc.metadata);
+        this.saveProjectMetadata(projectId);
         console.error(`Generated ${definition.title} (${result.reasoningTokens} reasoning + ${result.outputTokens} output tokens)`);
         return doc;
     }
     /**
      * Generates all project documents (in parallel for speed)
      */
-    async generateAllDocuments(chunks, force = false) {
+    async generateAllDocuments(projectId, chunks, force = false) {
         const result = {
             success: true,
             documentsGenerated: [],
@@ -374,9 +393,11 @@ ${chunk.content}
             totalOutputTokens: 0,
             errors: [],
         };
+        const docsPath = this.ensureProjectDocsDirectory(projectId);
+        const metadataCache = this.loadProjectMetadata(projectId);
         // Get previous progress if exists (read before parallel generation)
         let previousProgress;
-        const progressPath = path.join(this.options.docsPath, "progress.md");
+        const progressPath = path.join(docsPath, "progress.md");
         if (fs.existsSync(progressPath)) {
             previousProgress = fs.readFileSync(progressPath, "utf-8");
         }
@@ -393,15 +414,15 @@ ${chunk.content}
             "activeContext",
             "progress",
         ];
-        console.error(`\n🚀 Generating ${docTypes.length} documents in PARALLEL...`);
+        console.error(`\n🚀 Generating ${docTypes.length} documents in PARALLEL for project: ${projectId}...`);
         // Generate all documents in parallel
         const generationPromises = docTypes.map(async (docType) => {
             try {
                 // For activeContext, use only recent chunks
                 const docChunks = docType === "activeContext" ? recentChunks : chunks;
-                const existingMetadata = this.metadataCache.get(docType);
+                const existingMetadata = metadataCache.get(docType);
                 const isNew = !existingMetadata;
-                const doc = await this.generateDocument(docType, docChunks, force, docType === "progress" ? previousProgress : undefined);
+                const doc = await this.generateDocument(projectId, docType, docChunks, force, docType === "progress" ? previousProgress : undefined);
                 return { docType, doc, isNew, error: null };
             }
             catch (error) {
@@ -438,13 +459,15 @@ ${chunk.content}
     /**
      * Updates only documents affected by changes
      */
-    async updateDocuments(chunks, changedFiles) {
-        console.error(`updateDocuments called with ${chunks.length} chunks and ${changedFiles.length} changed files`);
+    async updateDocuments(projectId, chunks, changedFiles) {
+        console.error(`updateDocuments called for project ${projectId} with ${chunks.length} chunks and ${changedFiles.length} changed files`);
         // Debug: show first chunk if exists
         if (chunks.length > 0) {
             const firstChunk = chunks[0];
             console.error(`First chunk: ${firstChunk.file_path}, content length: ${firstChunk.content?.length || 0}`);
         }
+        const docsPath = this.ensureProjectDocsDirectory(projectId);
+        const metadataCache = this.loadProjectMetadata(projectId);
         // Determine which documents need updating based on changed files
         const docsToUpdate = [];
         // Always update activeContext and progress when there are changes
@@ -475,7 +498,7 @@ ${chunk.content}
         };
         // Get previous progress (read before parallel generation)
         let previousProgress;
-        const progressPath = path.join(this.options.docsPath, "progress.md");
+        const progressPath = path.join(docsPath, "progress.md");
         if (fs.existsSync(progressPath)) {
             previousProgress = fs.readFileSync(progressPath, "utf-8");
         }
@@ -483,14 +506,14 @@ ${chunk.content}
         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...`);
+        console.error(`\n🚀 Updating ${docsToUpdate.length} documents in PARALLEL for project: ${projectId}...`);
         // Generate docs in parallel
         const updatePromises = docsToUpdate.map(async (docType) => {
             try {
                 const docChunks = docType === "activeContext" ? recentChunks : chunks;
-                const existingMetadata = this.metadataCache.get(docType);
+                const existingMetadata = metadataCache.get(docType);
                 const isNew = !existingMetadata;
-                const doc = await this.generateDocument(docType, docChunks, true, // Force update for changed docs
+                const doc = await this.generateDocument(projectId, docType, docChunks, true, // Force update for changed docs
                 docType === "progress" ? previousProgress : undefined);
                 return { docType, doc, isNew, error: null };
             }
@@ -535,16 +558,18 @@ ${chunk.content}
         return result;
     }
     /**
-     * Reads a project document
+     * Reads a project document for a specific project
      */
-    getDocument(type) {
+    getDocument(projectId, type) {
         const definition = DOC_DEFINITIONS[type];
-        const docPath = path.join(this.options.docsPath, definition.filename);
+        const docsPath = this.getProjectDocsPath(projectId);
+        const docPath = path.join(docsPath, definition.filename);
         if (!fs.existsSync(docPath)) {
             return null;
         }
         const content = fs.readFileSync(docPath, "utf-8");
-        const metadata = this.metadataCache.get(type);
+        const metadataCache = this.loadProjectMetadata(projectId);
+        const metadata = metadataCache.get(type);
         return {
             type,
             content,
@@ -558,12 +583,12 @@ ${chunk.content}
         };
     }
     /**
-     * Reads all project documents
+     * Reads all project documents for a specific project
      */
-    getAllDocuments() {
+    getAllDocuments(projectId) {
         const docs = [];
         for (const type of Object.keys(DOC_DEFINITIONS)) {
-            const doc = this.getDocument(type);
+            const doc = this.getDocument(projectId, type);
             if (doc) {
                 docs.push(doc);
             }
@@ -573,8 +598,8 @@ ${chunk.content}
     /**
      * Gets a summary of all documents (useful for context loading)
      */
-    getDocumentsSummary() {
-        const docs = this.getAllDocuments();
+    getDocumentsSummary(projectId) {
+        const docs = this.getAllDocuments(projectId);
         if (docs.length === 0) {
             return "No project documentation has been generated yet. Use memorybank_generate_project_docs to generate documentation.";
         }
@@ -594,21 +619,23 @@ ${chunk.content}
         return summary;
     }
     /**
-     * Checks if documents exist
+     * Checks if documents exist for a project
      */
-    hasDocuments() {
-        return this.metadataCache.size > 0;
+    hasDocuments(projectId) {
+        const metadataCache = this.loadProjectMetadata(projectId);
+        return metadataCache.size > 0;
     }
     /**
-     * Gets statistics about generated documents
+     * Gets statistics about generated documents for a project
      */
-    getStats() {
+    getStats(projectId) {
+        const metadataCache = this.loadProjectMetadata(projectId);
         let totalReasoningTokens = 0;
         let totalOutputTokens = 0;
         let lastGenerated = 0;
         const documents = {};
         for (const type of Object.keys(DOC_DEFINITIONS)) {
-            const metadata = this.metadataCache.get(type);
+            const metadata = metadataCache.get(type);
             documents[type] = {
                 exists: !!metadata,
                 lastGenerated: metadata ? new Date(metadata.lastGenerated) : undefined,
@@ -622,7 +649,7 @@ ${chunk.content}
             }
         }
         return {
-            documentCount: this.metadataCache.size,
+            documentCount: metadataCache.size,
             totalReasoningTokens,
             totalOutputTokens,
             lastGenerated: lastGenerated > 0 ? new Date(lastGenerated) : undefined,
@@ -632,13 +659,6 @@ ${chunk.content}
     // ==========================================
     // Project-specific document methods (for MCP Resources)
     // ==========================================
-    /**
-     * Gets the docs path for a specific project
-     */
-    getProjectDocsPath(projectId) {
-        const storagePath = process.env.MEMORYBANK_STORAGE_PATH || ".memorybank";
-        return path.join(storagePath, "projects", projectId, "docs");
-    }
     /**
      * Checks if a project's Memory Bank is initialized
      */
@@ -716,7 +736,7 @@ export function createProjectKnowledgeService() {
     const options = {
         model: process.env.MEMORYBANK_REASONING_MODEL || "gpt-5-mini",
         reasoningEffort: process.env.MEMORYBANK_REASONING_EFFORT || "medium",
-        docsPath: path.join(storagePath, "project-docs"),
+        storagePath: storagePath,
         enableSummary: true,
     };
     return new ProjectKnowledgeService(apiKey, options);

package/dist/tools/generateProjectDocs.js

@@ -33,8 +33,9 @@ export async function generateProjectDocs(params, projectKnowledgeService, vecto
             };
         }
         console.error(`Found ${chunks.length} code chunks to analyze`);
-        // Generate documents
-        const result = await projectKnowledgeService.generateAllDocuments(chunks, params.force || false);
+        // Generate documents - projectId is required
+        const projectId = params.projectId || "default";
+        const result = await projectKnowledgeService.generateAllDocuments(projectId, 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

package/dist/tools/getProjectDocs.js

@@ -15,13 +15,14 @@ const VALID_DOC_TYPES = [
  */
 export async function getProjectDocs(params, projectKnowledgeService) {
     try {
+        const projectId = params.projectId;
         const format = params.format || "full";
         const requestedDoc = params.document?.toLowerCase();
-        // Check if any documents exist
-        if (!projectKnowledgeService.hasDocuments()) {
+        // Check if any documents exist for this project
+        if (!projectKnowledgeService.hasDocuments(projectId)) {
             return {
                 success: false,
-                message: "No project documentation has been generated yet. Run memorybank_generate_project_docs first.",
+                message: `No project documentation has been generated for project "${projectId}" yet. Run memorybank_generate_project_docs first.`,
                 stats: {
                     documentCount: 0,
                     totalReasoningTokens: 0,
@@ -29,8 +30,8 @@ export async function getProjectDocs(params, projectKnowledgeService) {
                 },
             };
         }
-        // Get stats
-        const stats = projectKnowledgeService.getStats();
+        // Get stats for this project
+        const stats = projectKnowledgeService.getStats(projectId);
         const statsResult = {
             documentCount: stats.documentCount,
             totalReasoningTokens: stats.totalReasoningTokens,
@@ -39,20 +40,20 @@ export async function getProjectDocs(params, projectKnowledgeService) {
         };
         // Handle summary request
         if (requestedDoc === "summary" || format === "summary") {
-            const summary = projectKnowledgeService.getDocumentsSummary();
+            const summary = projectKnowledgeService.getDocumentsSummary(projectId);
             return {
                 success: true,
-                message: `Retrieved summary of ${stats.documentCount} project documents.`,
+                message: `Retrieved summary of ${stats.documentCount} project documents for "${projectId}".`,
                 summary,
                 stats: statsResult,
             };
         }
         // Handle "all" or no specific document
         if (!requestedDoc || requestedDoc === "all") {
-            const documents = projectKnowledgeService.getAllDocuments();
+            const documents = projectKnowledgeService.getAllDocuments(projectId);
             return {
                 success: true,
-                message: `Retrieved ${documents.length} project documents.`,
+                message: `Retrieved ${documents.length} project documents for "${projectId}".`,
                 documents,
                 stats: statsResult,
             };
@@ -67,17 +68,17 @@ export async function getProjectDocs(params, projectKnowledgeService) {
                 stats: statsResult,
             };
         }
-        const document = projectKnowledgeService.getDocument(normalizedDoc);
+        const document = projectKnowledgeService.getDocument(projectId, normalizedDoc);
         if (!document) {
             return {
                 success: false,
-                message: `Document "${normalizedDoc}" has not been generated yet.`,
+                message: `Document "${normalizedDoc}" has not been generated yet for project "${projectId}".`,
                 stats: statsResult,
             };
         }
         return {
             success: true,
-            message: `Retrieved document: ${normalizedDoc}`,
+            message: `Retrieved document: ${normalizedDoc} for project "${projectId}"`,
             documents: [document],
             stats: statsResult,
         };

package/package.json

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