@grec0/memory-bank-mcp 0.0.2

package/dist/tools/board-summary.js

@@ -0,0 +1,151 @@
+import { z } from "zod";
+// Import functions from operations directory
+import { getBoard } from "../operations/boards.js";
+import { getLists } from "../operations/lists.js";
+import { getCards } from "../operations/cards.js";
+import { getTasks } from "../operations/tasks.js";
+import { getLabels } from "../operations/labels.js";
+import { getComments } from "../operations/comments.js";
+/**
+ * Zod schema for the getBoardSummary function parameters
+ * @property {string} boardId - The ID of the board to get a summary for
+ * @property {boolean} [includeTaskDetails=false] - Whether to include detailed task information for each card
+ * @property {boolean} [includeComments=false] - Whether to include comments for each card
+ */
+export const getBoardSummarySchema = z.object({
+    boardId: z.string().describe("The ID of the board to get a summary for"),
+    includeTaskDetails: z.boolean().optional().default(false).describe("Whether to include detailed task information for each card"),
+    includeComments: z.boolean().optional().default(false).describe("Whether to include comments for each card"),
+});
+/**
+ * Retrieves a comprehensive summary of a board including lists, cards, tasks, and statistics
+ *
+ * This function aggregates data from multiple sources to provide a complete view of a board,
+ * including its lists, cards, tasks, and labels. It also calculates various statistics and
+ * provides workflow state analysis.
+ *
+ * @param {GetBoardSummaryParams} params - Parameters for retrieving board summary
+ * @param {string} params.boardId - The ID of the board to get a summary for
+ * @param {boolean} [params.includeTaskDetails=false] - Whether to include detailed task information for each card
+ * @param {boolean} [params.includeComments=false] - Whether to include comments for each card
+ * @returns {Promise<object>} Comprehensive board summary including lists, cards, tasks, statistics, and workflow state
+ * @throws {Error} If the board is not found
+ */
+export async function getBoardSummary(params) {
+    const { boardId, includeTaskDetails, includeComments } = params;
+    try {
+        // Get the board details
+        const board = await getBoard(boardId);
+        if (!board) {
+            throw new Error(`Board with ID ${boardId} not found`);
+        }
+        // Get all lists on the board
+        const allLists = await getLists(boardId);
+        // Get all cards for each list
+        const listsWithCards = await Promise.all(allLists.map(async (list) => {
+            const listCards = await getCards(list.id);
+            // Get tasks for each card if requested
+            const cardsWithDetails = await Promise.all(listCards.map(async (card) => {
+                let taskDetails = [];
+                if (includeTaskDetails) {
+                    taskDetails = await getTasks(card.id);
+                }
+                // Get comments if requested
+                let cardComments = [];
+                if (includeComments) {
+                    cardComments = await getComments(card.id);
+                }
+                // Calculate task completion percentage
+                const completedTasks = taskDetails.filter((task) => task.isCompleted).length;
+                const totalTasks = taskDetails.length;
+                const completionPercentage = totalTasks > 0
+                    ? Math.round((completedTasks / totalTasks) * 100)
+                    : 0;
+                return {
+                    ...card,
+                    tasks: includeTaskDetails
+                        ? {
+                            items: taskDetails,
+                            total: totalTasks,
+                            completed: completedTasks,
+                            completionPercentage,
+                        }
+                        : undefined,
+                    comments: includeComments
+                        ? cardComments
+                        : undefined,
+                };
+            }));
+            return {
+                ...list,
+                cards: cardsWithDetails,
+                cardCount: cardsWithDetails.length,
+            };
+        }));
+        // Get all labels for the board
+        const boardLabels = await getLabels(boardId);
+        // Calculate overall statistics
+        const totalCards = listsWithCards.reduce((sum, list) => sum + list.cardCount, 0);
+        // Find specific lists by name
+        const backlogList = listsWithCards.find((list) => list.name.toLowerCase() === "backlog");
+        const inProgressList = listsWithCards.find((list) => list.name.toLowerCase() === "in progress");
+        const testingList = listsWithCards.find((list) => list.name.toLowerCase() === "testing");
+        const doneList = listsWithCards.find((list) => list.name.toLowerCase() === "done");
+        // Count cards with specific labels
+        const urgentCards = listsWithCards.flatMap((list) => list.cards)
+            .filter((card) => card.labelIds?.some((labelId) => boardLabels.find((label) => label.id === labelId &&
+            label.name.toLowerCase() === "urgent"))).length;
+        const bugCards = listsWithCards.flatMap((list) => list.cards)
+            .filter((card) => card.labelIds?.some((labelId) => boardLabels.find((label) => label.id === labelId &&
+            label.name.toLowerCase() === "bug"))).length;
+        return {
+            board,
+            lists: listsWithCards,
+            labels: boardLabels,
+            stats: {
+                totalCards,
+                backlogCount: backlogList?.cardCount || 0,
+                inProgressCount: inProgressList?.cardCount || 0,
+                testingCount: testingList?.cardCount || 0,
+                doneCount: doneList?.cardCount || 0,
+                urgentCount: urgentCards,
+                bugCount: bugCards,
+                completionPercentage: totalCards > 0
+                    ? Math.round((doneList?.cardCount || 0) / totalCards * 100)
+                    : 0,
+            },
+            workflowState: {
+                hasCardsInBacklog: (backlogList?.cardCount || 0) > 0,
+                hasCardsInProgress: (inProgressList?.cardCount || 0) > 0,
+                hasCardsInTesting: (testingList?.cardCount || 0) > 0,
+                nextActionSuggestion: getNextActionSuggestion(backlogList?.cardCount || 0, inProgressList?.cardCount || 0, testingList?.cardCount || 0),
+            },
+        };
+    }
+    catch (error) {
+        console.error("Error in getBoardSummary:", error);
+        throw error;
+    }
+}
+/**
+ * Helper function to suggest the next action based on board state
+ *
+ * @param {number} backlogCount - Number of cards in the Backlog list
+ * @param {number} inProgressCount - Number of cards in the In Progress list
+ * @param {number} testingCount - Number of cards in the Testing list
+ * @returns {string} A suggestion for the next action to take
+ */
+function getNextActionSuggestion(backlogCount, inProgressCount, testingCount) {
+    if (testingCount > 0) {
+        return "Review cards in Testing that need feedback";
+    }
+    else if (inProgressCount > 0) {
+        return "Continue working on cards in In Progress";
+    }
+    else if (backlogCount > 0) {
+        return "Start working on a card from Backlog";
+    }
+    else {
+        return "All tasks complete! Create new cards or projects";
+    }
+}

