@grec0/memory-bank-mcp 0.2.12 → 0.2.14

package/dist/common/registryManager.js

@@ -1,23 +1,123 @@
 import * as fs from 'fs/promises';
+import * as fssync from 'fs';
 import * as path from 'path';
 import * as os from 'os';
 import { ProjectVectorStore } from './projectVectorStore.js';
 export class RegistryManager {
     globalPath;
     projectVectorStore;
+    storagePath;
     constructor() {
         this.globalPath = path.join(os.homedir(), '.memorybank', 'global_registry.json');
+        this.storagePath = process.env.MEMORYBANK_STORAGE_PATH || path.join(os.homedir(), '.memorybank');
         this.projectVectorStore = new ProjectVectorStore();
     }
+    /**
+     * Discovers projects by scanning the projects directory
+     * Used for auto-recovery when registry.json is corrupted/empty
+     */
+    async discoverProjectsFromDisk() {
+        const projectsDir = path.join(this.storagePath, 'projects');
+        if (!fssync.existsSync(projectsDir)) {
+            return [];
+        }
+        try {
+            const entries = await fs.readdir(projectsDir, { withFileTypes: true });
+            const projectIds = entries
+                .filter(e => e.isDirectory())
+                .map(e => e.name);
+            console.error(`Discovered ${projectIds.length} projects from disk: ${projectIds.join(', ')}`);
+            return projectIds;
+        }
+        catch (error) {
+            console.error(`Error discovering projects from disk: ${error}`);
+            return [];
+        }
+    }
+    /**
+     * Ensures the registry exists and returns it
+     * If corrupted/empty, auto-recovers by scanning project folders
+     */
     async ensureRegistry() {
         try {
             await fs.mkdir(path.dirname(this.globalPath), { recursive: true });
             const content = await fs.readFile(this.globalPath, 'utf-8');
-            return JSON.parse(content);
+            // Validate JSON
+            if (!content || content.trim() === '') {
+                console.error('⚠️  Registry file is empty, attempting auto-recovery...');
+                return await this.autoRecoverRegistry();
+            }
+            const parsed = JSON.parse(content);
+            // Validate structure
+            if (!parsed || typeof parsed !== 'object' || !Array.isArray(parsed.projects)) {
+                console.error('⚠️  Registry file has invalid structure, attempting auto-recovery...');
+                await this.backupCorruptedRegistry(content);
+                return await this.autoRecoverRegistry();
+            }
+            // Check if registry is suspiciously empty (has folders but no projects)
+            if (parsed.projects.length === 0) {
+                const diskProjects = await this.discoverProjectsFromDisk();
+                if (diskProjects.length > 0) {
+                    console.error(`⚠️  Registry is empty but ${diskProjects.length} projects exist on disk, attempting auto-recovery...`);
+                    await this.backupCorruptedRegistry(content);
+                    return await this.autoRecoverRegistry();
+                }
+            }
+            return parsed;
         }
-        catch {
+        catch (error) {
+            if (error.code === 'ENOENT') {
+                // File doesn't exist, try auto-recovery
+                console.error('Registry file does not exist, attempting auto-recovery...');
+                return await this.autoRecoverRegistry();
+            }
+            // JSON parse error - backup and auto-recover
+            console.error(`Error reading registry: ${error.message}, attempting auto-recovery...`);
+            try {
+                const content = await fs.readFile(this.globalPath, 'utf-8');
+                await this.backupCorruptedRegistry(content);
+            }
+            catch {
+                // Can't read for backup
+            }
+            return await this.autoRecoverRegistry();
+        }
+    }
+    /**
+     * Auto-recovers registry by discovering projects from disk
+     * Returns a minimal registry with project IDs - full data will be populated by sync
+     */
+    async autoRecoverRegistry() {
+        const projectIds = await this.discoverProjectsFromDisk();
+        if (projectIds.length === 0) {
+            console.error('No projects found on disk, starting with empty registry');
             return { projects: [] };
         }
+        console.error(`✓ Auto-recovered ${projectIds.length} projects from disk`);
+        console.error(`  Run 'memorybank_sync_projects' to populate full metadata`);
+        // Return minimal registry - sync will populate the rest
+        const projects = projectIds.map(projectId => ({
+            projectId,
+            path: '', // Will be populated by sync
+            description: '',
+            keywords: [],
+            lastActive: new Date().toISOString(),
+            status: 'ACTIVE'
+        }));
+        return { projects };
+    }
+    /**
+     * Backs up a corrupted registry file before overwriting
+     */
+    async backupCorruptedRegistry(content) {
+        try {
+            const backupPath = `${this.globalPath}.backup-${Date.now()}`;
+            await fs.writeFile(backupPath, content, 'utf-8');
+            console.error(`Backed up corrupted registry to: ${backupPath}`);
+        }
+        catch (error) {
+            console.error(`Failed to backup corrupted registry: ${error}`);
+        }
     }
     async saveRegistry(registry) {
         await fs.writeFile(this.globalPath, JSON.stringify(registry, null, 2), 'utf-8');
@@ -29,16 +129,27 @@ export class RegistryManager {
         const existing = idx >= 0 ? registry.projects[idx] : null;
         const card = {
             projectId,
-            path: workspacePath,
-            description: description || existing?.description || '',
+            // Preserve existing workspace path if new one is empty/invalid
+            path: (workspacePath && workspacePath.trim() !== '') ? workspacePath : (existing?.path || workspacePath),
+            // Preserve existing description if new one is undefined or empty
+            description: (description !== undefined && description.trim() !== '') ? description : (existing?.description || ''),
+            // Preserve existing keywords if new array is empty
             keywords: keywords.length > 0 ? keywords : (existing?.keywords || []),
             lastActive: new Date().toISOString(),
             status: 'ACTIVE',
             // Enhanced fields - preserve existing if not provided
-            responsibilities: enhancedInfo?.responsibilities || existing?.responsibilities,
-            owns: enhancedInfo?.owns || existing?.owns,
-            exports: enhancedInfo?.exports || existing?.exports,
-            projectType: enhancedInfo?.projectType || existing?.projectType,
+            responsibilities: enhancedInfo?.responsibilities !== undefined
+                ? (enhancedInfo.responsibilities.length > 0 ? enhancedInfo.responsibilities : existing?.responsibilities)
+                : existing?.responsibilities,
+            owns: enhancedInfo?.owns !== undefined
+                ? (enhancedInfo.owns.length > 0 ? enhancedInfo.owns : existing?.owns)
+                : existing?.owns,
+            exports: enhancedInfo?.exports !== undefined
+                ? (enhancedInfo.exports.trim() !== '' ? enhancedInfo.exports : existing?.exports)
+                : existing?.exports,
+            projectType: enhancedInfo?.projectType !== undefined
+                ? (enhancedInfo.projectType.trim() !== '' ? enhancedInfo.projectType : existing?.projectType)
+                : existing?.projectType,
         };
         if (idx >= 0) {
             registry.projects[idx] = card;

package/dist/common/vectorStore.js

@@ -378,6 +378,30 @@ export class VectorStore {
             return new Map();
         }
     }
+    /**
+     * Gets all unique project IDs that have indexed chunks
+     * Useful for discovering which projects have code in the vector store
+     */
+    async getIndexedProjectIds() {
+        await this.ensureInitialized();
+        if (!this.table) {
+            return [];
+        }
+        try {
+            const allChunks = await this.table.query().toArray();
+            const projectIds = new Set();
+            for (const chunk of allChunks) {
+                if (chunk.project_id) {
+                    projectIds.add(chunk.project_id);
+                }
+            }
+            return Array.from(projectIds);
+        }
+        catch (error) {
+            console.error(`Error getting indexed project IDs: ${error}`);
+            return [];
+        }
+    }
 }
 /**
  * Creates a vector store from environment variables

package/dist/common/version.js

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

package/dist/tools/generateProjectDocs.js

@@ -98,32 +98,44 @@ export async function generateProjectDocs(params, projectKnowledgeService, vecto
         console.error(`  - Estimated cost: $${totalCost.toFixed(4)}`);
         // === AUTO-UPDATE GLOBAL REGISTRY ===
         // Generate project summary and update registry with enriched info
-        if (result.documentsGenerated.length > 0 || result.documentsUpdated.length > 0) {
+        // ONLY if generation was successful AND at least one document was generated/updated
+        if (result.success && (result.documentsGenerated.length > 0 || result.documentsUpdated.length > 0)) {
             try {
                 console.error(`\n=== Updating Global Registry ===`);
                 const summary = await projectKnowledgeService.generateProjectSummary(projectId);
                 if (summary) {
-                    const registryManager = new RegistryManager();
-                    let embeddingService;
-                    if (process.env.OPENAI_API_KEY) {
-                        try {
-                            embeddingService = new EmbeddingService(process.env.OPENAI_API_KEY);
-                        }
-                        catch (e) {
-                            console.error(`Warning: Could not init embedding service: ${e}`);
+                    // Validate that the summary has meaningful data before updating registry
+                    const hasResponsibilities = summary.responsibilities && summary.responsibilities.length > 0;
+                    const hasDescription = summary.description && summary.description.trim().length > 0;
+                    if (!hasResponsibilities && !hasDescription) {
+                        console.error(`Warning: Generated summary is empty, skipping registry update`);
+                    }
+                    else {
+                        const registryManager = new RegistryManager();
+                        let embeddingService;
+                        if (process.env.OPENAI_API_KEY) {
+                            try {
+                                embeddingService = new EmbeddingService(process.env.OPENAI_API_KEY);
+                            }
+                            catch (e) {
+                                console.error(`Warning: Could not init embedding service: ${e}`);
+                            }
                         }
+                        await registryManager.registerProject(projectId, workspaceRoot, summary.description, summary.keywords, embeddingService, {
+                            responsibilities: summary.responsibilities,
+                            owns: summary.owns,
+                            exports: summary.exports,
+                            projectType: summary.projectType,
+                        });
+                        console.error(`Registry updated for ${projectId}:`);
+                        console.error(`  - Description: ${summary.description.slice(0, 80)}...`);
+                        console.error(`  - Type: ${summary.projectType}`);
+                        console.error(`  - Responsibilities: ${summary.responsibilities?.length || 0}`);
+                        message += ` Registry updated with project summary.`;
                     }
-                    await registryManager.registerProject(projectId, workspaceRoot, summary.description, summary.keywords, embeddingService, {
-                        responsibilities: summary.responsibilities,
-                        owns: summary.owns,
-                        exports: summary.exports,
-                        projectType: summary.projectType,
-                    });
-                    console.error(`Registry updated for ${projectId}:`);
-                    console.error(`  - Description: ${summary.description.slice(0, 80)}...`);
-                    console.error(`  - Type: ${summary.projectType}`);
-                    console.error(`  - Responsibilities: ${summary.responsibilities.length}`);
-                    message += ` Registry updated with project summary.`;
+                }
+                else {
+                    console.error(`Warning: Could not generate project summary, skipping registry update`);
                 }
             }
             catch (regError) {
@@ -131,6 +143,9 @@ export async function generateProjectDocs(params, projectKnowledgeService, vecto
                 // Don't fail the whole operation if registry update fails
             }
         }
+        else if (!result.success) {
+            console.error(`Skipping registry update because documentation generation failed`);
+        }
         return {
             success: result.success,
             message,

package/dist/tools/syncProjects.js

@@ -1,5 +1,10 @@
 import { RegistryManager } from '../common/registryManager.js';
 import { EmbeddingService } from '../common/embeddingService.js';
+import { VectorStore } from '../common/vectorStore.js';
+import { ProjectKnowledgeService } from '../common/projectKnowledgeService.js';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
 export async function syncProjectsTool() {
     if (!process.env.OPENAI_API_KEY) {
         return {
@@ -10,11 +15,155 @@ export async function syncProjectsTool() {
     try {
         const registryManager = new RegistryManager();
         const embeddingService = new EmbeddingService(process.env.OPENAI_API_KEY);
-        const result = await registryManager.syncRegistry(embeddingService);
+        const vectorStore = new VectorStore();
+        const projectKnowledgeService = new ProjectKnowledgeService(process.env.OPENAI_API_KEY);
+        console.error("\n=== Starting Project Synchronization ===");
+        // Step 1: Discover ALL projects from multiple sources
+        console.error("\nStep 1: Discovering projects from all sources...");
+        // 1a. Find projects with indexed code
+        const indexedProjectIds = await vectorStore.getIndexedProjectIds();
+        console.error(`  - Found ${indexedProjectIds.length} projects with indexed code`);
+        // 1b. Find projects with documentation folders (auto-recovery!)
+        const storagePath = process.env.MEMORYBANK_STORAGE_PATH || path.join(os.homedir(), '.memorybank');
+        const projectsDir = path.join(storagePath, 'projects');
+        let documentedProjectIds = [];
+        if (fs.existsSync(projectsDir)) {
+            const entries = fs.readdirSync(projectsDir, { withFileTypes: true });
+            documentedProjectIds = entries
+                .filter(e => e.isDirectory())
+                .map(e => e.name);
+            console.error(`  - Found ${documentedProjectIds.length} projects with documentation folders`);
+        }
+        // 1c. Combine all discovered projects (unique)
+        const allProjectIds = Array.from(new Set([...indexedProjectIds, ...documentedProjectIds]));
+        console.error(`  - Total unique projects discovered: ${allProjectIds.length}`);
+        if (allProjectIds.length > 0) {
+            console.error(`  - Projects: ${allProjectIds.join(', ')}`);
+        }
+        // Step 2: Sync existing registry to vector store
+        console.error("\nStep 2: Syncing existing registry to vector store...");
+        const registryResult = await registryManager.syncRegistry(embeddingService);
+        console.error(`Registry sync: ${registryResult.processed} processed, ${registryResult.failures} failures`);
+        // Step 3: For each discovered project, ensure it has documentation and registry entry
+        let docsGenerated = 0;
+        let docsSkipped = 0;
+        let docsFailed = 0;
+        let registryRecovered = 0;
+        console.error("\nStep 3: Ensuring documentation and registry for all discovered projects...");
+        for (const projectId of allProjectIds) {
+            try {
+                console.error(`\nProcessing project: ${projectId}`);
+                // Check if project has documentation
+                const hasDocumentation = projectKnowledgeService.isProjectInitialized(projectId);
+                const hasIndexedCode = indexedProjectIds.includes(projectId);
+                if (!hasDocumentation && hasIndexedCode) {
+                    console.error(`  - No documentation found, generating...`);
+                    // Generate documentation (this will automatically update registry)
+                    const chunks = await vectorStore.getAllChunks(projectId);
+                    if (chunks.length > 0) {
+                        const result = await projectKnowledgeService.generateAllDocuments(projectId, chunks, false // Don't force regeneration
+                        );
+                        if (result.success) {
+                            console.error(`  - Documentation generated successfully`);
+                            // Generate and update registry
+                            const summary = await projectKnowledgeService.generateProjectSummary(projectId);
+                            if (summary) {
+                                // Try to find existing workspace path from registry
+                                let workspacePath = '';
+                                const existingProject = await registryManager.getProject(projectId);
+                                if (existingProject) {
+                                    workspacePath = existingProject.path;
+                                }
+                                else {
+                                    // Try to infer from chunks
+                                    const firstChunk = chunks[0];
+                                    if (firstChunk && firstChunk.file_path) {
+                                        // Extract workspace path (this is a guess, may not be perfect)
+                                        workspacePath = process.cwd();
+                                    }
+                                }
+                                await registryManager.registerProject(projectId, workspacePath, summary.description, summary.keywords, embeddingService, {
+                                    responsibilities: summary.responsibilities,
+                                    owns: summary.owns,
+                                    exports: summary.exports,
+                                    projectType: summary.projectType,
+                                });
+                                console.error(`  - Registry updated with project summary`);
+                                docsGenerated++;
+                            }
+                        }
+                        else {
+                            console.error(`  - Failed to generate documentation`);
+                            docsFailed++;
+                        }
+                    }
+                    else {
+                        console.error(`  - No chunks found for project, skipping`);
+                        docsSkipped++;
+                    }
+                }
+                else if (hasDocumentation) {
+                    console.error(`  - Documentation already exists, ensuring registry is up-to-date...`);
+                    // Documentation exists, regenerate/update registry from it (RECOVERY!)
+                    try {
+                        const summary = await projectKnowledgeService.generateProjectSummary(projectId);
+                        if (summary) {
+                            const existingProject = await registryManager.getProject(projectId);
+                            const workspacePath = existingProject?.path || process.cwd();
+                            await registryManager.registerProject(projectId, workspacePath, summary.description, summary.keywords, embeddingService, {
+                                responsibilities: summary.responsibilities,
+                                owns: summary.owns,
+                                exports: summary.exports,
+                                projectType: summary.projectType,
+                            });
+                            console.error(`  - Registry updated/recovered from documentation`);
+                            registryRecovered++;
+                        }
+                    }
+                    catch (error) {
+                        console.error(`  - Error recovering registry from docs: ${error}`);
+                    }
+                    docsSkipped++;
+                }
+                else {
+                    console.error(`  - No documentation and no indexed code, skipping`);
+                    docsSkipped++;
+                }
+            }
+            catch (error) {
+                console.error(`  - Error processing project ${projectId}: ${error}`);
+                docsFailed++;
+            }
+        }
+        console.error("\n=== Synchronization Complete ===");
+        console.error(`Projects discovered: ${allProjectIds.length} total`);
+        console.error(`  - From indexed code: ${indexedProjectIds.length}`);
+        console.error(`  - From documentation folders: ${documentedProjectIds.length}`);
+        console.error(`Registry synced: ${registryResult.processed} projects`);
+        console.error(`Registry recovered from docs: ${registryRecovered} projects`);
+        console.error(`Documentation generated: ${docsGenerated} projects`);
+        console.error(`Documentation skipped (already exists): ${docsSkipped} projects`);
+        console.error(`Failures: ${registryResult.failures + docsFailed}`);
         return {
             success: true,
-            message: `Synchronization complete. Processed: ${result.processed}, Failures: ${result.failures}`,
-            details: result
+            message: `Synchronization complete. Discovered ${allProjectIds.length} projects (${indexedProjectIds.length} indexed, ${documentedProjectIds.length} documented). Registry recovered: ${registryRecovered}, Docs generated: ${docsGenerated}, Failures: ${registryResult.failures + docsFailed}`,
+            details: {
+                discovery: {
+                    total: allProjectIds.length,
+                    indexed: indexedProjectIds.length,
+                    documented: documentedProjectIds.length,
+                    projects: allProjectIds
+                },
+                registrySync: registryResult,
+                registryRecovery: {
+                    recovered: registryRecovered
+                },
+                documentationGeneration: {
+                    generated: docsGenerated,
+                    skipped: docsSkipped,
+                    failed: docsFailed
+                }
+            }
         };
     }
     catch (error) {
@@ -26,7 +175,26 @@ export async function syncProjectsTool() {
 }
 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.",
+    description: `Sincroniza y recupera automáticamente todos los proyectos desde múltiples fuentes.
+    
+Esta herramienta realiza una sincronización completa con AUTO-RECUPERACIÓN:
+
+DESCUBRIMIENTO MULTI-FUENTE:
+1. Escanea carpetas de documentación (.memorybank/projects/*)
+2. Escanea código indexado en vector store
+3. Lee registry JSON existente (si existe)
+
+RECUPERACIÓN AUTOMÁTICA:
+- Si el registry.json se corrompe o vacía, lo reconstruye desde las carpetas de documentación
+- Genera documentación para código indexado sin docs
+- Actualiza registry con responsabilidades extraídas
+
+Útil cuando:
+- El registry.json se ha corrompido o vaciado (AUTO-RECUPERA desde carpetas!)
+- Has indexado código pero no has generado documentación
+- El registry está desactualizado o incompleto
+- Necesitas poblar las responsabilidades de proyectos para el orquestador
+- Has perdido proyectos del registry pero las carpetas siguen existiendo`,
     inputSchema: {
         type: "object",
         properties: {}

package/package.json

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