@grec0/memory-bank-mcp 0.1.0 → 0.1.2

package/README.md

@@ -40,12 +40,19 @@ Con Memory Bank, las IAs:
 - **🔒 Privacidad**: Vector store local, respeta .gitignore y .memoryignore
 - **🔀 Multi-Proyecto**: Consulta cualquier proyecto indexado usando su `projectId`
 
-### Project Knowledge Layer (Conocimiento Global) 🆕
+### Project Knowledge Layer (Conocimiento Global)
 - **📄 Documentación Automática**: Genera 6 documentos markdown estructurados del proyecto
 - **🧠 IA con Razonamiento**: Usa OpenAI Responses API con modelos de razonamiento (gpt-5-mini)
 - **🔄 Actualización Inteligente**: Solo regenera documentos afectados por cambios
 - **📚 Contexto Global**: Complementa búsqueda precisa con visión de alto nivel
 
+### Context Management (Gestión de Sesión) 🆕
+- **🚀 Inicialización Rápida**: Crea estructura de Memory Bank con plantillas iniciales (sin IA)
+- **📝 Tracking de Sesión**: Registra contexto activo, cambios recientes y próximos pasos
+- **📋 Log de Decisiones**: Documenta decisiones técnicas con rationale y alternativas
+- **📊 Seguimiento de Progreso**: Gestiona tareas, milestones y blockers
+- **📡 MCP Resources**: Acceso directo de solo lectura a documentos via URIs
+
 ## 📋 Requisitos
 
 - **Node.js** >= 18.0.0
@@ -446,6 +453,153 @@ Lee la documentación del proyecto generada por IA.
 
 ---
 
