@grec0/memory-bank-mcp 0.0.2 → 0.0.3

package/dist/operations/tasks.js

@@ -1,238 +0,0 @@
-/**
- * @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/board-summary.js

@@ -1,151 +0,0 @@
-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

@@ -1,106 +0,0 @@
-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

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