@grec0/memory-bank-mcp 0.0.2 → 0.0.3

package/dist/operations/labels.js

@@ -1,258 +0,0 @@
-/**
- * @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

@@ -1,157 +0,0 @@
-/**
- * @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 };
-}

package/dist/operations/projects.js

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