+## 🔄 Herramientas de Gestión de Contexto (Cline-style)
+
+Estas herramientas permiten gestionar el contexto del proyecto de forma manual, complementando la generación automática con IA.
+
+### `memorybank_initialize`
+
+Inicializa el Memory Bank para un proyecto nuevo. Crea la estructura de directorios y 7 documentos markdown con plantillas iniciales. **No usa IA**.
+
+**Parámetros:**
+- `projectId` **(REQUERIDO)**: Identificador único del proyecto
+- `projectPath` **(REQUERIDO)**: Ruta absoluta del proyecto
+- `projectName` (opcional): Nombre legible del proyecto
+- `description` (opcional): Descripción inicial del proyecto
+
+**Ejemplo:**
+```json
+{
+  "projectId": "my-project",
+  "projectPath": "C:/workspaces/my-project",
+  "projectName": "My Awesome Project",
+  "description": "A web application for..."
+}
+```
+
+**Documentos creados:**
+- `projectBrief.md` - Descripción general
+- `productContext.md` - Contexto de producto
+- `systemPatterns.md` - Patrones de arquitectura
+- `techContext.md` - Stack tecnológico
+- `activeContext.md` - Contexto de sesión
+- `progress.md` - Seguimiento de progreso
+- `decisionLog.md` - Log de decisiones
+
+### `memorybank_update_context`
+
+Actualiza el contexto activo con información de la sesión actual. Mantiene historial de las últimas 10 sesiones. **No usa IA**.
+
+**Parámetros:**
+- `projectId` **(REQUERIDO)**: Identificador del proyecto
+- `currentSession` (opcional): Información de sesión (date, mode, task)
+- `recentChanges` (opcional): Lista de cambios recientes
+- `openQuestions` (opcional): Preguntas pendientes
+- `nextSteps` (opcional): Próximos pasos planificados
+- `notes` (opcional): Notas adicionales
+
+**Ejemplo:**
+```json
+{
+  "projectId": "my-project",
+  "currentSession": {
+    "mode": "development",
+    "task": "Implementing authentication"
+  },
+  "recentChanges": ["Added JWT middleware", "Created user model"],
+  "nextSteps": ["Add refresh token", "Create login endpoint"]
+}
+```
+
+### `memorybank_record_decision`
+
+Registra decisiones técnicas con rationale en el log de decisiones. **No usa IA**.
+
+**Parámetros:**
+- `projectId` **(REQUERIDO)**: Identificador del proyecto
+- `decision` **(REQUERIDO)**: Objeto con información de la decisión
+  - `title` **(REQUERIDO)**: Título de la decisión
+  - `description` **(REQUERIDO)**: Qué se decidió
+  - `rationale` **(REQUERIDO)**: Por qué se tomó esta decisión
+  - `alternatives` (opcional): Alternativas consideradas
+  - `impact` (opcional): Impacto esperado
+  - `category` (opcional): architecture, technology, dependencies, etc.
+
+**Ejemplo:**
+```json
+{
+  "projectId": "my-project",
+  "decision": {
+    "title": "JWT Authentication",
+    "description": "Use JWT tokens for API authentication",
+    "rationale": "Stateless, scalable, works well with microservices",
+    "alternatives": ["Session-based auth", "OAuth only"],
+    "category": "architecture"
+  }
+}
+```
+
+### `memorybank_track_progress`
+
+Actualiza el seguimiento de progreso con tareas, milestones y blockers. **No usa IA**.
+
+**Parámetros:**
+- `projectId` **(REQUERIDO)**: Identificador del proyecto
+- `progress` (opcional): Tareas a actualizar
+  - `completed`: Tareas completadas
+  - `inProgress`: Tareas en progreso
+  - `blocked`: Tareas bloqueadas
+  - `upcoming`: Próximas tareas
+- `milestone` (opcional): Milestone a añadir/actualizar (name, status, targetDate, notes)
+- `blockers` (opcional): Lista de blockers con severidad (low/medium/high)
+- `phase` (opcional): Fase actual del proyecto
+- `phaseStatus` (opcional): Estado de la fase
+
+**Ejemplo:**
+```json
+{
+  "projectId": "my-project",
+  "progress": {
+    "completed": ["Setup project structure", "Configure ESLint"],
+    "inProgress": ["Implement user authentication"],
+    "upcoming": ["Add unit tests"]
+  },
+  "milestone": {
+    "name": "MVP",
+    "status": "in_progress",
+    "targetDate": "2026-02-01"
+  }
+}
+```
+
+---
+
+## 📡 MCP Resources (Acceso Directo)
+
+Memory Bank expone recursos MCP para acceso directo de solo lectura a los documentos del proyecto.
+
+| Resource URI | Contenido |
+|--------------|-----------|
+| `memory://{projectId}/active` | Contexto activo de sesión |
+| `memory://{projectId}/progress` | Seguimiento de progreso |
+| `memory://{projectId}/decisions` | Log de decisiones técnicas |
+| `memory://{projectId}/context` | Contexto del proyecto (brief + tech) |
+| `memory://{projectId}/patterns` | Patrones de sistema |
+| `memory://{projectId}/brief` | Descripción del proyecto |
+
+**Ejemplo de uso:**
+```
+// Acceder al contexto activo del proyecto "my-project"
+memory://my-project/active
+
+// Acceder al log de decisiones
+memory://my-project/decisions
+```
+
+Los recursos son de solo lectura. Para modificar documentos, usa las herramientas correspondientes (`memorybank_update_context`, `memorybank_record_decision`, etc.).
+
+---
+
 ## 📋 Plantillas de Instrucciones para Agentes
 
 Memory Bank incluye plantillas de instrucciones en dos formatos para configurar el comportamiento del agente:
@@ -805,10 +959,41 @@ Si `pendingFiles` muestra archivos pendientes:
 
 ## 🎓 Inspiración
 
