@grec0/memory-bank-mcp 0.0.3 → 0.0.4

package/dist/tools/create-card-with-tasks.js

@@ -0,0 +1,81 @@
+import { z } from "zod";
+import { createCard } from "../operations/cards.js";
+import { createTask } from "../operations/tasks.js";
+import { createComment } from "../operations/comments.js";
+/**
+ * Zod schema for the createCardWithTasks function parameters
+ * @property {string} listId - The ID of the list to create the card in
+ * @property {string} name - The name of the card
+ * @property {string} [description] - The description of the card
+ * @property {string[]} [tasks] - Array of task descriptions to create
+ * @property {string} [comment] - Optional comment to add to the card
+ * @property {number} [position] - Optional position for the card in the list
+ */
+export const createCardWithTasksSchema = z.object({
+    listId: z.string().describe("The ID of the list to create the card in"),
+    name: z.string().describe("The name of the card"),
+    description: z.string().optional().describe("The description of the card"),
+    tasks: z.array(z.string()).optional().describe("Array of task descriptions to create"),
+    comment: z.string().optional().describe("Optional comment to add to the card"),
+    position: z.number().optional().describe("Optional position for the card in the list"),
+});
+/**
+ * Creates a new card with tasks, description, and optional comment in a single operation
+ *
+ * This function streamlines the process of creating a card with associated tasks and comments
+ * by handling all the necessary API calls in a single function.
+ *
+ * @param {CreateCardWithTasksParams} params - Parameters for creating a card with tasks
+ * @param {string} params.listId - The ID of the list to create the card in
+ * @param {string} params.name - The name of the card
+ * @param {string} [params.description] - The description of the card
+ * @param {string[]} [params.tasks] - Array of task descriptions to create
+ * @param {string} [params.comment] - Optional comment to add to the card
+ * @param {number} [params.position] - Optional position for the card in the list
+ * @returns {Promise<object>} The created card, tasks, and comment
+ * @throws {Error} If there's an error creating the card, tasks, or comment
+ */
+export async function createCardWithTasks(params) {
+    const { listId, name, description, tasks, comment, position = 65535 } = params;
+    try {
+        // Create the card
+        const card = await createCard({
+            listId,
+            name,
+            description: description || "",
+            position,
+        });
+        // Create tasks if provided
+        const createdTasks = [];
+        if (tasks && tasks.length > 0) {
+            for (let i = 0; i < tasks.length; i++) {
+                const taskName = tasks[i];
+                // Calculate position for each task (65535, 131070, 196605, etc.)
+                const taskPosition = 65535 * (i + 1);
+                const task = await createTask({
+                    cardId: card.id,
+                    name: taskName,
+                    position: taskPosition,
+                });
+                createdTasks.push(task);
+            }
+        }
+        // Add a comment if provided
+        let createdComment = null;
+        if (comment) {
+            createdComment = await createComment({
+                cardId: card.id,
+                text: comment,
+            });
+        }
+        return {
+            card,
+            tasks: createdTasks,
+            comment: createdComment,
+        };
+    }
+    catch (error) {
+        console.error("Error in createCardWithTasks:", error);
+        throw error;
+    }
+}

package/dist/tools/generateProjectDocs.js