package/dist/tools/card-details.js

@@ -0,0 +1,106 @@
+import { z } from "zod";
+import { getCard } from "../operations/cards.js";
+import { getTasks } from "../operations/tasks.js";
+import { getComments } from "../operations/comments.js";
+import { getLabels } from "../operations/labels.js";
+import { getProjects } from "../operations/projects.js";
+import { getBoards } from "../operations/boards.js";
+import { getLists } from "../operations/lists.js";
+/**
+ * Zod schema for the getCardDetails function parameters
+ * @property {string} cardId - The ID of the card to get details for
+ */
+export const getCardDetailsSchema = z.object({
+    cardId: z.string().describe("The ID of the card to get details for"),
+});
+/**
+ * Retrieves comprehensive details about a card including tasks, comments, labels, and analysis
+ *
+ * This function aggregates data from multiple sources to provide a complete view of a card,
+ * including its tasks, comments, and labels. It also calculates task completion percentage
+ * and performs analysis on the card's status.
+ *
+ * @param {GetCardDetailsParams} params - Parameters for retrieving card details
+ * @param {string} params.cardId - The ID of the card to get details for
+ * @returns {Promise<object>} Comprehensive card details including tasks, comments, labels, and analysis
+ * @throws {Error} If the card is not found or if the board ID cannot be determined
+ */
+export async function getCardDetails(params) {
+    const { cardId } = params;
+    try {
+        // Get the card details
+        const card = await getCard(cardId);
+        if (!card) {
+            throw new Error(`Card with ID ${cardId} not found`);
+        }
+        // Get tasks for the card
+        const tasks = await getTasks(card.id);
+        // Get comments for the card
+        const comments = await getComments(card.id);
+        // Find the board ID by searching through all projects and boards
+        let boardId = null;
+        // Get all projects
+        const projectsResponse = await getProjects(1, 100);
+        const projects = projectsResponse.items;
+        // For each project, get its boards
+        for (const project of projects) {
+            if (boardId)
+                break; // Stop if we already found the board ID
+            const boards = await getBoards(project.id);
+            // For each board, get its lists
+            for (const board of boards) {
+                if (boardId)
+                    break; // Stop if we already found the board ID
+                const lists = await getLists(board.id);
+                // Check if the card's list ID is in this board
+                const matchingList = lists.find((list) => list.id === card.listId);
+                if (matchingList) {
+                    boardId = board.id;
+                    break;
+                }
+            }
+        }
+        if (!boardId) {
+            throw new Error(`Could not determine board ID for card ${cardId}`);
+        }
+        const labels = await getLabels(boardId);
+        // Filter to just the labels assigned to this card
+        // Note: We need to get the labelIds from the card's data
+        // This might require additional API calls or data structure knowledge
+        // For now, we'll return all labels for the board
+        // Calculate task completion percentage
+        const completedTasks = tasks.filter((task) => task.isCompleted).length;
+        const totalTasks = tasks.length;
+        const completionPercentage = totalTasks > 0
+            ? Math.round((completedTasks / totalTasks) * 100)
+            : 0;
+        // Sort comments by date (newest first)
+        const sortedComments = comments.sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime());
+        // Check if the most recent comment is likely from a human (not the LLM)
+        // This is a heuristic and might need adjustment
+        const hasRecentHumanFeedback = sortedComments.length > 0 &&
+            sortedComments[0].data &&
+            !sortedComments[0].data.text.includes("Implemented feature") &&
+            !sortedComments[0].data.text.includes("Awaiting human review");
+        return {
+            card,
+            taskItems: tasks,
+            taskStats: {
+                total: totalTasks,
+                completed: completedTasks,
+                completionPercentage,
+            },
+            comments: sortedComments,
+            labels,
+            analysis: {
+                hasRecentHumanFeedback,
+                isComplete: completionPercentage === 100,
+                needsAttention: hasRecentHumanFeedback || completedTasks === 0,
+            },
+        };
+    }
+    catch (error) {
+        console.error("Error in getCardDetails:", error);
+        throw error;
+    }
+}

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/getStats.js

