@grec0/memory-bank-mcp 0.0.2 → 0.0.3

package/dist/common/logger.js

@@ -0,0 +1,54 @@
+/**
+ * @fileoverview Structured logger for Memory Bank MCP
+ * Ensures all logs are written to stderr to avoid breaking JSON-RPC on stdout
+ */
+export var LogLevel;
+(function (LogLevel) {
+    LogLevel[LogLevel["DEBUG"] = 0] = "DEBUG";
+    LogLevel[LogLevel["INFO"] = 1] = "INFO";
+    LogLevel[LogLevel["WARN"] = 2] = "WARN";
+    LogLevel[LogLevel["ERROR"] = 3] = "ERROR";
+})(LogLevel || (LogLevel = {}));
+export class Logger {
+    static instance;
+    level = LogLevel.INFO;
+    constructor() { }
+    static getInstance() {
+        if (!Logger.instance) {
+            Logger.instance = new Logger();
+        }
+        return Logger.instance;
+    }
+    setLevel(level) {
+        this.level = level;
+    }
+    formatMessage(level, message) {
+        const timestamp = new Date().toISOString();
+        return `[${timestamp}] [${level}] ${message}`;
+    }
+    debug(message) {
+        if (this.level <= LogLevel.DEBUG) {
+            console.error(this.formatMessage("DEBUG", message));
+        }
+    }
+    info(message) {
+        if (this.level <= LogLevel.INFO) {
+            console.error(this.formatMessage("INFO", message));
+        }
+    }
+    warn(message) {
+        if (this.level <= LogLevel.WARN) {
+            console.error(this.formatMessage("WARN", message));
+        }
+    }
+    error(message, error) {
+        if (this.level <= LogLevel.ERROR) {
+            const errorMsg = error ? ` ${error instanceof Error ? error.message : String(error)}` : "";
+            console.error(this.formatMessage("ERROR", message + errorMsg));
+            if (error instanceof Error && error.stack) {
+                console.error(error.stack);
+            }
+        }
+    }
+}
+export const logger = Logger.getInstance();

package/dist/common/vectorStore.js

@@ -122,16 +122,16 @@ export class VectorStore {
         }
     }
     /**
-     * Deletes all chunks from a specific file
+     * Deletes all chunks from a specific file in a specific project
      */