@@ -0,0 +1,133 @@
+/**
+ * @fileoverview Tool for generating project documentation
+ * Uses the Project Knowledge Service to create structured markdown docs
+ */
+/**
+ * Generates project documentation using AI reasoning
+ */
+export async function generateProjectDocs(params, projectKnowledgeService, vectorStore) {
+    try {
+        console.error("\n=== Generating Project Documentation ===");
+        console.error(`Project ID: ${params.projectId || "default"}`);
+        console.error(`Force regeneration: ${params.force || false}`);
+        // Get all chunks from the vector store
+        const chunks = await vectorStore.getAllChunks(params.projectId);
+        if (chunks.length === 0) {
+            return {
+                success: false,
+                message: "No indexed code found. Please run memorybank_index_code first to index your project.",
+                result: {
+                    success: false,
+                    documentsGenerated: [],
+                    documentsUpdated: [],
+                    documentsSkipped: [],
+                    totalReasoningTokens: 0,
+                    totalOutputTokens: 0,
+                    errors: ["No chunks available for documentation generation"],
+                },
+                tokenUsage: {
+                    reasoningTokens: 0,
+                    outputTokens: 0,
+                    estimatedCost: "$0.00",
+                },
+            };
+        }
+        console.error(`Found ${chunks.length} code chunks to analyze`);
+        // Generate documents
+        const result = await projectKnowledgeService.generateAllDocuments(chunks, params.force || false);
+        // Calculate estimated cost (approximate rates for gpt-5-mini)
+        // Reasoning tokens are typically more expensive
+        const reasoningCostPer1K = 0.003; // $0.003 per 1K reasoning tokens
+        const outputCostPer1K = 0.012; // $0.012 per 1K output tokens
+        const reasoningCost = (result.totalReasoningTokens / 1000) * reasoningCostPer1K;
+        const outputCost = (result.totalOutputTokens / 1000) * outputCostPer1K;
+        const totalCost = reasoningCost + outputCost;
+        // Build response message
+        let message = "";
+        if (result.documentsGenerated.length > 0) {
+            message += `Generated ${result.documentsGenerated.length} new document(s): ${result.documentsGenerated.join(", ")}. `;
+        }
+        if (result.documentsUpdated.length > 0) {
+            message += `Updated ${result.documentsUpdated.length} document(s): ${result.documentsUpdated.join(", ")}. `;
+        }
+        if (result.documentsSkipped.length > 0) {
+            message += `Skipped ${result.documentsSkipped.length} unchanged document(s). `;
+        }
+        if (result.errors.length > 0) {
+            message += `Errors: ${result.errors.join("; ")}`;
+        }
+        if (!message) {
+            message = "All documents are up to date.";
+        }
+        console.error(`\nGeneration complete:`);
+        console.error(`  - Generated: ${result.documentsGenerated.length}`);
+        console.error(`  - Updated: ${result.documentsUpdated.length}`);
+        console.error(`  - Skipped: ${result.documentsSkipped.length}`);
+        console.error(`  - Reasoning tokens: ${result.totalReasoningTokens}`);
+        console.error(`  - Output tokens: ${result.totalOutputTokens}`);
+        console.error(`  - Estimated cost: $${totalCost.toFixed(4)}`);
+        return {
+            success: result.success,
+            message,
+            result,
+            tokenUsage: {
+                reasoningTokens: result.totalReasoningTokens,
+                outputTokens: result.totalOutputTokens,
+                estimatedCost: `$${totalCost.toFixed(4)}`,
+            },
+        };
+    }
+    catch (error) {
+        console.error(`Error generating project docs: ${error.message}`);
+        return {
+            success: false,
+            message: `Failed to generate project documentation: ${error.message}`,
+            result: {
+                success: false,
+                documentsGenerated: [],
+                documentsUpdated: [],
+                documentsSkipped: [],
+                totalReasoningTokens: 0,
+                totalOutputTokens: 0,
+                errors: [error.message],
+            },
+            tokenUsage: {
+                reasoningTokens: 0,
+                outputTokens: 0,
+                estimatedCost: "$0.00",
+            },
+        };
+    }
+}
+/**
+ * Tool definition for MCP
+ */
+export const generateProjectDocsToolDefinition = {
+    name: "memorybank_generate_project_docs",
+    description: `Genera documentación estructurada del proyecto usando IA con razonamiento avanzado (gpt-5-mini).
+  
+Crea 6 documentos markdown que proporcionan una visión global del proyecto:
+- projectBrief.md: Descripción general del proyecto
+- productContext.md: Perspectiva de negocio y usuarios
+- systemPatterns.md: Patrones de arquitectura y diseño
+- techContext.md: Stack tecnológico y dependencias
+- activeContext.md: Estado actual de desarrollo
+- progress.md: Seguimiento de cambios
+
+Esta herramienta complementa la búsqueda semántica precisa con conocimiento global del proyecto.
+Útil para que agentes menos avanzados comprendan mejor el contexto completo.`,
+    inputSchema: {
+        type: "object",
+        properties: {
+            projectId: {
+                type: "string",
+                description: "ID del proyecto (opcional, usa 'default' si no se especifica)",
+            },
+            force: {
+                type: "boolean",
+                description: "Forzar regeneración de todos los documentos aunque no hayan cambiado",
+                default: false,
+            },
+        },
+    },
+};