@@ -0,0 +1,59 @@
+/**
+ * @fileoverview Get stats tool for Memory Bank
+ * Returns statistics about the indexed codebase
+ */
+/**
+ * Gets statistics about the Memory Bank
+ */
+export async function getStats(indexManager, embeddingService) {
+    try {
+        console.error("\nGetting Memory Bank statistics...");
+        // Get index stats
+        const indexStats = await indexManager.getStats();
+        // Get embedding cache stats
+        const cacheStats = embeddingService.getCacheStats();
+        const stats = {
+            totalFiles: indexStats.totalFiles,
+            totalChunks: indexStats.totalChunks,
+            lastIndexed: indexStats.lastIndexed?.toISOString(),
+            languages: indexStats.languages,
+            pendingFiles: indexStats.pendingFiles,
+            embeddingCache: cacheStats.size > 0 ? cacheStats : undefined,
+        };
+        // Format message
+        let message = `Memory Bank contains ${stats.totalChunks} chunk(s) from ${stats.totalFiles} file(s)`;
+        if (stats.lastIndexed) {
+            const lastIndexedDate = new Date(stats.lastIndexed);
+            const now = new Date();
+            const diffMs = now.getTime() - lastIndexedDate.getTime();
+            const diffMins = Math.floor(diffMs / 60000);
+            if (diffMins < 60) {
+                message += `, last indexed ${diffMins} minute(s) ago`;
+            }
+            else {
+                const diffHours = Math.floor(diffMins / 60);
+                message += `, last indexed ${diffHours} hour(s) ago`;
+            }
+        }
+        if (stats.pendingFiles && stats.pendingFiles.length > 0) {
+            message += `. ${stats.pendingFiles.length} file(s) pending reindexing`;
+        }
+        console.error(message);
+        console.error(`Languages: ${Object.keys(stats.languages).join(", ")}`);
+        if (stats.embeddingCache) {
+            console.error(`Embedding cache: ${stats.embeddingCache.size} cached`);
+        }
+        return {
+            success: true,
+            stats,
+            message,
+        };
+    }
+    catch (error) {
+        console.error(`Error in getStats tool: ${error}`);
+        return {
+            success: false,
+            message: `Failed to get stats: ${error}`,
+        };
+    }
+}

