@grec0/memory-bank-mcp 0.0.2

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

@@ -0,0 +1,332 @@
+/**
+ * @fileoverview Vector store for Memory Bank using LanceDB
+ * Manages storage and retrieval of code embeddings
+ */
+import * as lancedb from "@lancedb/lancedb";
+import * as fs from "fs";
+/**
+ * Vector store using LanceDB
+ */
+export class VectorStore {
+    db = null;
+    table = null;
+    dbPath;
+    tableName;
+    constructor(dbPath = ".memorybank", tableName = "code_chunks") {
+        this.dbPath = dbPath;
+        this.tableName = tableName;
+    }
+    /**
+     * Initializes the vector database
+     */
+    async initialize() {
+        try {
+            // Create database directory if it doesn't exist
+            if (!fs.existsSync(this.dbPath)) {
+                fs.mkdirSync(this.dbPath, { recursive: true });
+                console.error(`Created database directory: ${this.dbPath}`);
+            }
+            // Connect to LanceDB
+            this.db = await lancedb.connect(this.dbPath);
+            console.error(`Connected to LanceDB at ${this.dbPath}`);
+            // Check if table exists
+            const tableNames = await this.db.tableNames();
+            if (tableNames.includes(this.tableName)) {
+                // Open existing table
+                this.table = await this.db.openTable(this.tableName);
+                console.error(`Opened existing table: ${this.tableName}`);
+            }
+            else {
+                // Create new table with empty data (will add records later)
+                console.error(`Creating new table: ${this.tableName}`);
+                // LanceDB requires at least one record to create table with schema
+                // We'll create it when first inserting data
+            }
+        }
+        catch (error) {
+            console.error(`Error initializing vector store: ${error}`);
+            throw error;
+        }
+    }
+    /**
+     * Ensures database and table are initialized
+     */
+    async ensureInitialized() {
+        if (!this.db) {
+            await this.initialize();
+        }
+    }
+    /**
+     * Inserts chunks into the vector store
+     */
+    async insertChunks(chunks) {
+        await this.ensureInitialized();
+        if (chunks.length === 0) {
+            return;
+        }
+        try {
+            if (!this.table) {
+                // Create table with first batch of data
+                this.table = await this.db.createTable(this.tableName, chunks);
+                console.error(`Created table ${this.tableName} with ${chunks.length} chunks`);
+            }
+            else {
+                // Add to existing table
+                await this.table.add(chunks);
+                console.error(`Added ${chunks.length} chunks to ${this.tableName}`);
+            }
+        }
+        catch (error) {
+            console.error(`Error inserting chunks: ${error}`);
+            throw error;
+        }
+    }
+    /**
+     * Updates chunks in the vector store
+     */
+    async updateChunks(chunks) {
+        await this.ensureInitialized();
+        if (chunks.length === 0) {
+            return;
+        }
+        try {
+            // Delete old versions by ID
+            const ids = chunks.map((c) => c.id);
+            await this.deleteChunksByIds(ids);
+            // Insert updated versions
+            await this.insertChunks(chunks);
+            console.error(`Updated ${chunks.length} chunks`);
+        }
+        catch (error) {
+            console.error(`Error updating chunks: ${error}`);
+            throw error;
+        }
+    }
+    /**
+     * Deletes chunks by their IDs
+     */
+    async deleteChunksByIds(ids) {
+        await this.ensureInitialized();
+        if (!this.table || ids.length === 0) {
+            return;
+        }
+        try {
+            // LanceDB uses SQL-like syntax for deletion
+            const idList = ids.map((id) => `'${id}'`).join(",");
+            await this.table.delete(`id IN (${idList})`);
+            console.error(`Deleted ${ids.length} chunks`);
+        }
+        catch (error) {
+            console.error(`Error deleting chunks: ${error}`);
+            throw error;
+        }
+    }
+    /**
+     * Deletes all chunks from a specific file
+     */
+    async deleteChunksByFile(filePath) {
+        await this.ensureInitialized();
+        if (!this.table) {
+            return;
+        }
+        try {
+            await this.table.delete(`filePath = '${filePath}'`);
+            console.error(`Deleted all chunks from file: ${filePath}`);
+        }
+        catch (error) {
+            console.error(`Error deleting chunks by file: ${error}`);
+            throw error;
+        }
+    }
+    /**
+     * Searches for similar chunks using vector similarity
+     */
+    async search(queryVector, options = {}) {
+        await this.ensureInitialized();
+        if (!this.table) {
+            console.error("No table exists yet, returning empty results");
+            return [];
+        }
+        const topK = options.topK || 10;
+        const minScore = options.minScore || 0.0;
+        try {
+            // Start with vector search
+            let query = this.table.search(queryVector).limit(topK);
+            // Apply filters if specified
+            if (options.filterByFile) {
+                query = query.where(`filePath LIKE '%${options.filterByFile}%'`);
+            }
+            if (options.filterByLanguage) {
+                query = query.where(`language = '${options.filterByLanguage}'`);
+            }
+            if (options.filterByType) {
+                query = query.where(`chunkType = '${options.filterByType}'`);
+            }
+            // Execute search
+            const results = await query.toArray();
+            // Convert to SearchResult format
+            const searchResults = results.map((result) => {
+                // LanceDB returns distance, convert to similarity score (0-1)
+                // Using cosine similarity: score = 1 - (distance / 2)
+                const distance = result._distance || 0;
+                const score = Math.max(0, 1 - distance / 2);
+                return {
+                    chunk: {
+                        id: result.id,
+                        vector: result.vector,
+                        filePath: result.filePath,
+                        content: result.content,
+                        startLine: result.startLine,
+                        endLine: result.endLine,
+                        chunkType: result.chunkType,
+                        name: result.name,
+                        language: result.language,
+                        fileHash: result.fileHash,
+                        timestamp: result.timestamp,
+                        context: result.context,
+                    },
+                    score,
+                    distance,
+                };
+            });
+            // Filter by minimum score
+            return searchResults.filter((r) => r.score >= minScore);
+        }
+        catch (error) {
+            console.error(`Error searching vector store: ${error}`);
+            throw error;
+        }
+    }
+    /**
+     * Gets all chunks from a specific file
+     */
+    async getChunksByFile(filePath) {
+        await this.ensureInitialized();
+        if (!this.table) {
+            return [];
+        }
+        try {
+            const results = await this.table
+                .where(`filePath = '${filePath}'`)
+                .toArray();
+            return results.map((r) => ({
+                id: r.id,
+                vector: r.vector,
+                filePath: r.filePath,
+                content: r.content,
+                startLine: r.startLine,
+                endLine: r.endLine,
+                chunkType: r.chunkType,
+                name: r.name,
+                language: r.language,
+                fileHash: r.fileHash,
+                timestamp: r.timestamp,
+                context: r.context,
+            }));
+        }
+        catch (error) {
+            console.error(`Error getting chunks by file: ${error}`);
+            return [];
+        }
+    }
+    /**
+     * Gets statistics about the vector store
+     */
+    async getStats() {
+        await this.ensureInitialized();
+        if (!this.table) {
+            return {
+                totalChunks: 0,
+                fileCount: 0,
+                languageCounts: {},
+                typeCounts: {},
+            };
+        }
+        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);
+                languageCounts[chunk.language] = (languageCounts[chunk.language] || 0) + 1;
+                typeCounts[chunk.chunkType] = (typeCounts[chunk.chunkType] || 0) + 1;
+                if (chunk.timestamp > latestTimestamp) {
+                    latestTimestamp = chunk.timestamp;
+                }
+            }
+            return {
+                totalChunks: allChunks.length,
+                fileCount: uniqueFiles.size,
+                languageCounts,
+                typeCounts,
+                lastUpdated: latestTimestamp > 0 ? new Date(latestTimestamp) : undefined,
+            };
+        }
+        catch (error) {
+            console.error(`Error getting stats: ${error}`);
+            throw error;
+        }
+    }
+    /**
+     * Clears all data from the vector store
+     */
+    async clear() {
+        await this.ensureInitialized();
+        if (!this.table) {
+            return;
+        }
+        try {
+            // Drop the table
+            await this.db.dropTable(this.tableName);
+            this.table = null;
+            console.error(`Cleared vector store table: ${this.tableName}`);
+        }
+        catch (error) {
+            console.error(`Error clearing vector store: ${error}`);
+            throw error;
+        }
+    }
+    /**
+     * Closes the database connection
+     */
+    async close() {
+        // LanceDB connections are lightweight and don't need explicit closing
+        // But we'll clear references
+        this.table = null;
+        this.db = null;
+    }
+    /**
+     * Gets file hashes for all indexed files
+     */
+    async getFileHashes() {
+        await this.ensureInitialized();
+        if (!this.table) {
+            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);
+                }
+            }
+            return fileHashes;
+        }
+        catch (error) {
+            console.error(`Error getting file hashes: ${error}`);
+            return new Map();
+        }
+    }
+}
+/**
+ * Creates a vector store from environment variables
+ */
+export function createVectorStore() {
+    const storagePath = process.env.MEMORYBANK_STORAGE_PATH || ".memorybank";
+    return new VectorStore(storagePath);
+}

package/dist/common/version.js

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