@grec0/memory-bank-mcp 0.0.3 → 0.0.4

package/dist/common/utils.js

@@ -0,0 +1,215 @@
+import { getUserAgent } from "universal-user-agent";
+import { createPlankaError } from "./errors.js";
+import { VERSION } from "./version.js";
+import https from "https";
+import nodeFetch from "node-fetch";
+// Global variables to store tokens
+let agentToken = null;
+// Create HTTPS agent for insecure connections if needed
+let httpsAgent;
+if (process.env.PLANKA_ALLOW_INSECURE === "true") {
+    console.error("[DEBUG] Allowing insecure HTTPS connections (certificate validation disabled)");
+    httpsAgent = new https.Agent({
+        rejectUnauthorized: false,
+    });
+}
+// Custom fetch function that uses the agent
+const customFetch = httpsAgent
+    ? (url, options) => {
+        return nodeFetch(url, { ...options, agent: httpsAgent });
+    }
+    : fetch;
+async function parseResponseBody(response) {
+    const contentType = response.headers.get("content-type");
+    if (contentType?.includes("application/json")) {
+        return response.json();
+    }
+    return response.text();
+}
+export function buildUrl(baseUrl, params) {
+    const url = new URL(baseUrl);
+    Object.entries(params).forEach(([key, value]) => {
+        if (value !== undefined) {
+            url.searchParams.append(key, value.toString());
+        }
+    });
+    return url.toString();
+}
+const USER_AGENT = `modelcontextprotocol/servers/planka/v${VERSION} ${getUserAgent()}`;
+async function authenticateAgent() {
+    const email = process.env.PLANKA_AGENT_EMAIL;
+    const password = process.env.PLANKA_AGENT_PASSWORD;
+    console.error(`[DEBUG] Attempting authentication with email: ${email}`);
+    if (!email || !password) {
+        throw new Error("PLANKA_AGENT_EMAIL and PLANKA_AGENT_PASSWORD environment variables are required");
+    }
+    const baseUrl = process.env.PLANKA_BASE_URL || "http://localhost:3000";
+    // Construir la URL correctamente para el endpoint de tokens
+    const url = baseUrl.endsWith('/')
+        ? `${baseUrl}api/access-tokens`
+        : `${baseUrl}/api/access-tokens`;
+    console.error(`[DEBUG] Authentication URL: ${url}`);
+    console.error(`[DEBUG] Base URL: ${baseUrl}`);
+    try {
+        const requestBody = JSON.stringify({
+            emailOrUsername: email,
+            password: password,
+        });
+        console.error(`[DEBUG] Request body: ${requestBody}`);
+        const response = await customFetch(url, {
+            method: "POST",
+            headers: {
+                "Accept": "application/json",
+                "Content-Type": "application/json",
+                "User-Agent": USER_AGENT,
+            },
+            body: requestBody,
+            credentials: "include",
+        });
+        console.error(`[DEBUG] Response status: ${response.status}`);
+        console.error(`[DEBUG] Response headers:`, Object.fromEntries(response.headers.entries()));
+        const responseBody = await parseResponseBody(response);
+        console.error(`[DEBUG] Response body:`, responseBody);
+        if (!response.ok) {
+            throw createPlankaError(response.status, responseBody);
+        }
+        // The token is directly in the item field
+        const { item } = responseBody;
+        agentToken = item;
+        console.error(`[DEBUG] Authentication successful, token length: ${item?.length}`);
+        return item;
+    }
+    catch (error) {
+        console.error(`[DEBUG] Authentication error:`, error);
+        // Rethrow with more context
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        throw new Error(`Failed to authenticate agent with Planka: ${errorMessage}`);
+    }
+}
+async function getAuthToken() {
+    if (agentToken) {
+        return agentToken;
+    }
+    return authenticateAgent();
+}
+export async function plankaRequest(path, options = {}) {
+    const baseUrl = process.env.PLANKA_BASE_URL || "http://localhost:3000";
+    // Ensure path starts with /api/ if not already present
+    const normalizedPath = path.startsWith("/api/") ? path : `/api/${path}`;
+    // Construir la URL correctamente
+    const url = baseUrl.endsWith('/')
+        ? `${baseUrl}${normalizedPath.substring(1)}` // Remove leading slash if baseUrl ends with /
+        : `${baseUrl}${normalizedPath}`;
+    const headers = {
+        "Accept": "application/json",
+        "Content-Type": "application/json",
+        "User-Agent": USER_AGENT,
+        ...options.headers,
+    };
+    // Remove Content-Type header for FormData
+    if (options.body instanceof FormData) {
+        delete headers["Content-Type"];
+    }
+    // Add authentication token if not skipped
+    if (!options.skipAuth) {
+        try {
+            const token = await getAuthToken();
+            headers["Authorization"] = `Bearer ${token}`;
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error
+                ? error.message
+                : String(error);
+            throw new Error(`Failed to get authentication token: ${errorMessage}`);
+        }
+    }
+    try {
+        const response = await customFetch(url, {
+            method: options.method || "GET",
+            headers,
+            body: options.body instanceof FormData
+                ? options.body
+                : options.body
+                    ? JSON.stringify(options.body)
+                    : undefined,
+            credentials: "include", // Include cookies for Planka authentication
+        });
+        const responseBody = await parseResponseBody(response);
+        if (!response.ok) {
+            throw createPlankaError(response.status, responseBody);
+        }
+        return responseBody;
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        throw new Error(`Failed to make Planka request to ${url}: ${errorMessage}`);
+    }
+}
+export function validateProjectName(name) {
+    const sanitized = name.trim();
+    if (!sanitized) {
+        throw new Error("Project name cannot be empty");
+    }
+    return sanitized;
+}
+export function validateBoardName(name) {
+    const sanitized = name.trim();
+    if (!sanitized) {
+        throw new Error("Board name cannot be empty");
+    }
+    return sanitized;
+}
+export function validateListName(name) {
+    const sanitized = name.trim();
+    if (!sanitized) {
+        throw new Error("List name cannot be empty");
+    }
+    return sanitized;
+}
+export function validateCardName(name) {
+    const sanitized = name.trim();
+    if (!sanitized) {
+        throw new Error("Card name cannot be empty");
+    }
+    return sanitized;
+}
+/**
+ * Looks up a user ID by email
+ *
+ * @param {string} email - The email of the user to look up
+ * @returns {Promise<string | null>} The user ID if found, null otherwise
+ */
+export async function getUserIdByEmail(email) {
+    try {
+        // Get all users
+        const response = await plankaRequest("/api/users");
+        const { items } = response;
+        // Find the user with the matching email
+        const user = items.find((user) => user.email === email);
+        return user ? user.id : null;
+    }
+    catch (error) {
+        console.error(`Failed to get user ID by email: ${error instanceof Error ? error.message : String(error)}`);
+        return null;
+    }
+}
+/**
+ * Looks up a user ID by username
+ *
+ * @param {string} username - The username of the user to look up
+ * @returns {Promise<string | null>} The user ID if found, null otherwise
+ */
+export async function getUserIdByUsername(username) {
+    try {
+        // Get all users
+        const response = await plankaRequest("/api/users");
+        const { items } = response;
+        // Find the user with the matching username
+        const user = items.find((user) => user.username === username);
+        return user ? user.id : null;
+    }
+    catch (error) {
+        console.error(`Failed to get user ID by username: ${error instanceof Error ? error.message : String(error)}`);
+        return null;
+    }
+}