-Este proyecto está inspirado en el sistema de Memory Bank de Cursor IDE, tal como se describe en:
+Este proyecto combina los mejores conceptos de dos enfoques complementarios:
+
+### Cursor IDE - Indexación Semántica
+
+El sistema de indexación vectorial y búsqueda semántica está inspirado en cómo Cursor IDE maneja la memoria de código:
+
+- [Advanced Cursor: Use the Memory Bank](https://medium.com/codetodeploy/advanced-cursor-use-the-memory-bank-to-eliminate-hallucination-affd3fbeefa3) - Eliminar alucinaciones con memoria persistente
+- [How Cursor Indexes Codebases Fast](https://read.engineerscodex.com/p/how-cursor-indexes-codebases-fast) - Técnicas de indexación eficiente
+
+### Cline - Documentación Estructurada del Proyecto
+
+El sistema de **Project Knowledge Layer** (documentos markdown estructurados) está inspirado en el enfoque de Cline Memory Bank:
+
+- [Cline MCP Memory Bank](https://github.com/dazeb/cline-mcp-memory-bank) - Implementación de referencia del Memory Bank para Cline
+- [Cline Memory Bank Custom Instructions](https://gist.github.com/zoharbabin/441e8e8b719a444f26b34bd0b189b283) - Instrucciones personalizadas para usar el Memory Bank
+
+**Documentos del enfoque Cline que adoptamos:**
+| Documento | Propósito |
+|-----------|-----------|
+| `projectBrief.md` | Requisitos y alcance del proyecto |
+| `productContext.md` | Propósito, usuarios objetivo, problemas que resuelve |
+| `activeContext.md` | Tareas actuales, cambios recientes, próximos pasos |
+| `systemPatterns.md` | Decisiones arquitectónicas, patrones, relaciones |
+| `techContext.md` | Stack tecnológico, dependencias, configuraciones |
+| `progress.md` | Hitos, estado general, problemas conocidos |
+
+### Nuestra Contribución
+
+Memory Bank MCP **fusiona ambos enfoques**:
+
+1. **Búsqueda Semántica** (estilo Cursor): Embeddings vectoriales + LanceDB para encontrar código relevante instantáneamente
+2. **Documentación Estructurada** (estilo Cline): 6 documentos markdown generados con IA que proporcionan contexto global
+3. **Multi-Proyecto**: Capacidad única de consultar múltiples proyectos indexados desde cualquier workspace
 
-- [Advanced Cursor: Use the Memory Bank](https://medium.com/codetodeploy/advanced-cursor-use-the-memory-bank-to-eliminate-hallucination-affd3fbeefa3)
-- [How Cursor Indexes Codebases Fast](https://read.engineerscodex.com/p/how-cursor-indexes-codebases-fast)
+Esta combinación permite que los agentes tengan tanto **precisión** (búsqueda semántica) como **comprensión global** (documentación estructurada)
 
 ---
 

package/dist/common/projectKnowledgeService.js

@@ -607,6 +607,80 @@ ${chunk.content}
             documents: documents,
         };
     }
+    // ==========================================
+    // 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
+     */
+    isProjectInitialized(projectId) {
+        const docsPath = this.getProjectDocsPath(projectId);
+        return fs.existsSync(docsPath);
+    }
+    /**
+     * Reads a specific document for a project (for MCP Resources)
+     */
+    getProjectDocument(projectId, docName) {
+        const docsPath = this.getProjectDocsPath(projectId);
+        // Map document names to filenames
+        const docMap = {
+            "projectBrief": "projectBrief.md",
+            "productContext": "productContext.md",
+            "systemPatterns": "systemPatterns.md",
+            "techContext": "techContext.md",
+            "activeContext": "activeContext.md",
+            "progress": "progress.md",
+            "decisionLog": "decisionLog.md",
+            "decisions": "decisionLog.md", // Alias
+            "active": "activeContext.md", // Alias
+            "context": "projectBrief.md", // Alias - returns project brief
+            "patterns": "systemPatterns.md", // Alias
+            "brief": "projectBrief.md", // Alias
+            "tech": "techContext.md", // Alias
+            "product": "productContext.md", // Alias
+        };
+        const filename = docMap[docName] || `${docName}.md`;
+        const filePath = path.join(docsPath, filename);
+        if (!fs.existsSync(filePath)) {
+            return null;
+        }
+        return fs.readFileSync(filePath, "utf-8");
+    }
+    /**
+     * Gets combined project context (projectBrief + techContext)
+     */
+    getProjectContext(projectId) {
+        const brief = this.getProjectDocument(projectId, "projectBrief");
+        const tech = this.getProjectDocument(projectId, "techContext");
+        if (!brief && !tech)
+            return null;
+        let content = "# Project Context\n\n";
+        if (brief) {
+            content += brief + "\n\n---\n\n";
+        }
+        if (tech) {
+            content += tech;
+        }
+        return content;
+    }
+    /**
+     * Lists all available documents for a project
+     */
+    listProjectDocuments(projectId) {
+        const docsPath = this.getProjectDocsPath(projectId);
+        if (!fs.existsSync(docsPath)) {
+            return [];
+        }
+        const files = fs.readdirSync(docsPath);
+        return files.filter(f => f.endsWith(".md"));
+    }
 }
 /**
  * Creates a Project Knowledge Service from environment variables

package/dist/index.js

@@ -20,6 +20,11 @@ import { getStats } from "./tools/getStats.js";
 import { analyzeCoverage } from "./tools/analyzeCoverage.js";
 import { generateProjectDocs, generateProjectDocsToolDefinition } from "./tools/generateProjectDocs.js";
 import { getProjectDocs, getProjectDocsToolDefinition } from "./tools/getProjectDocs.js";
+// Import new context management tools
+import { initializeMemoryBank, initializeMemoryBankToolDefinition } from "./tools/initializeMemoryBank.js";
+import { updateContext, updateContextToolDefinition } from "./tools/updateContext.js";
+import { recordDecision, recordDecisionToolDefinition } from "./tools/recordDecision.js";
+import { trackProgress, trackProgressToolDefinition } from "./tools/trackProgress.js";
 import { VERSION } from "./common/version.js";
 // Global services
 let embeddingService;
@@ -252,6 +257,341 @@ server.tool(getProjectDocsToolDefinition.name, getProjectDocsToolDefinition.desc
         content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
     };
 });
+// ==========================================
+// Context Management Tools (Cline-style)
+// ==========================================
+// Tool: Initialize Memory Bank
+server.tool(initializeMemoryBankToolDefinition.name, initializeMemoryBankToolDefinition.description, {
+    projectId: z
+        .string()
+        .describe("Identificador único del proyecto (OBLIGATORIO)"),
+    projectPath: z
+        .string()
+        .describe("Ruta absoluta del proyecto"),
+    projectName: z
+        .string()
+        .optional()
+        .describe("Nombre legible del proyecto (opcional)"),
+    description: z
+        .string()
+        .optional()
+        .describe("Descripción inicial del proyecto (opcional)"),
+}, async (args) => {
+    const storagePath = process.env.MEMORYBANK_STORAGE_PATH || ".memorybank";
+    const result = await initializeMemoryBank({
+        projectId: args.projectId,
+        projectPath: args.projectPath,
+        projectName: args.projectName,
+        description: args.description,
+    }, storagePath);
+    return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+    };
+});
+// Tool: Update Context
+server.tool(updateContextToolDefinition.name, updateContextToolDefinition.description, {
+    projectId: z
+        .string()
+        .describe("Identificador único del proyecto (OBLIGATORIO)"),
+    currentSession: z
+        .object({
+        date: z.string().optional().describe("Fecha de la sesión (YYYY-MM-DD)"),
+        mode: z.string().optional().describe("Modo de trabajo: development, debugging, refactoring, etc."),
+        task: z.string().optional().describe("Descripción de la tarea actual"),
+    })
+        .optional()
+        .describe("Información de la sesión actual"),
+    recentChanges: z
+        .array(z.string())
+        .optional()
+        .describe("Lista de cambios recientes realizados"),
+    openQuestions: z
+        .array(z.string())
+        .optional()
+        .describe("Preguntas pendientes de resolver"),
+    nextSteps: z
+        .array(z.string())
+        .optional()
+        .describe("Próximos pasos planificados"),
+    notes: z
+        .string()
+        .optional()
+        .describe("Notas adicionales o consideraciones"),
+}, async (args) => {
+    const storagePath = process.env.MEMORYBANK_STORAGE_PATH || ".memorybank";
+    const result = await updateContext({
+        projectId: args.projectId,
+        currentSession: args.currentSession,
+        recentChanges: args.recentChanges,
+        openQuestions: args.openQuestions,
+        nextSteps: args.nextSteps,
+        notes: args.notes,
+    }, storagePath);
+    return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+    };
+});
+// Tool: Record Decision
+server.tool(recordDecisionToolDefinition.name, recordDecisionToolDefinition.description, {
+    projectId: z
+        .string()
+        .describe("Identificador único del proyecto (OBLIGATORIO)"),
+    decision: z
+        .object({
+        title: z.string().describe("Título corto y descriptivo de la decisión"),
+        description: z.string().describe("Descripción detallada de lo que se decidió"),
+        rationale: z.string().describe("Por qué se tomó esta decisión"),
+        alternatives: z.array(z.string()).optional().describe("Alternativas consideradas"),
+        impact: z.string().optional().describe("Impacto esperado de la decisión"),
+        category: z.string().optional().describe("Categoría: architecture, technology, dependencies, etc."),
+        date: z.string().optional().describe("Fecha de la decisión (YYYY-MM-DD)"),
+    })
+        .describe("Información de la decisión a registrar"),
+}, async (args) => {
+    const storagePath = process.env.MEMORYBANK_STORAGE_PATH || ".memorybank";
+    const result = await recordDecision({
+        projectId: args.projectId,
+        decision: args.decision,
+    }, storagePath);
+    return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+    };
+});
+// Tool: Track Progress
+server.tool(trackProgressToolDefinition.name, trackProgressToolDefinition.description, {
+    projectId: z
+        .string()
+        .describe("Identificador único del proyecto (OBLIGATORIO)"),
+    progress: z
+        .object({
+        completed: z.array(z.string()).optional().describe("Tareas completadas"),
+        inProgress: z.array(z.string()).optional().describe("Tareas en progreso"),
+        blocked: z.array(z.string()).optional().describe("Tareas bloqueadas"),
+        upcoming: z.array(z.string()).optional().describe("Próximas tareas"),
+    })
+        .optional()
+        .describe("Tareas a actualizar"),
+    milestone: z
+        .object({
+        name: z.string().describe("Nombre del milestone"),
+        status: z.enum(["pending", "in_progress", "completed"]).describe("Estado del milestone"),
+        targetDate: z.string().optional().describe("Fecha objetivo"),
+        notes: z.string().optional().describe("Notas adicionales"),
+    })
+        .optional()
+        .describe("Milestone a añadir o actualizar"),
+    blockers: z
+        .array(z.object({
+        description: z.string().describe("Descripción del blocker"),
+        severity: z.enum(["low", "medium", "high"]).describe("Severidad"),
+    }))
+        .optional()
+        .describe("Blockers a registrar"),
+    phase: z
+        .string()
+        .optional()
+        .describe("Fase actual del proyecto"),
+    phaseStatus: z
+        .string()
+        .optional()
+        .describe("Estado de la fase"),
+}, async (args) => {
+    const storagePath = process.env.MEMORYBANK_STORAGE_PATH || ".memorybank";
+    const result = await trackProgress({
+        projectId: args.projectId,
+        progress: args.progress,
+        milestone: args.milestone,
+        blockers: args.blockers,
+        phase: args.phase,
+        phaseStatus: args.phaseStatus,
+    }, storagePath);
+    return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+    };
+});
+// ==========================================
+// MCP Resources (Direct document access)
+// ==========================================
+// Resource: Project Active Context
+server.resource("memory://*/active", "Contexto activo del proyecto: sesión actual, cambios recientes, próximos pasos", async (uri) => {
+    const projectId = uri.pathname.split("/")[0] || uri.host;
+    if (!projectKnowledgeService) {
+        return {
+            contents: [{
+                    uri: uri.href,
+                    mimeType: "text/plain",
+                    text: "Error: Project Knowledge Service not initialized",
+                }],
+        };
+    }
+    const content = projectKnowledgeService.getProjectDocument(projectId, "activeContext");
+    if (!content) {
+        return {
+            contents: [{
+                    uri: uri.href,
+                    mimeType: "text/plain",
+                    text: `No active context found for project "${projectId}". Run memorybank_initialize first.`,
+                }],
+        };
+    }
+    return {
+        contents: [{
+                uri: uri.href,
+                mimeType: "text/markdown",
+                text: content,
+            }],
+    };
+});
+// Resource: Project Progress
+server.resource("memory://*/progress", "Seguimiento de progreso: tareas completadas, en progreso, bloqueadas y milestones", async (uri) => {
+    const projectId = uri.pathname.split("/")[0] || uri.host;
+    if (!projectKnowledgeService) {
+        return {
+            contents: [{
+                    uri: uri.href,
+                    mimeType: "text/plain",
+                    text: "Error: Project Knowledge Service not initialized",
+                }],
+        };
+    }
+    const content = projectKnowledgeService.getProjectDocument(projectId, "progress");
+    if (!content) {
+        return {
+            contents: [{
+                    uri: uri.href,
+                    mimeType: "text/plain",
+                    text: `No progress tracking found for project "${projectId}". Run memorybank_initialize first.`,
+                }],
+        };
+    }
+    return {
+        contents: [{
+                uri: uri.href,
+                mimeType: "text/markdown",
+                text: content,
+            }],
+    };
+});
+// Resource: Project Decisions
+server.resource("memory://*/decisions", "Log de decisiones técnicas: historial de decisiones arquitectónicas y técnicas", async (uri) => {
+    const projectId = uri.pathname.split("/")[0] || uri.host;
+    if (!projectKnowledgeService) {
+        return {
+            contents: [{
+                    uri: uri.href,
+                    mimeType: "text/plain",
+                    text: "Error: Project Knowledge Service not initialized",
+                }],
+        };
+    }
+    const content = projectKnowledgeService.getProjectDocument(projectId, "decisionLog");
+    if (!content) {
+        return {
+            contents: [{
+                    uri: uri.href,
+                    mimeType: "text/plain",
+                    text: `No decision log found for project "${projectId}". Run memorybank_initialize first.`,
+                }],
+        };
+    }
+    return {
+        contents: [{
+                uri: uri.href,
+                mimeType: "text/markdown",
+                text: content,
+            }],
+    };
+});
+// Resource: Project Context (Brief + Tech)
+server.resource("memory://*/context", "Contexto completo del proyecto: descripción general y stack tecnológico", async (uri) => {
+    const projectId = uri.pathname.split("/")[0] || uri.host;
+    if (!projectKnowledgeService) {
+        return {
+            contents: [{
+                    uri: uri.href,
+                    mimeType: "text/plain",
+                    text: "Error: Project Knowledge Service not initialized",
+                }],
+        };
+    }
+    const content = projectKnowledgeService.getProjectContext(projectId);
+    if (!content) {
+        return {
+            contents: [{
+                    uri: uri.href,
+                    mimeType: "text/plain",
+                    text: `No project context found for project "${projectId}". Run memorybank_initialize first.`,
+                }],
+        };
+    }
+    return {
+        contents: [{
+                uri: uri.href,
+                mimeType: "text/markdown",
+                text: content,
+            }],
+    };
+});
+// Resource: System Patterns
+server.resource("memory://*/patterns", "Patrones de sistema: arquitectura, patrones de diseño y organización del código", async (uri) => {
+    const projectId = uri.pathname.split("/")[0] || uri.host;
+    if (!projectKnowledgeService) {
+        return {
+            contents: [{
+                    uri: uri.href,
+                    mimeType: "text/plain",
+                    text: "Error: Project Knowledge Service not initialized",
+                }],
+        };
+    }
+    const content = projectKnowledgeService.getProjectDocument(projectId, "systemPatterns");
+    if (!content) {
+        return {
+            contents: [{
+                    uri: uri.href,
+                    mimeType: "text/plain",
+                    text: `No system patterns found for project "${projectId}". Run memorybank_initialize or memorybank_generate_project_docs first.`,
+                }],
+        };
+    }
+    return {
+        contents: [{
+                uri: uri.href,
+                mimeType: "text/markdown",
+                text: content,
+            }],
+    };
+});
+// Resource: Project Brief
+server.resource("memory://*/brief", "Descripción del proyecto: propósito, objetivos y audiencia", async (uri) => {
+    const projectId = uri.pathname.split("/")[0] || uri.host;
+    if (!projectKnowledgeService) {
+        return {
+            contents: [{
+                    uri: uri.href,
+                    mimeType: "text/plain",
+                    text: "Error: Project Knowledge Service not initialized",
+                }],
+        };
+    }
+    const content = projectKnowledgeService.getProjectDocument(projectId, "projectBrief");
+    if (!content) {
+        return {
+            contents: [{
+                    uri: uri.href,
+                    mimeType: "text/plain",
+                    text: `No project brief found for project "${projectId}". Run memorybank_initialize or memorybank_generate_project_docs first.`,
+                }],
+        };
+    }
+    return {
+        contents: [{
+                uri: uri.href,
+                mimeType: "text/markdown",
+                text: content,
+            }],
+    };
+});
 /**
  * Validates and initializes environment
  */
@@ -328,16 +668,29 @@ async function startStdioServer() {
         await server.connect(transport);
         console.error("\n=== MCP Server Ready ===");
         console.error("Available tools:");
-        console.error("  Core Memory Bank:");
+        console.error("  Core Memory Bank (Cursor-style):");
         console.error("    - memorybank_index_code: Indexar código semánticamente");
         console.error("    - memorybank_search: Buscar código por similitud semántica");
         console.error("    - memorybank_read_file: Leer archivos del workspace");
         console.error("    - memorybank_write_file: Escribir archivos y reindexar");
         console.error("    - memorybank_get_stats: Obtener estadísticas del índice");
         console.error("    - memorybank_analyze_coverage: Analizar cobertura de indexación");
-        console.error("  Project Knowledge Layer:");
+        console.error("  Project Knowledge Layer (AI Docs):");
         console.error("    - memorybank_generate_project_docs: Generar documentación con IA");
         console.error("    - memorybank_get_project_docs: Leer documentación del proyecto");
+        console.error("  Context Management (Cline-style):");
+        console.error("    - memorybank_initialize: Inicializar Memory Bank para un proyecto");
+        console.error("    - memorybank_update_context: Actualizar contexto de sesión");
+        console.error("    - memorybank_record_decision: Registrar decisiones técnicas");
+        console.error("    - memorybank_track_progress: Actualizar progreso del proyecto");
+        console.error("");
+        console.error("Available resources:");
+        console.error("    - memory://{projectId}/active: Contexto activo");
+        console.error("    - memory://{projectId}/progress: Seguimiento de progreso");
+        console.error("    - memory://{projectId}/decisions: Log de decisiones");
+        console.error("    - memory://{projectId}/context: Contexto del proyecto");
+        console.error("    - memory://{projectId}/patterns: Patrones de sistema");
+        console.error("    - memory://{projectId}/brief: Descripción del proyecto");
         console.error("");
         console.error("Ready to accept requests...\n");
     }