@grec0/memory-bank-mcp 0.0.2

package/dist/operations/comments.js

@@ -0,0 +1,249 @@
+/**
+ * @fileoverview Comment operations for the MCP Kanban server
+ *
+ * This module provides functions for interacting with comments in the Planka Kanban board,
+ * including creating, retrieving, updating, and deleting comments on cards.
+ */
+import { z } from "zod";
+import { plankaRequest } from "../common/utils.js";
+// Schema definitions
+/**
+ * Schema for creating a new comment
+ * @property {string} cardId - The ID of the card to create the comment on
+ * @property {string} text - The text content of the comment
+ */
+export const CreateCommentSchema = z.object({
+    cardId: z.string().describe("Card ID"),
+    text: z.string().describe("Comment text"),
+});
+/**
+ * Schema for retrieving comments from a card
+ * @property {string} cardId - The ID of the card to get comments from
+ */
+export const GetCommentsSchema = z.object({
+    cardId: z.string().describe("Card ID"),
+});
+/**
+ * Schema for retrieving a specific comment
+ * @property {string} id - The ID of the comment to retrieve
+ */
+export const GetCommentSchema = z.object({
+    id: z.string().describe("Comment ID"),
+});
+/**
+ * Schema for updating a comment
+ * @property {string} id - The ID of the comment to update
+ * @property {string} text - The new text content for the comment
+ */
+export const UpdateCommentSchema = z.object({
+    id: z.string().describe("Comment ID"),
+    text: z.string().describe("Comment text"),
+});
+/**
+ * Schema for deleting a comment
+ * @property {string} id - The ID of the comment to delete
+ */
+export const DeleteCommentSchema = z.object({
+    id: z.string().describe("Comment ID"),
+});
+// Comment action schema
+const CommentActionSchema = z.object({
+    id: z.string(),
+    type: z.literal("commentCard"),
+    data: z.object({
+        text: z.string(),
+    }),
+    cardId: z.string(),
+    userId: z.string(),
+    createdAt: z.string(),
+    updatedAt: z.string().nullable(),
+});
+// Response schemas
+const CommentActionsResponseSchema = z.object({
+    items: z.array(CommentActionSchema),
+    included: z.record(z.any()).optional(),
+});
+const CommentActionResponseSchema = z.object({
+    item: CommentActionSchema,
+    included: z.record(z.any()).optional(),
+});
+// Function implementations
+/**
+ * Creates a new comment on a card
+ *
+ * @param {CreateCommentOptions} options - Options for creating the comment
+ * @param {string} options.cardId - The ID of the card to create the comment on
+ * @param {string} options.text - The text content of the comment
+ * @returns {Promise<object>} The created comment
+ * @throws {Error} If the comment creation fails
+ */
+export async function createComment(options) {
+    try {
+        const response = await plankaRequest(`/api/cards/${options.cardId}/comment-actions`, {
+            method: "POST",
+            body: {
+                text: options.text,
+            },
+        });
+        const parsedResponse = CommentActionResponseSchema.parse(response);
+        return parsedResponse.item;
+    }
+    catch (error) {
+        throw new Error(`Failed to create comment: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+/**
+ * Retrieves all comments for a specific card
+ *
+ * @param {string} cardId - The ID of the card to get comments for
+ * @returns {Promise<Array<object>>} Array of comments on the card
+ * @throws {Error} If retrieving comments fails
+ */
+export async function getComments(cardId) {
+    try {
+        const response = await plankaRequest(`/api/cards/${cardId}/actions`);
+        try {
+            // Try to parse as a CommentsResponseSchema first
+            const parsedResponse = CommentActionsResponseSchema.parse(response);
+            // Filter only comment actions
+            if (parsedResponse.items && Array.isArray(parsedResponse.items)) {
+                return parsedResponse.items.filter((item) => item.type === "commentCard");
+            }
+            return parsedResponse.items;
+        }
+        catch (parseError) {
+            // If that fails, try to parse as an array directly
+            if (Array.isArray(response)) {
+                const items = z.array(CommentActionSchema).parse(response);
+                // Filter only comment actions
+                return items.filter((item) => item.type === "commentCard");
+            }
+            // If we get here, we couldn't parse the response in any expected format
+            throw new Error(`Could not parse comments response: ${JSON.stringify(response)}`);
+        }
+    }
+    catch (error) {
+        // If all else fails, return an empty array
+        return [];
+    }
+}
+/**
+ * Retrieves a specific comment by ID
+ *
+ * @param {string} id - The ID of the comment to retrieve
+ * @returns {Promise<object>} The requested comment
+ * @throws {Error} If retrieving the comment fails
+ */
+export async function getComment(id) {
+    try {
+        // Get all projects which includes boards
+        const projectsResponse = await plankaRequest(`/api/projects`);
+        if (!projectsResponse ||
+            typeof projectsResponse !== "object" ||
+            !("included" in projectsResponse) ||
+            !projectsResponse.included ||
+            typeof projectsResponse.included !== "object") {
+            throw new Error("Failed to get projects");
+        }
+        const included = projectsResponse.included;
+        // Get all boards
+        if (!("boards" in included) || !Array.isArray(included.boards)) {
+            throw new Error("No boards found");
+        }
+        const boards = included.boards;
+        // Check each board for cards
+        for (const board of boards) {
+            if (typeof board !== "object" || board === null || !("id" in board)) {
+                continue;
+            }
+            const boardId = board.id;
+            // Get the board details which includes cards
+            const boardResponse = await plankaRequest(`/api/boards/${boardId}`);
+            if (!boardResponse ||
+                typeof boardResponse !== "object" ||
+                !("included" in boardResponse) ||
+                !boardResponse.included ||
+                typeof boardResponse.included !== "object") {
+                continue;
+            }
+            const boardIncluded = boardResponse.included;
+            if (!("cards" in boardIncluded) ||
+                !Array.isArray(boardIncluded.cards)) {
+                continue;
+            }
+            const cards = boardIncluded.cards;
+            // Check each card for the comment
+            for (const card of cards) {
+                if (typeof card !== "object" || card === null || !("id" in card)) {
+                    continue;
+                }
+                const cardId = card.id;
+                // Get the card actions
+                const actionsResponse = await plankaRequest(`/api/cards/${cardId}/actions`);
+                if (!actionsResponse ||
+                    typeof actionsResponse !== "object" ||
+                    !("items" in actionsResponse) ||
+                    !Array.isArray(actionsResponse.items)) {
+                    continue;
+                }
+                const actions = actionsResponse.items;
+                // Find the comment with the matching ID
+                const comment = actions.find((action) => typeof action === "object" &&
+                    action !== null &&
+                    "id" in action &&
+                    action.id === id &&
+                    "type" in action &&
+                    action.type === "commentCard");
+                if (comment) {
+                    return comment;
+                }
+            }
+        }
+        throw new Error(`Comment not found: ${id}`);
+    }
+    catch (error) {
+        throw new Error(`Failed to get comment: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+/**
+ * Updates a comment's text content
+ *
+ * @param {string} id - The ID of the comment to update
+ * @param {Partial<Omit<CreateCommentOptions, "cardId">>} options - The properties to update
+ * @param {string} options.text - The new text content for the comment
+ * @returns {Promise<object>} The updated comment
+ * @throws {Error} If updating the comment fails
+ */
+export async function updateComment(id, options) {
+    try {
+        const response = await plankaRequest(`/api/comment-actions/${id}`, {
+            method: "PATCH",
+            body: {
+                text: options.text,
+            },
+        });
+        const parsedResponse = CommentActionResponseSchema.parse(response);
+        return parsedResponse.item;
+    }
+    catch (error) {
+        throw new Error(`Failed to update comment: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+/**
+ * Deletes a comment by ID
+ *
+ * @param {string} id - The ID of the comment to delete
+ * @returns {Promise<{success: boolean}>} Success indicator
+ * @throws {Error} If deleting the comment fails
+ */
+export async function deleteComment(id) {
+    try {
+        await plankaRequest(`/api/comment-actions/${id}`, {
+            method: "DELETE",
+        });
+        return { success: true };
+    }
+    catch (error) {
+        throw new Error(`Failed to delete comment: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}

package/dist/operations/labels.js

@@ -0,0 +1,258 @@
+/**
+ * @fileoverview Label operations for the MCP Kanban server
+ *
+ * This module provides functions for interacting with labels in the Planka Kanban board,
+ * including creating, retrieving, updating, and deleting labels, as well as
+ * adding and removing labels from cards.
+ */
+import { z } from "zod";
+import { plankaRequest } from "../common/utils.js";
+import { PlankaLabelSchema } from "../common/types.js";
+/**
+ * Valid color options for labels in Planka
+ */
+export const VALID_LABEL_COLORS = [
+    "berry-red",
+    "pumpkin-orange",
+    "lagoon-blue",
+    "pink-tulip",
+    "light-mud",
+    "orange-peel",
+    "bright-moss",
+    "antique-blue",
+    "dark-granite",
+    "lagune-blue",
+    "sunny-grass",
+    "morning-sky",
+    "light-orange",
+    "midnight-blue",
+    "tank-green",
+    "gun-metal",
+    "wet-moss",
+    "red-burgundy",
+    "light-concrete",
+    "apricot-red",
+    "desert-sand",
+    "navy-blue",
+    "egg-yellow",
+    "coral-green",
+    "light-cocoa",
+];
+/**
+ * Schema for creating a new label
+ * @property {string} boardId - The ID of the board to create the label in
+ * @property {string} name - The name of the label
+ * @property {string} color - The color of the label (must be one of the valid colors)
+ * @property {number} [position] - The position of the label in the board (default: 65535)
+ */
+export const CreateLabelSchema = z.object({
+    boardId: z.string().describe("Board ID"),
+    name: z.string().describe("Label name"),
+    color: z.enum(VALID_LABEL_COLORS).describe("Label color"),
+    position: z.number().optional().describe("Label position (default: 65535)"),
+});
+/**
+ * Schema for retrieving labels from a board
+ * @property {string} boardId - The ID of the board to get labels from
+ */
+export const GetLabelsSchema = z.object({
+    boardId: z.string().describe("Board ID"),
+});
+export const GetLabelSchema = z.object({
+    id: z.string().describe("Label ID"),
+});
+/**
+ * Schema for updating a label
+ * @property {string} id - The ID of the label to update
+ * @property {string} [name] - The new name for the label
+ * @property {string} [color] - The new color for the label
+ * @property {number} [position] - The new position for the label
+ */
+export const UpdateLabelSchema = z.object({
+    id: z.string().describe("Label ID"),
+    name: z.string().optional().describe("Label name"),
+    color: z.enum(VALID_LABEL_COLORS).optional().describe("Label color"),
+    position: z.number().optional().describe("Label position"),
+});
+/**
+ * Schema for deleting a label
+ * @property {string} id - The ID of the label to delete
+ */
+export const DeleteLabelSchema = z.object({
+    id: z.string().describe("Label ID"),
+});
+/**
+ * Schema for adding a label to a card
+ * @property {string} cardId - The ID of the card to add the label to
+ * @property {string} labelId - The ID of the label to add to the card
+ */
+export const AddLabelToCardSchema = z.object({
+    cardId: z.string().describe("Card ID"),
+    labelId: z.string().describe("Label ID"),
+});
+/**
+ * Schema for removing a label from a card
+ * @property {string} cardId - The ID of the card to remove the label from
+ * @property {string} labelId - The ID of the label to remove from the card
+ */
+export const RemoveLabelFromCardSchema = z.object({
+    cardId: z.string().describe("Card ID"),
+    labelId: z.string().describe("Label ID"),
+});
+// Response schemas
+const LabelsResponseSchema = z.object({
+    items: z.array(PlankaLabelSchema),
+    included: z.record(z.any()).optional(),
+});
+const LabelResponseSchema = z.object({
+    item: PlankaLabelSchema,
+    included: z.record(z.any()).optional(),
+});
+const CardLabelResponseSchema = z.object({
+    item: z.object({
+        id: z.string(),
+        cardId: z.string(),
+        labelId: z.string(),
+        createdAt: z.string(),
+        updatedAt: z.string().nullable(),
+    }),
+    included: z.record(z.any()).optional(),
+});
+// Function implementations
+/**
+ * Creates a new label in a board
+ *
+ * @param {CreateLabelOptions} options - Options for creating the label
+ * @param {string} options.boardId - The ID of the board to create the label in
+ * @param {string} options.name - The name of the label
+ * @param {string} options.color - The color of the label
+ * @param {number} [options.position] - The position of the label in the board (default: 65535)
+ * @returns {Promise<object>} The created label
+ * @throws {Error} If the label creation fails
+ */
+export async function createLabel(options) {
+    try {
+        const response = await plankaRequest(`/api/boards/${options.boardId}/labels`, {
+            method: "POST",
+            body: {
+                name: options.name,
+                color: options.color,
+                position: options.position,
+            },
+        });
+        const parsedResponse = LabelResponseSchema.parse(response);
+        return parsedResponse.item;
+    }
+    catch (error) {
+        throw new Error(`Failed to create label: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+/**
+ * Retrieves all labels for a specific board
+ *
+ * @param {string} boardId - The ID of the board to get labels from
+ * @returns {Promise<Array<object>>} Array of labels in the board
+ */
+export async function getLabels(boardId) {
+    try {
+        // Get the board which includes labels in the response
+        const response = await plankaRequest(`/api/boards/${boardId}`);
+        // Check if the response has the expected structure
+        if (response &&
+            typeof response === "object" &&
+            "included" in response &&
+            response.included &&
+            typeof response.included === "object" &&
+            "labels" in response.included) {
+            // Get the labels from the included property
+            const labels = response.included.labels;
+            if (Array.isArray(labels)) {
+                return labels;
+            }
+        }
+        // If we can't find labels in the expected format, return an empty array
+        return [];
+    }
+    catch (error) {
+        // If all else fails, return an empty array
+        return [];
+    }
+}
+/**
+ * Updates a label's properties
+ *
+ * @param {string} id - The ID of the label to update
+ * @param {Partial<Omit<CreateLabelOptions, "boardId">>} options - The properties to update
+ * @returns {Promise<object>} The updated label
+ */
+export async function updateLabel(id, options) {
+    try {
+        const response = await plankaRequest(`/api/labels/${id}`, {
+            method: "PATCH",
+            body: options,
+        });
+        const parsedResponse = LabelResponseSchema.parse(response);
+        return parsedResponse.item;
+    }
+    catch (error) {
+        throw new Error(`Failed to update label: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+/**
+ * Deletes a label by ID
+ *
+ * @param {string} id - The ID of the label to delete
+ * @returns {Promise<{success: boolean}>} Success indicator
+ */
+export async function deleteLabel(id) {
+    try {
+        await plankaRequest(`/api/labels/${id}`, {
+            method: "DELETE",
+        });
+        return { success: true };
+    }
+    catch (error) {
+        throw new Error(`Failed to delete label: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+/**
+ * Adds a label to a card
+ *
+ * @param {string} cardId - The ID of the card to add the label to
+ * @param {string} labelId - The ID of the label to add to the card
+ * @returns {Promise<object>} The created card-label relationship
+ */
+export async function addLabelToCard(cardId, labelId) {
+    try {
+        // The correct endpoint is /api/cards/{cardId}/labels with labelId in the body
+        await plankaRequest(`/api/cards/${cardId}/labels`, {
+            method: "POST",
+            body: {
+                labelId,
+            },
+        });
+        return { success: true };
+    }
+    catch (error) {
+        throw new Error(`Failed to add label to card: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+/**
+ * Removes a label from a card
+ *
+ * @param {string} cardId - The ID of the card to remove the label from
+ * @param {string} labelId - The ID of the label to remove from the card
+ * @returns {Promise<{success: boolean}>} Success indicator
+ */
+export async function removeLabelFromCard(cardId, labelId) {
+    try {
+        // The correct endpoint is /api/cards/{cardId}/labels/{labelId}
+        await plankaRequest(`/api/cards/${cardId}/labels/${labelId}`, {
+            method: "DELETE",
+        });
+        return { success: true };
+    }
+    catch (error) {
+        throw new Error(`Failed to remove label from card: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}

package/dist/operations/lists.js

@@ -0,0 +1,157 @@
+/**
+ * @fileoverview List operations for the MCP Kanban server
+ *
+ * This module provides functions for interacting with lists in the Planka Kanban board,
+ * including creating, retrieving, updating, and deleting lists.
+ */
+import { z } from "zod";
+import { plankaRequest } from "../common/utils.js";
+import { PlankaListSchema } from "../common/types.js";
+// Schema definitions
+/**
+ * Schema for creating a new list
+ * @property {string} boardId - The ID of the board to create the list in
+ * @property {string} name - The name of the list
+ * @property {number} [position] - The position of the list in the board (default: 65535)
+ */
+export const CreateListSchema = z.object({
+    boardId: z.string().describe("Board ID"),
+    name: z.string().describe("List name"),
+    position: z.number().optional().describe("List position (default: 65535)"),
+});
+/**
+ * Schema for retrieving lists from a board
+ * @property {string} boardId - The ID of the board to get lists from
+ */
+export const GetListsSchema = z.object({
+    boardId: z.string().describe("Board ID"),
+});
+/**
+ * Schema for updating a list
+ * @property {string} id - The ID of the list to update
+ * @property {string} [name] - The new name for the list
+ * @property {number} [position] - The new position for the list
+ */
+export const UpdateListSchema = z.object({
+    id: z.string().describe("List ID"),
+    name: z.string().optional().describe("List name"),
+    position: z.number().optional().describe("List position"),
+});
+/**
+ * Schema for deleting a list
+ * @property {string} id - The ID of the list to delete
+ */
+export const DeleteListSchema = z.object({
+    id: z.string().describe("List ID"),
+});
+// Response schemas
+const ListsResponseSchema = z.object({
+    items: z.array(PlankaListSchema),
+    included: z.record(z.any()).optional(),
+});
+const ListResponseSchema = z.object({
+    item: PlankaListSchema,
+    included: z.record(z.any()).optional(),
+});
+// Function implementations
+/**
+ * Creates a new list in a board
+ *
+ * @param {CreateListOptions} options - Options for creating the list
+ * @param {string} options.boardId - The ID of the board to create the list in
+ * @param {string} options.name - The name of the list
+ * @param {number} [options.position] - The position of the list in the board (default: 65535)
+ * @returns {Promise<object>} The created list
+ * @throws {Error} If the list creation fails
+ */
+export async function createList(options) {
+    try {
+        const response = await plankaRequest(`/api/boards/${options.boardId}/lists`, {
+            method: "POST",
+            body: {
+                name: options.name,
+                position: options.position,
+            },
+        });
+        const parsedResponse = ListResponseSchema.parse(response);
+        return parsedResponse.item;
+    }
+    catch (error) {
+        throw new Error(`Failed to create list: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+/**
+ * Retrieves all lists for a specific board
+ *
+ * @param {string} boardId - The ID of the board to get lists from
+ * @returns {Promise<Array<object>>} Array of lists in the board
+ */
+export async function getLists(boardId) {
+    try {
+        // Get the board which includes lists in the response
+        const response = await plankaRequest(`/api/boards/${boardId}`);
+        // Check if the response has the expected structure
+        if (response &&
+            typeof response === "object" &&
+            "included" in response &&
+            response.included &&
+            typeof response.included === "object" &&
+            "lists" in response.included) {
+            // Get the lists from the included property
+            const lists = response.included.lists;
+            if (Array.isArray(lists)) {
+                return lists;
+            }
+        }
+        // If we can't find lists in the expected format, return an empty array
+        return [];
+    }
+    catch (error) {
+        // If all else fails, return an empty array
+        return [];
+    }
+}
+/**
+ * Retrieves a specific list by ID
+ *
+ * @param {string} id - The ID of the list to retrieve
+ * @returns {Promise<object|null>} The requested list or null if not found
+ */
+export async function getList(id) {
+    try {
+        const response = await plankaRequest(`/api/lists/${id}`);
+        const parsedResponse = ListResponseSchema.parse(response);
+        return parsedResponse.item;
+    }
+    catch (error) {
+        console.error(`Error getting list with ID ${id}:`, error);
+        return null;
+    }
+}
+/**
+ * Updates a list's properties
+ *
+ * @param {string} id - The ID of the list to update
+ * @param {Partial<Omit<CreateListOptions, "boardId">>} options - The properties to update
+ * @returns {Promise<object>} The updated list
+ */
+export async function updateList(id, options) {
+    const response = await plankaRequest(`/api/lists/${id}`, {
+        method: "PATCH",
+        body: options,
+    });
+    const parsedResponse = ListResponseSchema.parse(response);
+    return parsedResponse.item;
+}
+/**
+ * Deletes a list by ID
+ *
+ * @param {string} id - The ID of the list to delete
+ * @returns {Promise<{success: boolean}>} Success indicator
+ */
+export async function deleteList(id) {
+    await plankaRequest(`/api/lists/${id}`, {
+        method: "DELETE",
+    });
+    return { success: true };
+}