@grec0/memory-bank-mcp 0.0.2

package/dist/operations/projects.js

@@ -0,0 +1,102 @@
+/**
+ * @fileoverview Project operations for the MCP Kanban server
+ *
+ * This module provides functions for interacting with projects in the Planka Kanban system,
+ * including creating, retrieving, updating, and deleting projects.
+ */
+import { z } from "zod";
+import { plankaRequest } from "../common/utils.js";
+import { PlankaProjectSchema } from "../common/types.js";
+// Schema definitions
+/**
+ * Schema for creating a new project
+ * @property {string} name - The name of the project
+ */
+export const CreateProjectSchema = z.object({
+    name: z.string().describe("Project name"),
+});
+/**
+ * Schema for retrieving projects with pagination
+ * @property {number} [page] - Page number for pagination (default: 1)
+ * @property {number} [perPage] - Number of results per page (default: 30, max: 100)
+ */
+export const GetProjectsSchema = z.object({
+    page: z.number().optional().describe("Page number for pagination (default: 1)"),
+    perPage: z.number().optional().describe("Number of results per page (default: 30, max: 100)"),
+});
+/**
+ * Schema for retrieving a specific project
+ * @property {string} id - The ID of the project to retrieve
+ */
+export const GetProjectSchema = z.object({
+    id: z.string().describe("Project ID"),
+});
+/**
+ * Schema for updating a project
+ * @property {string} id - The ID of the project to update
+ * @property {string} [name] - The new name for the project
+ */
+export const UpdateProjectSchema = z.object({
+    id: z.string().describe("Project ID"),
+    name: z.string().optional().describe("Project name"),
+});
+/**
+ * Schema for deleting a project
+ * @property {string} id - The ID of the project to delete
+ */
+export const DeleteProjectSchema = z.object({
+    id: z.string().describe("Project ID"),
+});
+// Response schemas
+const ProjectsResponseSchema = z.object({
+    items: z.array(PlankaProjectSchema),
+    included: z.record(z.any()).optional(),
+});
+const ProjectResponseSchema = z.object({
+    item: PlankaProjectSchema,
+    included: z.record(z.any()).optional(),
+});
+/**
+ * Retrieves projects with pagination support
+ *
+ * @param {number} [page=1] - The page number to retrieve (1-indexed)
+ * @param {number} [perPage=30] - The number of projects per page (max: 100)
+ * @returns {Promise<{items: Array<object>, included?: object}>} Paginated projects
+ * @throws {Error} If retrieving projects fails
+ */
+export async function getProjects(page = 1, perPage = 30) {
+    try {
+        // Ensure perPage is within limits
+        if (perPage > 100) {
+            perPage = 100;
+        }
+        const queryParams = new URLSearchParams();
+        queryParams.append("page", page.toString());
+        queryParams.append("per_page", perPage.toString());
+        const response = await plankaRequest(`/api/projects?${queryParams.toString()}`, {
+            method: "GET",
+        });
+        const parsedResponse = ProjectsResponseSchema.parse(response);
+        return parsedResponse;
+    }
+    catch (error) {
+        throw new Error(`Failed to get projects: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+/**
+ * Retrieves a specific project by ID
+ *
+ * @param {string} id - The ID of the project to retrieve
+ * @returns {Promise<object>} The requested project
+ * @throws {Error} If retrieving the project fails
+ */
+export async function getProject(id) {
+    try {
+        const response = await plankaRequest(`/api/projects/${id}`);
+        const parsedResponse = ProjectResponseSchema.parse(response);
+        return parsedResponse.item;
+    }
+    catch (error) {
+        throw new Error(`Failed to get project: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}

package/dist/operations/tasks.js

@@ -0,0 +1,238 @@
+/**
+ * @fileoverview Task operations for the MCP Kanban server
+ *
+ * This module provides functions for interacting with tasks in the Planka Kanban board,
+ * including creating, retrieving, updating, and deleting tasks, as well as batch operations.
+ */
+import { z } from "zod";
+import { plankaRequest } from "../common/utils.js";
+import { PlankaTaskSchema } from "../common/types.js";
+// Schema definitions
+/**
+ * Schema for creating a new task
+ * @property {string} cardId - The ID of the card to create the task in
+ * @property {string} name - The name of the task
+ * @property {number} [position] - The position of the task in the card (default: 65535)
+ */
+export const CreateTaskSchema = z.object({
+    cardId: z.string().describe("Card ID"),
+    name: z.string().describe("Task name"),
+    position: z.number().optional().describe("Task position (default: 65535)"),
+});
+/**
+ * Schema for batch creating multiple tasks
+ * @property {Array<CreateTaskSchema>} tasks - Array of tasks to create
+ */
+export const BatchCreateTasksSchema = z.object({
+    tasks: z.array(CreateTaskSchema).describe("Array of tasks to create"),
+});
+/**
+ * Schema for retrieving tasks from a card
+ * @property {string} cardId - The ID of the card to get tasks from
+ */
+export const GetTasksSchema = z.object({
+    cardId: z.string().describe("Card ID"),
+});
+/**
+ * Schema for retrieving a specific task
+ * @property {string} id - The ID of the task to retrieve
+ * @property {string} [cardId] - The ID of the card containing the task
+ */
+export const GetTaskSchema = z.object({
+    id: z.string().describe("Task ID"),
+    cardId: z.string().optional().describe("Card ID containing the task"),
+});
+/**
+ * Schema for updating a task
+ * @property {string} id - The ID of the task to update
+ * @property {string} [name] - The new name for the task
+ * @property {boolean} [isCompleted] - Whether the task is completed
+ * @property {number} [position] - The new position for the task
+ */
+export const UpdateTaskSchema = z.object({
+    id: z.string().describe("Task ID"),
+    name: z.string().optional().describe("Task name"),
+    isCompleted: z.boolean().optional().describe("Whether the task is completed"),
+    position: z.number().optional().describe("Task position"),
+});
+/**
+ * Schema for deleting a task
+ * @property {string} id - The ID of the task to delete
+ */
+export const DeleteTaskSchema = z.object({
+    id: z.string().describe("Task ID"),
+});
+// Response schemas
+const TasksResponseSchema = z.object({
+    items: z.array(PlankaTaskSchema),
+    included: z.record(z.any()).optional(),
+});
+const TaskResponseSchema = z.object({
+    item: PlankaTaskSchema,
+    included: z.record(z.any()).optional(),
+});
+// Map to store task ID to card ID mapping
+const taskCardIdMap = {};
+// Function implementations
+/**
+ * Creates a new task for a card
+ *
+ * @param {object} params - The task creation parameters
+ * @param {string} params.cardId - The ID of the card to create the task in
+ * @param {string} params.name - The name of the new task
+ * @param {number} params.position - The position of the task in the card
+ * @returns {Promise<object>} The created task
+ */
+export async function createTask(params) {
+    try {
+        const { cardId, name, position = 65535 } = params;
+        const response = await plankaRequest(`/api/cards/${cardId}/tasks`, {
+            method: "POST",
+            body: { name, position },
+        });
+        // Store the task ID to card ID mapping for getTask
+        if (response.item && response.item.id) {
+            taskCardIdMap[response.item.id] = cardId;
+        }
+        return response.item;
+    }
+    catch (error) {
+        console.error("Error creating task:", error);
+        throw new Error(`Failed to create task: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+/**
+ * Creates multiple tasks for cards in a single operation
+ *
+ * @param {BatchCreateTasksOptions} options - The batch create tasks options
+ * @returns {Promise<{results: any[], successes: any[], failures: TaskError[]}>} The results of the batch operation
+ * @throws {Error} If the batch operation fails completely
+ */
+export async function batchCreateTasks(options) {
+    try {
+        const results = [];
+        const successes = [];
+        const failures = [];
+        // Process each task in sequence
+        for (let i = 0; i < options.tasks.length; i++) {
+            const task = options.tasks[i];
+            // Ensure position is set if not provided
+            if (!task.position) {
+                task.position = 65535 * (i + 1);
+            }
+            try {
+                const result = await createTask(task);
+                results.push({
+                    success: true,
+                    result,
+                });
+                successes.push(result);
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error
+                    ? error.message
+                    : String(error);
+                results.push({
+                    success: false,
+                    error: { message: errorMessage },
+                });
+                failures.push({
+                    index: i,
+                    task,
+                    error: errorMessage,
+                });
+            }
+        }
+        return {
+            results,
+            successes,
+            failures,
+        };
+    }
+    catch (error) {
+        throw new Error(`Failed to batch create tasks: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+/**
+ * Retrieves all tasks for a specific card
+ *
+ * @param {string} cardId - The ID of the card to get tasks from
+ * @returns {Promise<Array<object>>} Array of tasks in the card
+ */
+export async function getTasks(cardId) {
+    try {
+        // Instead of using the tasks endpoint which returns HTML,
+        // we'll get the card details which includes tasks
+        const response = await plankaRequest(`/api/cards/${cardId}`);
+        // Extract tasks from the card response
+        if (response?.included?.tasks && Array.isArray(response.included.tasks)) {
+            const tasks = response.included.tasks;
+            return tasks;
+        }
+        return [];
+    }
+    catch (error) {
+        console.error(`Error getting tasks for card ${cardId}:`, error);
+        // If there's an error, return an empty array
+        return [];
+    }
+}
+/**
+ * Retrieves a specific task by ID
+ *
+ * @param {string} id - The ID of the task to retrieve
+ * @param {string} [cardId] - Optional card ID to help find the task
+ * @returns {Promise<object>} The requested task
+ */
+export async function getTask(id, cardId) {
+    try {
+        // Tasks in Planka are always part of a card, so we need the card ID
+        const taskCardId = cardId || taskCardIdMap[id];
+        if (!taskCardId) {
+            throw new Error("Card ID is required to get a task. Either provide it directly or create the task first.");
+        }
+        // Get the card details which includes tasks
+        const response = await plankaRequest(`/api/cards/${taskCardId}`);
+        if (!response?.included?.tasks ||
+            !Array.isArray(response.included.tasks)) {
+            throw new Error(`Failed to get tasks for card ${taskCardId}`);
+        }
+        // Find the task with the matching ID
+        const task = response.included.tasks.find((task) => task.id === id);
+        if (!task) {
+            throw new Error(`Task with ID ${id} not found in card ${taskCardId}`);
+        }
+        return task;
+    }
+    catch (error) {
+        console.error(`Error getting task with ID ${id}:`, error);
+        throw new Error(`Failed to get task: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+/**
+ * Updates a task's properties
+ *
+ * @param {string} id - The ID of the task to update
+ * @param {Partial<Omit<CreateTaskOptions, "cardId">>} options - The properties to update
+ * @returns {Promise<object>} The updated task
+ */
+export async function updateTask(id, options) {
+    const response = await plankaRequest(`/api/tasks/${id}`, {
+        method: "PATCH",
+        body: options,
+    });
+    const parsedResponse = TaskResponseSchema.parse(response);
+    return parsedResponse.item;
+}
+/**
+ * Deletes a task by ID
+ *
+ * @param {string} id - The ID of the task to delete
+ * @returns {Promise<{success: boolean}>} Success indicator
+ */
+export async function deleteTask(id) {
+    await plankaRequest(`/api/tasks/${id}`, {
+        method: "DELETE",
+    });
+    return { success: true };
+}

package/dist/tools/analyzeCoverage.js

@@ -0,0 +1,316 @@
+/**
+ * @fileoverview Analyze coverage tool for Memory Bank
+ * Provides detailed analysis of indexation coverage across the project
+ */
+import * as path from "path";
+import { scanFiles } from "../common/fileScanner.js";
+/**
+ * Builds a directory tree with indexation status
+ */
+function buildDirectoryTree(files, indexedFiles, pendingFiles, rootPath) {
+    const root = {
+        name: path.basename(rootPath),
+        path: "",
+        type: "directory",
+        status: "indexed",
+        fileCount: 0,
+        indexedCount: 0,
+        pendingCount: 0,
+        children: [],
+    };
+    // Build tree structure
+    const dirMap = new Map();
+    dirMap.set("", root);
+    // Sort files by path for consistent tree building
+    const sortedFiles = [...files].sort((a, b) => a.path.localeCompare(b.path));
+    for (const file of sortedFiles) {
+        const parts = file.path.split(path.sep);
+        let currentPath = "";
+        // Create directory nodes
+        for (let i = 0; i < parts.length - 1; i++) {
+            const parentPath = currentPath;
+            currentPath = currentPath ? path.join(currentPath, parts[i]) : parts[i];
+            if (!dirMap.has(currentPath)) {
+                const dirNode = {
+                    name: parts[i],
+                    path: currentPath,
+                    type: "directory",
+                    status: "indexed",
+                    fileCount: 0,
+                    indexedCount: 0,
+                    pendingCount: 0,
+                    children: [],
+                };
+                dirMap.set(currentPath, dirNode);
+                const parent = dirMap.get(parentPath);
+                if (parent && parent.children) {
+                    parent.children.push(dirNode);
+                }
+            }
+        }
+        // Add file node
+        const fileName = parts[parts.length - 1];
+        const fileDir = parts.length > 1 ? path.dirname(file.path) : "";
+        const parentDir = dirMap.get(fileDir);
+        if (parentDir && parentDir.children) {
+            const indexed = indexedFiles.has(file.path);
+            const pending = pendingFiles.has(file.path);
+            const fileNode = {
+                name: fileName,
+                path: file.path,
+                type: "file",
+                status: pending ? "pending_reindex" : indexed ? "indexed" : "not_indexed",
+                size: file.size,
+                lastModified: file.mtime,
+                lastIndexed: indexed ? new Date(indexedFiles.get(file.path).lastIndexed) : undefined,
+                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) => {
+        if (node.children) {
+            node.children.sort((a, b) => {
+                if (a.type !== b.type) {
+                    return a.type === "directory" ? -1 : 1;
+                }
+                return a.name.localeCompare(b.name);
+            });
+            node.children.forEach(sortChildren);
+        }
+    };
+    sortChildren(root);
+    return root;
+}
+/**
+ * Calculates coverage statistics
+ */
+function calculateStats(files, indexedFiles, pendingFiles, totalChunks) {
+    const stats = {
+        totalFiles: files.length,
+        indexedFiles: 0,
+        notIndexedFiles: 0,
+        pendingReindexFiles: 0,
+        ignoredFiles: 0,
+        totalSize: 0,
+        indexedSize: 0,
+        coveragePercentage: 0,
+        totalChunks,
+        languageBreakdown: {},
+        directoryBreakdown: {},
+    };
+    for (const file of files) {
+        stats.totalSize += file.size;
+        const indexed = indexedFiles.has(file.path);
+        const pending = pendingFiles.has(file.path);
+        if (pending) {
+            stats.pendingReindexFiles++;
+        }
+        else if (indexed) {
+            stats.indexedFiles++;
+            stats.indexedSize += file.size;
+        }
+        else {
+            stats.notIndexedFiles++;
+        }
+        // Language breakdown
+        if (!stats.languageBreakdown[file.language]) {
+            stats.languageBreakdown[file.language] = {
+                total: 0,
+                indexed: 0,
+                chunks: 0,
+            };
+        }
+        stats.languageBreakdown[file.language].total++;
+        if (indexed) {
+            stats.languageBreakdown[file.language].indexed++;
+            stats.languageBreakdown[file.language].chunks += indexedFiles.get(file.path).chunks;
+        }
+        // Directory breakdown
+        const dir = path.dirname(file.path);
+        const topLevelDir = dir.split(path.sep)[0] || "(root)";
+        if (!stats.directoryBreakdown[topLevelDir]) {
+            stats.directoryBreakdown[topLevelDir] = {
+                total: 0,
+                indexed: 0,
+                pending: 0,
+            };
+        }
+        stats.directoryBreakdown[topLevelDir].total++;
+        if (indexed)
+            stats.directoryBreakdown[topLevelDir].indexed++;
+        if (pending)
+            stats.directoryBreakdown[topLevelDir].pending++;
+    }
+    stats.coveragePercentage = stats.totalFiles > 0
+        ? (stats.indexedFiles / stats.totalFiles) * 100
+        : 0;
+    return stats;
+}
+/**
+ * Generates recommendations based on coverage analysis
+ */
+function generateRecommendations(stats, tree) {
+    const recommendations = [];
+    // Low coverage
+    if (stats.coveragePercentage < 50) {
+        recommendations.push(`⚠️ Cobertura baja (${stats.coveragePercentage.toFixed(1)}%). Considera indexar el proyecto completo con memorybank_index_code({})`);
+    }
+    else if (stats.coveragePercentage < 80) {
+        recommendations.push(`📊 Cobertura media (${stats.coveragePercentage.toFixed(1)}%). Hay ${stats.notIndexedFiles} archivos sin indexar`);
+    }
+    else if (stats.coveragePercentage === 100) {
+        recommendations.push(`✅ Cobertura completa (100%). Todos los archivos están indexados`);
+    }
+    // Pending reindex
+    if (stats.pendingReindexFiles > 0) {
+        recommendations.push(`🔄 Hay ${stats.pendingReindexFiles} archivo(s) con cambios pendientes de reindexación. Ejecuta memorybank_index_code({ forceReindex: true })`);
+    }
+    // Language-specific recommendations
+    const unindexedLanguages = Object.entries(stats.languageBreakdown)
+        .filter(([_, data]) => data.indexed === 0 && data.total > 0)
+        .map(([lang]) => lang);
+    if (unindexedLanguages.length > 0) {
+        recommendations.push(`💡 Lenguajes sin indexar: ${unindexedLanguages.join(", ")}. Considera indexar estos archivos`);
+    }
+    // Directory-specific recommendations
+    const unindexedDirs = Object.entries(stats.directoryBreakdown)
+        .filter(([_, data]) => data.indexed === 0 && data.total > 5)
+        .map(([dir]) => dir);
+    if (unindexedDirs.length > 0) {
+        recommendations.push(`📁 Directorios sin indexar: ${unindexedDirs.join(", ")}. Usa memorybank_index_code({ path: "directorio" })`);
+    }
+    // Size recommendations
+    const avgChunksPerFile = stats.indexedFiles > 0 ? stats.totalChunks / stats.indexedFiles : 0;
+    if (avgChunksPerFile > 20) {
+        recommendations.push(`⚡ Promedio alto de chunks por archivo (${avgChunksPerFile.toFixed(1)}). Los archivos son muy grandes o el chunk_size es pequeño`);
+    }
+    return recommendations;
+}
+/**
+ * Analyzes indexation coverage of the project
+ */
+export async function analyzeCoverage(indexManager, vectorStore, workspaceRoot) {
+    try {
+        console.error("\n=== Analizando cobertura de indexación ===");
+        console.error(`Workspace root: ${workspaceRoot}`);
+        // 1. Scan all code files in workspace with timeout protection
+        console.error("Escaneando archivos del workspace...");
+        // Add timeout and file limit protection
+        const scanStartTime = Date.now();
+        const maxScanTime = 10000; // 10 seconds max
+        let allFiles = [];
+        try {
+            allFiles = scanFiles({
+                rootPath: workspaceRoot,
+                recursive: true
+            });
+            const scanDuration = Date.now() - scanStartTime;
+            console.error(`Escaneo completado en ${scanDuration}ms`);
+            console.error(`Encontrados ${allFiles.length} archivos de código`);
+            // If scan took too long or found too many files, limit results
+            if (scanDuration > maxScanTime || allFiles.length > 10000) {
+                console.error(`⚠️ Workspace muy grande. Limitando análisis a primeros 1000 archivos`);
+                allFiles = allFiles.slice(0, 1000);
+            }
+        }
+        catch (error) {
+            console.error(`Error escaneando archivos: ${error}`);
+            throw error;
+        }
+        // 2. Get indexed files from vector store
+        console.error("Obteniendo archivos indexados...");
+        await vectorStore.initialize();
+        const fileHashes = await vectorStore.getFileHashes();
+        // 3. Get index metadata
+        const indexStats = await indexManager.getStats();
+        // 4. Build indexed files map with chunk counts
+        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,
+                });
+            }
+        }
+        // 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);
+                }
+            }
+        }
+        console.error(`Archivos indexados: ${indexedFiles.size}`);
+        console.error(`Archivos con cambios: ${pendingFiles.size}`);
+        // 6. Build directory tree
+        console.error("Construyendo árbol de directorios...");
+        const tree = buildDirectoryTree(allFiles, indexedFiles, pendingFiles, workspaceRoot);
+        // 7. Calculate statistics
+        console.error("Calculando estadísticas...");
+        const stats = calculateStats(allFiles, indexedFiles, pendingFiles, indexStats.totalChunks);
+        // 8. Generate recommendations
+        const recommendations = generateRecommendations(stats, tree);
+        // 9. Format message
+        const message = `Análisis completado: ${stats.indexedFiles}/${stats.totalFiles} archivos indexados (${stats.coveragePercentage.toFixed(1)}% cobertura)`;
+        console.error("\n=== Análisis completado ===");
+        console.error(message);
+        console.error(`Total chunks: ${stats.totalChunks}`);
+        console.error(`Pendientes: ${stats.pendingReindexFiles}`);
+        return {
+            success: true,
+            stats,
+            tree,
+            recommendations,
+            message,
+        };
+    }
+    catch (error) {
+        console.error(`Error analyzing coverage: ${error}`);
+        return {
+            success: false,
+            stats: {
+                totalFiles: 0,
+                indexedFiles: 0,
+                notIndexedFiles: 0,
+                pendingReindexFiles: 0,
+                ignoredFiles: 0,
+                totalSize: 0,
+                indexedSize: 0,
+                coveragePercentage: 0,
+                totalChunks: 0,
+                languageBreakdown: {},
+                directoryBreakdown: {},
+            },
+            tree: {
+                name: "root",
+                path: "",
+                type: "directory",
+                status: "not_indexed",
+                children: [],
+            },
+            recommendations: [],
+            message: `Failed to analyze coverage: ${error}`,
+        };
+    }
+}