package/dist/tools/index.js

@@ -0,0 +1,12 @@
+/**
+ * @fileoverview Tools module for the Memory Bank MCP server
+ *
+ * This module exports tools for semantic code indexing and retrieval.
+ */
+// Export all Memory Bank tools
+export * from "./indexCode.js";
+export * from "./searchMemory.js";
+export * from "./readFile.js";
+export * from "./writeFile.js";
+export * from "./getStats.js";
+export * from "./analyzeCoverage.js";

package/dist/tools/indexCode.js

@@ -0,0 +1,53 @@
+/**
+ * @fileoverview Index code tool for Memory Bank
+ * Indexes code files semantically
+ */
+import * as path from "path";
+/**
+ * Indexes code from a directory or file
+ */
+export async function indexCode(params, indexManager, workspaceRoot) {
+    try {
+        // Determine path to index
+        const targetPath = params.path
+            ? path.isAbsolute(params.path)
+                ? params.path
+                : path.join(workspaceRoot, params.path)
+            : workspaceRoot;
+        console.error(`\nIndexing code at: ${targetPath}`);
+        console.error(`Workspace root: ${workspaceRoot}`);
+        console.error(`Recursive: ${params.recursive !== false}`);
+        console.error(`Force reindex: ${params.forceReindex || false}`);
+        // Run indexing
+        const result = await indexManager.indexFiles({
+            rootPath: targetPath,
+            recursive: params.recursive !== false,
+            forceReindex: params.forceReindex || false,
+        });
+        // Format result
+        const message = result.filesProcessed > 0
+            ? `Successfully indexed ${result.filesProcessed} file(s), created ${result.chunksCreated} chunk(s) in ${(result.duration / 1000).toFixed(2)}s`
+            : result.errors.length > 0
+                ? `Indexing completed with errors`
+                : `No files needed indexing (all up to date)`;
+        return {
+            success: result.errors.length === 0,
+            filesProcessed: result.filesProcessed,
+            chunksCreated: result.chunksCreated,
+            duration: result.duration,
+            errors: result.errors.length > 0 ? result.errors : undefined,
+            message,
+        };
+    }
+    catch (error) {
+        console.error(`Error in indexCode tool: ${error}`);
+        return {
+            success: false,
+            filesProcessed: 0,
+            chunksCreated: 0,
+            duration: 0,
+            errors: [String(error)],
+            message: `Failed to index code: ${error}`,
+        };
+    }
+}

package/dist/tools/readFile.js