-    async deleteChunksByFile(filePath) {
+    async deleteChunksByFile(filePath, projectId) {
         await this.ensureInitialized();
         if (!this.table) {
             return;
         }
         try {
-            await this.table.delete(`filePath = '${filePath}'`);
-            console.error(`Deleted all chunks from file: ${filePath}`);
+            await this.table.delete(`"filePath" = '${filePath}' AND "projectId" = '${projectId}'`);
+            console.error(`Deleted all chunks from file: ${filePath} (project: ${projectId.substring(0, 8)}...)`);
         }
         catch (error) {
             console.error(`Error deleting chunks by file: ${error}`);
@@ -184,6 +184,7 @@ export class VectorStore {
                         fileHash: result.fileHash,
                         timestamp: result.timestamp,
                         context: result.context,
+                        projectId: result.projectId,
                     },
                     score,
                     distance,
@@ -222,6 +223,7 @@ export class VectorStore {
                 fileHash: r.fileHash,
                 timestamp: r.timestamp,
                 context: r.context,
+                projectId: r.projectId,
             }));
         }
         catch (error) {
@@ -322,6 +324,47 @@ 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

@@ -216,7 +216,7 @@ async function validateEnvironment() {
         vectorStore = createVectorStore();
         await vectorStore.initialize();
         console.error("✓ Vector store initialized");
-        indexManager = createIndexManager(embeddingService, vectorStore);
+        indexManager = createIndexManager(embeddingService, vectorStore, workspaceRoot);
         console.error("✓ Index manager initialized");
     }
     catch (error) {

package/dist/tools/analyzeCoverage.js

@@ -21,18 +21,22 @@ function buildDirectoryTree(files, indexedFiles, pendingFiles, rootPath) {
     // Build tree structure
     const dirMap = new Map();
     dirMap.set("", root);
+    // Helper to normalize paths to forward slashes
+    const normalize = (p) => p.replace(/\\/g, "/");
     // Sort files by path for consistent tree building
-    const sortedFiles = [...files].sort((a, b) => a.path.localeCompare(b.path));
+    const sortedFiles = [...files].sort((a, b) => normalize(a.path).localeCompare(normalize(b.path)));
     for (const file of sortedFiles) {
-        const parts = file.path.split(path.sep);
+        const normalizedPath = normalize(file.path);
+        const parts = normalizedPath.split("/");
         let currentPath = "";
         // Create directory nodes
         for (let i = 0; i < parts.length - 1; i++) {
+            const part = parts[i];
             const parentPath = currentPath;
-            currentPath = currentPath ? path.join(currentPath, parts[i]) : parts[i];
+            currentPath = currentPath ? `${currentPath}/${part}` : part;
             if (!dirMap.has(currentPath)) {
                 const dirNode = {
-                    name: parts[i],
+                    name: part,
                     path: currentPath,
                     type: "directory",
                     status: "indexed",
@@ -50,10 +54,10 @@ function buildDirectoryTree(files, indexedFiles, pendingFiles, rootPath) {
         }
         // Add file node
         const fileName = parts[parts.length - 1];
-        const fileDir = parts.length > 1 ? path.dirname(file.path) : "";
+        const fileDir = parts.length > 1 ? parts.slice(0, -1).join("/") : "";
         const parentDir = dirMap.get(fileDir);
         if (parentDir && parentDir.children) {
-            const indexed = indexedFiles.has(file.path);
+            const indexed = indexedFiles.has(normalize(file.path)); // Use normalized path for lookup
             const pending = pendingFiles.has(file.path);
             const fileNode = {
                 name: fileName,
@@ -66,33 +70,43 @@ function buildDirectoryTree(files, indexedFiles, pendingFiles, rootPath) {
                 chunkCount: indexed ? indexedFiles.get(file.path).chunks : 0,
             };
             parentDir.children.push(fileNode);
-            // Update parent stats
-            let current = parentDir;
-            while (current) {
-                current.fileCount = (current.fileCount || 0) + 1;
-                if (indexed)
-                    current.indexedCount = (current.indexedCount || 0) + 1;
-                if (pending)
-                    current.pendingCount = (current.pendingCount || 0) + 1;
-                // Find parent
-                const parentPath = path.dirname(current.path);
-                current = parentPath !== current.path ? dirMap.get(parentPath === "." ? "" : parentPath) : null;
-            }
         }
     }
-    // Sort children (directories first, then files)
-    const sortChildren = (node) => {
+    // Calculate stats bottom-up
+    const calculateNodeStats = (node) => {
+        if (node.type === "file") {
+            return;
+        }
+        let fileCount = 0;
+        let indexedCount = 0;
+        let pendingCount = 0;
         if (node.children) {
             node.children.sort((a, b) => {
-                if (a.type !== b.type) {
+                if (a.type !== b.type)
                     return a.type === "directory" ? -1 : 1;
-                }
                 return a.name.localeCompare(b.name);
             });
-            node.children.forEach(sortChildren);
+            for (const child of node.children) {
+                if (child.type === "directory") {
+                    calculateNodeStats(child);
+                    fileCount += child.fileCount || 0;
+                    indexedCount += child.indexedCount || 0;
+                    pendingCount += child.pendingCount || 0;
+                }
+                else {
+                    fileCount++;
+                    if (child.status === "indexed")
+                        indexedCount++;
+                    if (child.status === "pending_reindex")
+                        pendingCount++;
+                }
+            }
         }
+        node.fileCount = fileCount;
+        node.indexedCount = indexedCount;
+        node.pendingCount = pendingCount;
     };
-    sortChildren(root);
+    calculateNodeStats(root);
     return root;
 }
 /**
@@ -112,9 +126,11 @@ function calculateStats(files, indexedFiles, pendingFiles, totalChunks) {
         languageBreakdown: {},
         directoryBreakdown: {},
     };
+    // Helper to normalize paths
+    const normalize = (p) => p.replace(/\\/g, "/");
     for (const file of files) {
         stats.totalSize += file.size;
-        const indexed = indexedFiles.has(file.path);
+        const indexed = indexedFiles.has(normalize(file.path));
         const pending = pendingFiles.has(file.path);
         if (pending) {
             stats.pendingReindexFiles++;
@@ -137,7 +153,7 @@ function calculateStats(files, indexedFiles, pendingFiles, totalChunks) {
         stats.languageBreakdown[file.language].total++;
         if (indexed) {
             stats.languageBreakdown[file.language].indexed++;
-            stats.languageBreakdown[file.language].chunks += indexedFiles.get(file.path).chunks;
+            stats.languageBreakdown[file.language].chunks += indexedFiles.get(normalize(file.path)).chunks;
         }
         // Directory breakdown
         const dir = path.dirname(file.path);
@@ -214,7 +230,7 @@ export async function analyzeCoverage(indexManager, vectorStore, workspaceRoot)
         const maxScanTime = 10000; // 10 seconds max
         let allFiles = [];
         try {
-            allFiles = scanFiles({
+            allFiles = await scanFiles({
                 rootPath: workspaceRoot,
                 recursive: true
             });
@@ -231,33 +247,37 @@ export async function analyzeCoverage(indexManager, vectorStore, workspaceRoot)
             console.error(`Error escaneando archivos: ${error}`);
             throw error;
         }
-        // 2. Get indexed files from vector store
-        console.error("Obteniendo archivos indexados...");
+        // 2. Get indexed files stats in ONE batch query (Optimized)
+        console.error("Obteniendo estadísticas de archivos indexados...");
         await vectorStore.initialize();
-        const fileHashes = await vectorStore.getFileHashes();
+        // This single call replaces thousands of potential DB queries
+        // It returns Map<filePath, { lastIndexed, chunkCount, fileHash }>
+        const indexedFileStats = await vectorStore.getIndexedFileStats();
         // 3. Get index metadata
         const indexStats = await indexManager.getStats();
-        // 4. Build indexed files map with chunk counts
+        // 4. Adapt to expected format for efficient loopups
+        // Helper to normalize paths to forward slashes
+        const normalize = (p) => p.replace(/\\/g, "/");
+        // 4. Adapt to expected format for efficient loopups
         const indexedFiles = new Map();
-        // Get chunks grouped by file from vector store
-        for (const [filePath, hash] of fileHashes) {
-            const chunks = await vectorStore.getChunksByFile(filePath);
-            if (chunks.length > 0) {
-                indexedFiles.set(filePath, {
-                    lastIndexed: chunks[0].timestamp,
-                    chunks: chunks.length,
-                });
-            }
+        const normalizedStats = new Map();
+        for (const [path, stats] of indexedFileStats) {
+            const normPath = normalize(path);
+            normalizedStats.set(normPath, stats);
+            indexedFiles.set(normPath, {
+                lastIndexed: stats.lastIndexed,
+                chunks: stats.chunkCount
+            });
         }
         // 5. Identify pending files (files that changed)
         const pendingFiles = new Set();
         for (const file of allFiles) {
-            const indexed = indexedFiles.get(file.path);
-            if (indexed) {
-                // Check if file hash matches
-                const chunks = await vectorStore.getChunksByFile(file.path);
-                if (chunks.length > 0 && chunks[0].fileHash !== file.hash) {
-                    pendingFiles.add(file.path);
+            const normPath = normalize(file.path);
+            const stats = normalizedStats.get(normPath);
+            if (stats) {
+                // Check if file hash matches the one in DB
+                if (stats.fileHash !== file.hash) {
+                    pendingFiles.add(file.path); // keep original path for file system ops if needed
                 }
             }
         }

package/dist/tools/indexCode.js

@@ -21,6 +21,7 @@ export async function indexCode(params, indexManager, workspaceRoot) {
         // Run indexing
         const result = await indexManager.indexFiles({
             rootPath: targetPath,
+            projectRoot: workspaceRoot,
             recursive: params.recursive !== false,
             forceReindex: params.forceReindex || false,
         });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@grec0/memory-bank-mcp",
-  "version": "0.0.2",
+  "version": "0.0.3",
   "description": "MCP server for semantic code indexing with Memory Bank - AI-powered codebase understanding",
   "license": "MIT",
   "author": "@grec0",
@@ -41,6 +41,7 @@
     "@modelcontextprotocol/sdk": "1.6.1",
     "@types/node": "^22",
     "ignore": "^5.3.0",
+    "js-tiktoken": "^1.0.21",
     "openai": "^4.0.0",
     "zod": "^3.22.4",
     "zod-to-json-schema": "^3.23.5"

package/dist/common/setup.js

@@ -1,49 +0,0 @@
-// Global variables to store user IDs
-let adminUserId = null;
-import { getUserIdByEmail, getUserIdByUsername } from "./utils.js";
-/**
- * Gets the admin user ID by looking up the user by email or username
- *
- * This function will try the following methods in order:
- * 1. Use the cached admin user ID if available
- * 2. Use the PLANKA_ADMIN_ID environment variable if set (for backwards compatibility)
- * 3. Look up the admin user ID by email using PLANKA_ADMIN_EMAIL
- * 4. Look up the admin user ID by username using PLANKA_ADMIN_USERNAME
- */
-export async function getAdminUserId() {
-    if (adminUserId) {
-        return adminUserId;
-    }
-    try {
-        // Check for direct admin ID (for backwards compatibility)
-        const directAdminId = process.env.PLANKA_ADMIN_ID;
-        if (directAdminId) {
-            adminUserId = directAdminId;
-            return adminUserId;
-        }
-        // Try to get the admin ID by email
-        const adminEmail = process.env.PLANKA_ADMIN_EMAIL;
-        if (adminEmail) {
-            const id = await getUserIdByEmail(adminEmail);
-            if (id) {
-                adminUserId = id;
-                return adminUserId;
-            }
-        }
-        // If that fails, try to get the admin ID by username
-        const adminUsername = process.env.PLANKA_ADMIN_USERNAME;
-        if (adminUsername) {
-            const id = await getUserIdByUsername(adminUsername);
-            if (id) {
-                adminUserId = id;
-                return adminUserId;
-            }
-        }
-        console.error("Could not determine admin user ID. Please set PLANKA_ADMIN_ID, PLANKA_ADMIN_EMAIL, or PLANKA_ADMIN_USERNAME.");
-        return null;
-    }
-    catch (error) {
-        console.error("Failed to get admin user ID:", error);
-        return null;
-    }
-}

package/dist/common/utils.js

@@ -1,215 +0,0 @@
-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;
-    }
-}