@grec0/memory-bank-mcp 0.1.37 → 0.1.39

package/dist/common/indexManager.js

@@ -37,6 +37,12 @@ export class IndexManager {
         this.projectKnowledgeService = service;
         console.error("Project Knowledge Service attached to Index Manager");
     }
+    /**
+     * Gets the Embedding Service instance
+     */
+    getEmbeddingService() {
+        return this.embeddingService;
+    }
     /**
      * Enables or disables auto-update of project docs after indexing
      */

package/dist/common/projectVectorStore.js

@@ -0,0 +1,79 @@
+import * as lancedb from "@lancedb/lancedb";
+import * as fs from "fs";
+export class ProjectVectorStore {
+    db = null;
+    table = null;
+    dbPath;
+    tableName;
+    constructor(dbPath = ".memorybank", tableName = "projects") {
+        this.dbPath = dbPath;
+        this.tableName = tableName;
+    }
+    async initialize() {
+        try {
+            if (!fs.existsSync(this.dbPath)) {
+                fs.mkdirSync(this.dbPath, { recursive: true });
+            }
+            this.db = await lancedb.connect(this.dbPath);
+            const tableNames = await this.db.tableNames();
+            if (tableNames.includes(this.tableName)) {
+                this.table = await this.db.openTable(this.tableName);
+            }
+        }
+        catch (error) {
+            console.error(`Error initializing project vector store: ${error}`);
+            throw error;
+        }
+    }
+    async ensureInitialized() {
+        if (!this.db) {
+            await this.initialize();
+        }
+    }
+    async upsertProject(record) {
+        await this.ensureInitialized();
+        try {
+            if (!this.table) {
+                this.table = await this.db.createTable(this.tableName, [record]);
+            }
+            else {
+                // Delete existing if any (LanceDB update/merge is tricky, delete+insert is safer for single records)
+                try {
+                    await this.table.delete(`id = '${record.id}'`);
+                }
+                catch (e) {
+                    // Ignore if not found or delete fails
+                }
+                await this.table.add([record]);
+            }
+        }
+        catch (error) {
+            console.error(`Error upserting project: ${error}`);
+            throw error;
+        }
+    }
+    async search(queryVector, limit = 10) {
+        await this.ensureInitialized();
+        if (!this.table)
+            return [];
+        try {
+            const results = await this.table.search(queryVector).limit(limit).toArray();
+            return results.map((r) => ({
+                project: {
+                    id: r.id,
+                    vector: r.vector,
+                    name: r.name,
+                    description: r.description,
+                    tags: r.tags,
+                    path: r.path,
+                    lastActive: r.lastActive
+                },
+                score: 1 - (r._distance || 0) // Convert distance to score if needed
+            }));
+        }
+        catch (error) {
+            console.error(`Error searching projects: ${error}`);
+            return [];
+        }
+    }
+}

package/dist/common/registryManager.js

@@ -1,10 +1,13 @@
 import * as fs from 'fs/promises';
 import * as path from 'path';
 import * as os from 'os';