@@ -0,0 +1,69 @@
+/**
+ * @fileoverview Read file tool for Memory Bank
+ * Reads files from the workspace
+ */
+import * as fs from "fs";
+import * as path from "path";
+/**
+ * Reads a file from the workspace
+ */
+export async function readFile(params, workspaceRoot) {
+    try {
+        // Resolve file path
+        const filePath = path.isAbsolute(params.path)
+            ? params.path
+            : path.join(workspaceRoot, params.path);
+        // Check if file exists
+        if (!fs.existsSync(filePath)) {
+            return {
+                success: false,
+                filePath: params.path,
+                message: `File not found: ${params.path}`,
+            };
+        }
+        // Check if it's a file
+        const stats = fs.statSync(filePath);
+        if (!stats.isFile()) {
+            return {
+                success: false,
+                filePath: params.path,
+                message: `Path is not a file: ${params.path}`,
+            };
+        }
+        // Read file
+        const content = fs.readFileSync(filePath, "utf-8");
+        const lines = content.split("\n");
+        const totalLines = lines.length;
+        // Apply line range if specified
+        let finalContent = content;
+        let linesRead;
+        if (params.startLine !== undefined || params.endLine !== undefined) {
+            const start = Math.max(0, (params.startLine || 1) - 1);
+            const end = Math.min(totalLines, params.endLine || totalLines);
+            finalContent = lines.slice(start, end).join("\n");
+            linesRead = { start: start + 1, end };
+        }
+        const message = linesRead
+            ? `Read lines ${linesRead.start}-${linesRead.end} from ${params.path} (${totalLines} total lines)`
+            : `Read ${params.path} (${totalLines} lines, ${stats.size} bytes)`;
+        console.error(message);
+        return {
+            success: true,
+            content: finalContent,
+            filePath: params.path,
+            totalLines,
+            linesRead,
+            size: stats.size,
+            lastModified: stats.mtime,
+            message,
+        };
+    }
+    catch (error) {
+        console.error(`Error in readFile tool: ${error}`);
+        return {
+            success: false,
+            filePath: params.path,
+            message: `Failed to read file: ${error}`,
+        };
+    }
+}

package/dist/tools/searchMemory.js

@@ -0,0 +1,60 @@
+/**
+ * @fileoverview Search memory tool for Memory Bank
+ * Searches code semantically using vector similarity
+ */
+/**
+ * Searches the Memory Bank for relevant code
+ */
+export async function searchMemory(params, indexManager) {
+    try {
+        if (!params.query || params.query.trim() === "") {
+            return {
+                success: false,
+                results: [],
+                count: 0,
+                query: params.query || "",
+                message: "Query cannot be empty",
+            };
+        }
+        console.error(`\nSearching Memory Bank for: "${params.query}"`);
+        console.error(`Top K: ${params.topK || 10}`);
+        console.error(`Min score: ${params.minScore || 0.7}`);
+        if (params.filterByFile) {
+            console.error(`Filter by file: ${params.filterByFile}`);
+        }
+        if (params.filterByLanguage) {
+            console.error(`Filter by language: ${params.filterByLanguage}`);
+        }
+        // Search
+        const results = await indexManager.search(params.query, {
+            topK: params.topK || 10,
+            minScore: params.minScore !== undefined ? params.minScore : 0.7,
+            filterByFile: params.filterByFile,
+            filterByLanguage: params.filterByLanguage,
+        });
+        console.error(`Found ${results.length} result(s)`);
+        // Format message
+        let message = `Found ${results.length} result(s)`;
+        if (results.length > 0) {
+            const avgScore = results.reduce((sum, r) => sum + r.score, 0) / results.length;
+            message += ` (avg score: ${avgScore.toFixed(3)})`;
+        }
+        return {
+            success: true,
+            results,
+            count: results.length,
+            query: params.query,
+            message,
+        };
+    }
+    catch (error) {
+        console.error(`Error in searchMemory tool: ${error}`);
+        return {
+            success: false,
+            results: [],
+            count: 0,
+            query: params.query || "",
+            message: `Search failed: ${error}`,
+        };
+    }
+}