package/dist/tools/getProjectDocs.js

@@ -0,0 +1,126 @@
+/**
+ * @fileoverview Tool for reading project documentation
+ * Retrieves generated markdown documents for project context
+ */
+const VALID_DOC_TYPES = [
+    "projectBrief",
+    "productContext",
+    "systemPatterns",
+    "techContext",
+    "activeContext",
+    "progress",
+];
+/**
+ * Retrieves project documentation
+ */
+export async function getProjectDocs(params, projectKnowledgeService) {
+    try {
+        const format = params.format || "full";
+        const requestedDoc = params.document?.toLowerCase();
+        // Check if any documents exist
+        if (!projectKnowledgeService.hasDocuments()) {
+            return {
+                success: false,
+                message: "No project documentation has been generated yet. Run memorybank_generate_project_docs first.",
+                stats: {
+                    documentCount: 0,
+                    totalReasoningTokens: 0,
+                    totalOutputTokens: 0,
+                },
+            };
+        }
+        // Get stats
+        const stats = projectKnowledgeService.getStats();
+        const statsResult = {
+            documentCount: stats.documentCount,
+            totalReasoningTokens: stats.totalReasoningTokens,
+            totalOutputTokens: stats.totalOutputTokens,
+            lastGenerated: stats.lastGenerated?.toISOString(),
+        };
+        // Handle summary request
+        if (requestedDoc === "summary" || format === "summary") {
+            const summary = projectKnowledgeService.getDocumentsSummary();
+            return {
+                success: true,
+                message: `Retrieved summary of ${stats.documentCount} project documents.`,
+                summary,
+                stats: statsResult,
+            };
+        }
+        // Handle "all" or no specific document
+        if (!requestedDoc || requestedDoc === "all") {
+            const documents = projectKnowledgeService.getAllDocuments();
+            return {
+                success: true,
+                message: `Retrieved ${documents.length} project documents.`,
+                documents,
+                stats: statsResult,
+            };
+        }
+        // Handle specific document request
+        // Normalize document name (allow both "projectBrief" and "projectbrief")
+        const normalizedDoc = VALID_DOC_TYPES.find(t => t.toLowerCase() === requestedDoc.replace(".md", "").replace("_", ""));
+        if (!normalizedDoc) {
+            return {
+                success: false,
+                message: `Invalid document type: "${params.document}". Valid types are: ${VALID_DOC_TYPES.join(", ")}`,
+                stats: statsResult,
+            };
+        }
+        const document = projectKnowledgeService.getDocument(normalizedDoc);
+        if (!document) {
+            return {
+                success: false,
+                message: `Document "${normalizedDoc}" has not been generated yet.`,
+                stats: statsResult,
+            };
+        }
+        return {
+            success: true,
+            message: `Retrieved document: ${normalizedDoc}`,
+            documents: [document],
+            stats: statsResult,
+        };
+    }
+    catch (error) {
+        console.error(`Error getting project docs: ${error.message}`);
+        return {
+            success: false,
+            message: `Failed to retrieve project documentation: ${error.message}`,
+        };
+    }
+}
+/**
+ * Tool definition for MCP
+ */
+export const getProjectDocsToolDefinition = {
+    name: "memorybank_get_project_docs",
+    description: `Lee la documentación del proyecto generada por IA.
+
+Recupera documentos markdown estructurados que proporcionan contexto global del proyecto:
+- projectBrief: Descripción general del proyecto
+- productContext: Perspectiva de negocio y usuarios
+- systemPatterns: Patrones de arquitectura y diseño
+- techContext: Stack tecnológico y dependencias
+- activeContext: Estado actual de desarrollo
+- progress: Seguimiento de cambios
+
+Usa esta herramienta al inicio de cada sesión para cargar contexto global.
+Complementa la búsqueda semántica precisa (memorybank_search) con visión de alto nivel.`,
+    inputSchema: {
+        type: "object",
+        properties: {
+            document: {
+                type: "string",
+                description: "Documento específico a recuperar. Opciones: projectBrief, productContext, systemPatterns, techContext, activeContext, progress, all, summary",
+                default: "summary",
+            },
+            format: {
+                type: "string",
+                enum: ["full", "summary"],
+                description: "Formato de salida: 'full' devuelve contenido completo, 'summary' devuelve resumen de todos los docs",
+                default: "full",
+            },
+        },
+    },
+};