+import { ProjectVectorStore } from './projectVectorStore.js';
 export class RegistryManager {
     globalPath;
+    projectVectorStore;
     constructor() {
         this.globalPath = path.join(os.homedir(), '.memorybank', 'global_registry.json');
+        this.projectVectorStore = new ProjectVectorStore();
     }
     async ensureRegistry() {
         try {
@@ -19,7 +22,7 @@ export class RegistryManager {
     async saveRegistry(registry) {
         await fs.writeFile(this.globalPath, JSON.stringify(registry, null, 2), 'utf-8');
     }
-    async registerProject(projectId, workspacePath, description, keywords = []) {
+    async registerProject(projectId, workspacePath, description, keywords = [], embeddingService) {
         const registry = await this.ensureRegistry();
         const idx = registry.projects.findIndex(p => p.projectId === projectId);
         // Preserve existing description/keywords if not provided
@@ -39,11 +42,56 @@ export class RegistryManager {
             registry.projects.push(card);
         }
         await this.saveRegistry(registry);
+        // Update vector store if embedding service provides
+        if (embeddingService) {
+            try {
+                await this.updateProjectEmbedding(card, embeddingService);
+            }
+            catch (error) {
+                console.error(`Failed to update project embedding: ${error}`);
+            }
+        }
+    }
+    async updateProjectEmbedding(card, embeddingService) {
+        const text = `Project: ${card.projectId}\nDescription: ${card.description || ''}\nKeywords: ${card.keywords.join(', ')}`;
+        const result = await embeddingService.generateEmbedding(card.projectId, text);
+        await this.projectVectorStore.upsertProject({
+            id: card.projectId,
+            vector: result.vector,
+            name: card.projectId, // Using ID as name for now if name not available
+            description: card.description || '',
+            tags: card.keywords,
+            path: card.path,
+            lastActive: new Date(card.lastActive).getTime()
+        });
     }
-    async discoverProjects(query) {
+    async discoverProjects(query, embeddingService) {
         const registry = await this.ensureRegistry();
         if (!query || query.trim() === '')
             return registry.projects;
+        // Try semantic search if service available
+        if (embeddingService) {
+            try {
+                const queryEmbedding = await embeddingService.generateEmbedding('search-query', query);
+                const results = await this.projectVectorStore.search(queryEmbedding.vector);
+                // Map back to ProjectCards
+                const projectIds = new Set(results.map(r => r.project.id));
+                // Return found projects, maintain order from vector search
+                const foundProjects = [];
+                for (const res of results) {
+                    const card = registry.projects.find(p => p.projectId === res.project.id);
+                    if (card)
+                        foundProjects.push(card);
+                }
+                // If we found something, return it. If very few, maybe fallback or mix?
+                // For now, if we have semantic results, use them.
+                if (foundProjects.length > 0)
+                    return foundProjects;
+            }
+            catch (error) {
+                console.error(`Semantic search failed, falling back to text: ${error}`);
+            }
+        }
         const q = query.toLowerCase();
         return registry.projects.filter(p => p.projectId.toLowerCase().includes(q) ||
             (p.description && p.description.toLowerCase().includes(q)) ||
@@ -53,4 +101,28 @@ export class RegistryManager {
         const registry = await this.ensureRegistry();
         return registry.projects.find(p => p.projectId === projectId);
     }
+    /**
+     * Syncs all projects from the JSON registry to the vector store.
+     * Useful for migrating existing projects to the new semantic discovery system.
+     */
+    async syncRegistry(embeddingService) {
+        const registry = await this.ensureRegistry();
+        let processed = 0;
+        let failures = 0;
+        console.error(`Syncing ${registry.projects.length} projects to vector store...`);
+        for (const project of registry.projects) {
+            try {
+                await this.updateProjectEmbedding(project, embeddingService);
+                processed++;
+                if (processed % 10 === 0) {
+                    console.error(`Synced ${processed}/${registry.projects.length} projects`);
+                }
+            }
+            catch (error) {
+                console.error(`Failed to sync project ${project.projectId}: ${error}`);
+                failures++;
+            }
+        }
+        return { processed, failures };
+    }
 }

package/dist/common/version.js

@@ -1,2 +1,2 @@
 // Version of the MCP Kanban server
-export const VERSION = "0.1.33";
+export const VERSION = "0.1.39";

package/dist/index.js

@@ -82,6 +82,7 @@ import { trackProgress, trackProgressToolDefinition } from "./tools/trackProgres
 import { manageAgentsTool, manageAgentsToolDefinition } from "./tools/manageAgents.js";
 import { discoverProjectsTool, discoverProjectsToolDefinition } from "./tools/discoverProjects.js";
 import { delegateTaskTool, delegateTaskToolDefinition } from "./tools/delegateTask.js";
+import { syncProjectsTool, syncProjectsToolDefinition } from "./tools/syncProjects.js";
 import { RegistryManager } from "./common/registryManager.js";
 import { VERSION } from "./common/version.js";
 // Global services
@@ -837,6 +838,13 @@ server.tool(discoverProjectsToolDefinition.name, discoverProjectsToolDefinition.
         content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
     };
 });
+// Tool: Sync Projects
+server.tool(syncProjectsToolDefinition.name, syncProjectsToolDefinition.description, {}, async () => {
+    const result = await syncProjectsTool();
+    return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+    };
+});
 // Tool: Delegate Task
 server.tool(delegateTaskToolDefinition.name, delegateTaskToolDefinition.description, {
     projectId: z.string().describe("ID del proyecto origen (quien pide)"),

package/dist/tools/discoverProjects.js

@@ -1,7 +1,17 @@
 import { RegistryManager } from '../common/registryManager.js';
+import { EmbeddingService } from '../common/embeddingService.js';
 export async function discoverProjectsTool(params) {
     const registryManager = new RegistryManager();
-    const projects = await registryManager.discoverProjects(params.query);
+    let embeddingService;
+    if (process.env.OPENAI_API_KEY) {
+        try {
+            embeddingService = new EmbeddingService(process.env.OPENAI_API_KEY);
+        }
+        catch (e) {
+            console.error("Failed to init embedding service for discovery:", e);
+        }
+    }
+    const projects = await registryManager.discoverProjects(params.query, embeddingService);
     return {
         success: true,
         projectCount: projects.length,

package/dist/tools/index.js

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

package/dist/tools/indexCode.js

@@ -6,6 +6,7 @@ import * as path from "path";
 import { AgentBoard } from "../common/agentBoard.js";
 import { sessionLogger } from "../common/sessionLogger.js";
 import { sessionState } from "../common/sessionState.js";
+import { RegistryManager } from "../common/registryManager.js";
 /**
  * Indexes code from a directory or file
  */
@@ -44,6 +45,20 @@ export async function indexCode(params, indexManager, workspaceRoot) {
         console.error(`Workspace root: ${workspaceRoot}`);
         console.error(`Recursive: ${params.recursive !== false}`);
         console.error(`Force reindex: ${params.forceReindex || false}`);
+        // Register project and update embedding
+        try {
+            const registryManager = new RegistryManager();
+            const embeddingService = indexManager.getEmbeddingService();
+            // Try to get description/keywords from indexManager or project files could be an enhancement
+            // For now, we ensure registration with what we have
+            await registryManager.registerProject(params.projectId, workspaceRoot, undefined, // Preserve existing description
+            [], // Preserve/empty keywords
+            embeddingService);
+            console.error(`Project ${params.projectId} registered/updated in global registry and vector store`);
+        }
+        catch (regError) {
+            console.error(`Failed to register project: ${regError}`);
+        }
         // Run indexing - pass workspaceRoot for consistent path normalization
         const result = await indexManager.indexFiles({
             projectId: params.projectId,

package/dist/tools/syncProjects.js

@@ -0,0 +1,34 @@
+import { RegistryManager } from '../common/registryManager.js';
+import { EmbeddingService } from '../common/embeddingService.js';
+export async function syncProjectsTool() {
+    if (!process.env.OPENAI_API_KEY) {
+        return {
+            success: false,
+            message: "OPENAI_API_KEY environment variable is required for syncing projects."
+        };
+    }
+    try {
+        const registryManager = new RegistryManager();
+        const embeddingService = new EmbeddingService(process.env.OPENAI_API_KEY);
+        const result = await registryManager.syncRegistry(embeddingService);
+        return {
+            success: true,
+            message: `Synchronization complete. Processed: ${result.processed}, Failures: ${result.failures}`,
+            details: result
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            message: `Error during synchronization: ${error}`
+        };
+    }
+}
+export const syncProjectsToolDefinition = {
+    name: "memorybank_sync_projects",
+    description: "Sincroniza todos los proyectos del registro JSON al store vectorial para habilitar la búsqueda semántica. Útil para migrar datos existentes.",
+    inputSchema: {
+        type: "object",
+        properties: {}
+    }
+};

package/package.json

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