package/dist/common/vectorStore.js

@@ -1,6 +1,7 @@
 /**
  * @fileoverview Vector store for Memory Bank using LanceDB
  * Manages storage and retrieval of code embeddings
+ * Uses snake_case for field names for LanceDB SQL compatibility
  */
 import * as lancedb from "@lancedb/lancedb";
 import * as fs from "fs";
@@ -122,16 +123,17 @@ export class VectorStore {
         }
     }
     /**
-     * Deletes all chunks from a specific file in a specific project
+     * Deletes all chunks from a specific file
      */
-    async deleteChunksByFile(filePath, projectId) {
+    async deleteChunksByFile(filePath) {
         await this.ensureInitialized();
         if (!this.table) {
             return;
         }
         try {
-            await this.table.delete(`"filePath" = '${filePath}' AND "projectId" = '${projectId}'`);
-            console.error(`Deleted all chunks from file: ${filePath} (project: ${projectId.substring(0, 8)}...)`);
+            // Use snake_case field name for LanceDB SQL compatibility
+            await this.table.delete(`file_path = '${filePath}'`);
+            console.error(`Deleted all chunks from file: ${filePath}`);
         }
         catch (error) {
             console.error(`Error deleting chunks by file: ${error}`);
@@ -152,15 +154,18 @@ export class VectorStore {
         try {
             // Start with vector search
             let query = this.table.search(queryVector).limit(topK);
-            // Apply filters if specified
+            // Apply filters if specified (using snake_case field names)
             if (options.filterByFile) {
-                query = query.where(`filePath LIKE '%${options.filterByFile}%'`);
+                query = query.where(`file_path LIKE '%${options.filterByFile}%'`);
             }
             if (options.filterByLanguage) {
                 query = query.where(`language = '${options.filterByLanguage}'`);
             }
             if (options.filterByType) {
-                query = query.where(`chunkType = '${options.filterByType}'`);
+                query = query.where(`chunk_type = '${options.filterByType}'`);
+            }
+            if (options.filterByProject) {
+                query = query.where(`project_id = '${options.filterByProject}'`);
             }
             // Execute search
             const results = await query.toArray();
@@ -174,17 +179,17 @@ export class VectorStore {
                     chunk: {
                         id: result.id,
                         vector: result.vector,
-                        filePath: result.filePath,
+                        file_path: result.file_path,
                         content: result.content,
-                        startLine: result.startLine,
-                        endLine: result.endLine,
-                        chunkType: result.chunkType,
+                        start_line: result.start_line,
+                        end_line: result.end_line,
+                        chunk_type: result.chunk_type,
                         name: result.name,
                         language: result.language,
-                        fileHash: result.fileHash,
+                        file_hash: result.file_hash,
                         timestamp: result.timestamp,
                         context: result.context,
-                        projectId: result.projectId,
+                        project_id: result.project_id,
                     },
                     score,
                     distance,
@@ -208,22 +213,23 @@ export class VectorStore {
         }
         try {
             const results = await this.table
-                .where(`filePath = '${filePath}'`)
+                .query()
+                .where(`file_path = '${filePath}'`)
                 .toArray();
             return results.map((r) => ({
                 id: r.id,
                 vector: r.vector,
-                filePath: r.filePath,
+                file_path: r.file_path,
                 content: r.content,
-                startLine: r.startLine,
-                endLine: r.endLine,
-                chunkType: r.chunkType,
+                start_line: r.start_line,
+                end_line: r.end_line,
+                chunk_type: r.chunk_type,
                 name: r.name,
                 language: r.language,
-                fileHash: r.fileHash,
+                file_hash: r.file_hash,
                 timestamp: r.timestamp,
                 context: r.context,
-                projectId: r.projectId,
+                project_id: r.project_id,
             }));
         }
         catch (error) {
@@ -231,6 +237,56 @@ export class VectorStore {
             return [];
         }
     }
+    /**
+     * Gets all chunks, optionally filtered by project
+     */
+    async getAllChunks(projectId) {
+        await this.ensureInitialized();
+        if (!this.table) {
+            console.error("getAllChunks: No table exists");
+            return [];
+        }
+        try {
+            let query = this.table.query();
+            // Apply project filter using snake_case field name
+            if (projectId) {
+                query = query.where(`project_id = '${projectId}'`);
+                console.error(`getAllChunks: Filtering by project_id='${projectId}'`);
+            }
+            const results = await query.toArray();
+            console.error(`getAllChunks: Got ${results.length} results`);
+            // Debug: Check first result's content
+            if (results.length > 0) {
+                const first = results[0];
+                console.error(`getAllChunks: First result file_path=${first.file_path}, content length=${first.content?.length || 0}`);
+            }
+            return results.map((r) => ({
+                id: r.id,
+                vector: r.vector,
+                file_path: r.file_path,
+                content: r.content,
+                start_line: r.start_line,
+                end_line: r.end_line,
+                chunk_type: r.chunk_type,
+                name: r.name,
+                language: r.language,
+                file_hash: r.file_hash,
+                timestamp: r.timestamp,
+                context: r.context,
+                project_id: r.project_id,
+            }));
+        }
+        catch (error) {
+            console.error(`Error getting all chunks: ${error}`);
+            return [];
+        }
+    }
+    /**
+     * Gets chunks by project ID
+     */
+    async getChunksByProject(projectId) {
+        return this.getAllChunks(projectId);
+    }
     /**
      * Gets statistics about the vector store
      */
@@ -245,16 +301,15 @@ export class VectorStore {
             };
         }
         try {
-            // Use query().toArray() instead of direct toArray()
             const allChunks = await this.table.query().toArray();
             const uniqueFiles = new Set();
             const languageCounts = {};
             const typeCounts = {};
             let latestTimestamp = 0;
             for (const chunk of allChunks) {
-                uniqueFiles.add(chunk.filePath);
+                uniqueFiles.add(chunk.file_path);
                 languageCounts[chunk.language] = (languageCounts[chunk.language] || 0) + 1;
-                typeCounts[chunk.chunkType] = (typeCounts[chunk.chunkType] || 0) + 1;
+                typeCounts[chunk.chunk_type] = (typeCounts[chunk.chunk_type] || 0) + 1;
                 if (chunk.timestamp > latestTimestamp) {
                     latestTimestamp = chunk.timestamp;
                 }
@@ -309,12 +364,11 @@ export class VectorStore {
             return new Map();
         }
         try {
-            // Use query().toArray() instead of direct toArray()
             const allChunks = await this.table.query().toArray();
             const fileHashes = new Map();
             for (const chunk of allChunks) {
-                if (!fileHashes.has(chunk.filePath)) {
-                    fileHashes.set(chunk.filePath, chunk.fileHash);
+                if (!fileHashes.has(chunk.file_path)) {
+                    fileHashes.set(chunk.file_path, chunk.file_hash);
                 }
             }
             return fileHashes;
@@ -324,47 +378,6 @@ export class VectorStore {
             return new Map();
         }
     }
-    /**
-     * Gets aggregated statistics for all indexed files in a single query
-     * Returns a map of filePath -> { lastIndexed, chunkCount, fileHash }
-     */
-    async getIndexedFileStats() {
-        await this.ensureInitialized();
-        if (!this.table) {
-            return new Map();
-        }
-        try {
-            // Fetch all chunks in one go - much faster than N queries
-            // querying only necessary columns to reduce memory usage
-            const allChunks = await this.table.query()
-                .select(['filePath', 'timestamp', 'fileHash'])
-                .toArray();
-            const stats = new Map();
-            for (const chunk of allChunks) {
-                const current = stats.get(chunk.filePath);
-                if (!current) {
-                    stats.set(chunk.filePath, {
-                        lastIndexed: chunk.timestamp,
-                        chunkCount: 1,
-                        fileHash: chunk.fileHash
-                    });
-                }
-                else {
-                    // Update stats
-                    current.chunkCount++;
-                    // Keep the latest timestamp
-                    if (chunk.timestamp > current.lastIndexed) {
-                        current.lastIndexed = chunk.timestamp;
-                    }
-                }
-            }
-            return stats;
-        }
-        catch (error) {
-            console.error(`Error getting indexed file stats: ${error}`);
-            return new Map();
-        }
-    }
 }
 /**
  * Creates a vector store from environment variables

package/dist/index.js

@@ -10,6 +10,7 @@ import { z } from "zod";
 import { createEmbeddingService } from "./common/embeddingService.js";
 import { createVectorStore } from "./common/vectorStore.js";
 import { createIndexManager } from "./common/indexManager.js";
+import { createProjectKnowledgeService } from "./common/projectKnowledgeService.js";
 // Import tools
 import { indexCode } from "./tools/indexCode.js";
 import { searchMemory } from "./tools/searchMemory.js";
@@ -17,11 +18,14 @@ import { readFile } from "./tools/readFile.js";
 import { writeFile } from "./tools/writeFile.js";
 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 { VERSION } from "./common/version.js";
 // Global services
 let embeddingService;
 let vectorStore;
 let indexManager;
+let projectKnowledgeService;
 let workspaceRoot;
 // Create the MCP Server
 const server = new McpServer({
@@ -67,8 +71,8 @@ server.tool("memorybank_search", "Busca código relevante mediante búsqueda sem
     minScore: z
         .number()
         .optional()
-        .default(0.7)
-        .describe("Puntuación mínima de similitud (0-1). Valores más altos = resultados más relevantes"),
+        .default(0.4)
+        .describe("Puntuación mínima de similitud (0-1). por defecto usa 0.4 y basado en el resultado ajusta el valor"),
     filterByFile: z
         .string()
         .optional()
@@ -184,6 +188,47 @@ server.tool("memorybank_analyze_coverage", "Analiza la cobertura de indexación
         };
     }
 });
+// Tool: Generate Project Docs
+server.tool(generateProjectDocsToolDefinition.name, generateProjectDocsToolDefinition.description, {
+    projectId: z
+        .string()
+        .optional()
+        .describe("ID del proyecto (opcional, usa 'default' si no se especifica)"),
+    force: z
+        .boolean()
+        .optional()
+        .default(false)
+        .describe("Forzar regeneración de todos los documentos aunque no hayan cambiado"),
+}, async (args) => {
+    const result = await generateProjectDocs({
+        projectId: args.projectId,
+        force: args.force,
+    }, projectKnowledgeService, vectorStore);
+    return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+    };
+});
+// Tool: Get Project Docs
+server.tool(getProjectDocsToolDefinition.name, getProjectDocsToolDefinition.description, {
+    document: z
+        .string()
+        .optional()
+        .default("summary")
+        .describe("Documento específico a recuperar: projectBrief, productContext, systemPatterns, techContext, activeContext, progress, all, summary"),
+    format: z
+        .enum(["full", "summary"])
+        .optional()
+        .default("full")
+        .describe("Formato de salida: 'full' devuelve contenido completo, 'summary' devuelve resumen de todos los docs"),
+}, async (args) => {
+    const result = await getProjectDocs({
+        document: args.document,
+        format: args.format,
+    }, projectKnowledgeService);
+    return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+    };
+});
 /**
  * Validates and initializes environment
  */
@@ -208,6 +253,12 @@ async function validateEnvironment() {
     const embeddingModel = process.env.MEMORYBANK_EMBEDDING_MODEL || "text-embedding-3-small";
     const embeddingDimensions = process.env.MEMORYBANK_EMBEDDING_DIMENSIONS || "1536";
     console.error(`✓ Embedding model: ${embeddingModel} (${embeddingDimensions} dimensions)`);
+    // Project Knowledge Layer configuration
+    const reasoningModel = process.env.MEMORYBANK_REASONING_MODEL || "gpt-5-mini";
+    const reasoningEffort = process.env.MEMORYBANK_REASONING_EFFORT || "medium";
+    const autoUpdateDocs = process.env.MEMORYBANK_AUTO_UPDATE_DOCS === "true";
+    console.error(`✓ Reasoning model: ${reasoningModel} (effort: ${reasoningEffort})`);
+    console.error(`✓ Auto-update docs: ${autoUpdateDocs}`);
     // Initialize services
     console.error("\nInitializing services...");
     try {
@@ -216,8 +267,21 @@ async function validateEnvironment() {
         vectorStore = createVectorStore();
         await vectorStore.initialize();
         console.error("✓ Vector store initialized");
-        indexManager = createIndexManager(embeddingService, vectorStore, workspaceRoot);
+        indexManager = createIndexManager(embeddingService, vectorStore);
         console.error("✓ Index manager initialized");
+        // Initialize Project Knowledge Service
+        try {
+            projectKnowledgeService = createProjectKnowledgeService();
+            console.error("✓ Project Knowledge service initialized");
+            // Connect to Index Manager for auto-update hooks
+            indexManager.setProjectKnowledgeService(projectKnowledgeService);
+            indexManager.setAutoUpdateDocs(autoUpdateDocs);
+            console.error("✓ Project Knowledge service connected to Index Manager");
+        }
+        catch (error) {
+            console.error(`⚠ Warning: Project Knowledge service not available: ${error}`);
+            console.error("  Project documentation features will be disabled.");
+        }
     }
     catch (error) {
         console.error(`ERROR: Failed to initialize services: ${error}`);
@@ -241,12 +305,16 @@ async function startStdioServer() {
         await server.connect(transport);
         console.error("\n=== MCP Server Ready ===");
         console.error("Available tools:");
-        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("  Core Memory Bank:");
+        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("    - memorybank_generate_project_docs: Generar documentación con IA");
+        console.error("    - memorybank_get_project_docs: Leer documentación del proyecto");
         console.error("");
         console.error("Ready to accept requests...\n");
     }