package/dist/tools/index.js

@@ -10,3 +10,6 @@ export * from "./readFile.js";
 export * from "./writeFile.js";
 export * from "./getStats.js";
 export * from "./analyzeCoverage.js";
+// Export Project Knowledge Layer tools
+export * from "./generateProjectDocs.js";
+export * from "./getProjectDocs.js";

package/dist/tools/indexCode.js

@@ -21,7 +21,6 @@ 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/dist/tools/searchMemory.js

@@ -18,7 +18,7 @@ export async function searchMemory(params, indexManager) {
         }
         console.error(`\nSearching Memory Bank for: "${params.query}"`);
         console.error(`Top K: ${params.topK || 10}`);
-        console.error(`Min score: ${params.minScore || 0.7}`);
+        console.error(`Min score: ${params.minScore || 0.4}`);
         if (params.filterByFile) {
             console.error(`Filter by file: ${params.filterByFile}`);
         }
@@ -28,7 +28,7 @@ export async function searchMemory(params, indexManager) {
         // Search
         const results = await indexManager.search(params.query, {
             topK: params.topK || 10,
-            minScore: params.minScore !== undefined ? params.minScore : 0.7,
+            minScore: params.minScore !== undefined ? params.minScore : 0.4,
             filterByFile: params.filterByFile,
             filterByLanguage: params.filterByLanguage,
         });

package/dist/tools/workflow-actions.js

@@ -0,0 +1,145 @@
+import { z } from "zod";
+import { getCard, moveCard } from "../operations/cards.js";
+import { createComment } from "../operations/comments.js";
+import { getLists } from "../operations/lists.js";
+import { getBoard } from "../operations/boards.js";
+import { getTask, updateTask } from "../operations/tasks.js";
+/**
+ * Zod schema for the workflow action parameters
+ * @property {string} action - The workflow action to perform (start_working, mark_completed, move_to_testing, move_to_done)
+ * @property {string} cardId - The ID of the card to perform the action on
+ * @property {string} [comment] - Optional comment to add with the action
+ * @property {string[]} [taskIds] - Optional task IDs to mark as completed (for mark_completed action)
+ * @property {string} [boardId] - Optional board ID (if not provided, will attempt to determine from card)
+ */
+export const workflowActionSchema = z.object({
+    action: z.enum([
+        "start_working",
+        "mark_completed",
+        "move_to_testing",
+        "move_to_done",
+    ]).describe("The workflow action to perform"),
+    cardId: z.string().describe("The ID of the card to perform the action on"),
+    comment: z.string().optional().describe("Optional comment to add with the action"),
+    taskIds: z.array(z.string()).optional().describe("Optional task IDs to mark as completed (for mark_completed action)"),
+    boardId: z.string().optional().describe("Optional board ID (if not provided, will attempt to determine from card)"),
+});
+/**
+ * Performs a workflow action on a card (start working, mark completed, move to testing, move to done)
+ *
+ * This function handles common workflow actions for cards in a Kanban board, including
+ * moving cards between lists, marking tasks as completed, and adding comments to document progress.
+ *
+ * @param {WorkflowActionParams} params - Parameters for the workflow action
+ * @param {string} params.action - The workflow action to perform (start_working, mark_completed, move_to_testing, move_to_done)
+ * @param {string} params.cardId - The ID of the card to perform the action on
+ * @param {string} [params.comment] - Optional comment to add with the action
+ * @param {string[]} [params.taskIds] - Optional task IDs to mark as completed (for mark_completed action)
+ * @param {string} [params.boardId] - Optional board ID (if not provided, will attempt to determine from card)
+ * @returns {Promise<object>} The result of the workflow action
+ * @throws {Error} If the card or board is not found, or if the action cannot be performed
+ */
+export async function performWorkflowAction(params) {
+    const { action, cardId, comment, taskIds, boardId: providedBoardId } = params;
+    try {
+        // Get the card details
+        const card = await getCard(cardId);
+        if (!card) {
+            throw new Error(`Card with ID ${cardId} not found`);
+        }
+        // Use the provided boardId or try to determine it
+        let boardId = providedBoardId;
+        if (!boardId) {
+            // Try to get the boardId from the card response
+            // @ts-ignore - Some card responses include boardId
+            boardId = card.boardId;
+        }
+        if (!boardId) {
+            throw new Error(`Could not determine board ID for card ${cardId}. Please provide a boardId parameter.`);
+        }
+        // Get the board
+        const board = await getBoard(boardId);
+        if (!board) {
+            throw new Error(`Board with ID ${boardId} not found`);
+        }
+        // Get all lists on the board
+        const boardLists = await getLists(boardId);
+        // Find the target list based on the action
+        let targetList;
+        let actionComment = comment;
+        switch (action) {
+            case "start_working":
+                targetList = boardLists.find((list) => list.name.toLowerCase() === "in progress");
+                actionComment = comment || "🚀 Started working on this card.";
+                break;
+            case "mark_completed":
+                // This action doesn't move the card, just completes tasks
+                if (taskIds && taskIds.length > 0) {
+                    // Mark all specified tasks as completed
+                    const taskUpdates = await Promise.all(taskIds.map(async (taskId) => {
+                        // First get the task to get its current properties
+                        const task = await getTask(taskId);
+                        // Then update it with the same properties plus isCompleted=true
+                        return updateTask(taskId, {
+                            name: task.name,
+                            position: task.position,
+                            // Use the API's method for marking as completed
+                            // The updateTask function will handle this correctly
+                        });
+                    }));
+                    // Add a comment if provided
+                    if (comment) {
+                        await createComment({
+                            cardId,
+                            text: comment,
+                        });
+                    }
+                    return {
+                        success: true,
+                        action,
+                        cardId,
+                        tasksCompleted: taskUpdates.length,
+                    };
+                }
+                else {
+                    throw new Error("No task IDs provided for mark_completed action");
+                }
+            case "move_to_testing":
+                targetList = boardLists.find((list) => list.name.toLowerCase() === "testing" ||
+                    list.name.toLowerCase() === "review");
+                actionComment = comment ||
+                    "✅ Implementation completed and ready for testing.";
+                break;
+            case "move_to_done":
+                targetList = boardLists.find((list) => list.name.toLowerCase() === "done");
+                actionComment = comment ||
+                    "🎉 All work completed and verified.";
+                break;
+            default:
+                throw new Error(`Unknown action: ${action}`);
+        }
+        if (!targetList) {
+            throw new Error(`Target list not found for action: ${action}`);
+        }
+        // Move the card to the target list
+        const updatedCard = await moveCard(cardId, targetList.id);
+        // Add a comment
+        const newComment = await createComment({
+            cardId,
+            text: actionComment || "",
+        });
+        return {
+            success: true,
+            action,
+            cardId,
+            listId: targetList.id,
+            listName: targetList.name,
+            card: updatedCard,
+            comment: newComment,
+        };
+    }
+    catch (error) {
+        console.error(`Error in performWorkflowAction (${action}):`, error);
+        throw error;
+    }
+}

package/package.json

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