@grec0/memory-bank-mcp 0.0.2 → 0.0.3

package/dist/operations/boardMemberships.js

@@ -1,186 +0,0 @@
-/**
- * @fileoverview Board membership operations for the MCP Kanban server
- *
- * This module provides functions for managing board memberships in the Planka Kanban system,
- * including creating, retrieving, updating, and deleting board memberships, which control
- * user access and permissions to boards.
- */
-import { z } from "zod";
-import { plankaRequest } from "../common/utils.js";
-// Schema definitions
-/**
- * Schema for creating a new board membership
- * @property {string} boardId - The ID of the board to add the user to
- * @property {string} userId - The ID of the user to add to the board
- * @property {string} role - The role of the user on the board (editor or viewer)
- */
-export const CreateBoardMembershipSchema = z.object({
-    boardId: z.string().describe("Board ID"),
-    userId: z.string().describe("User ID"),
-    role: z.enum(["editor", "viewer"]).describe("Membership role (editor or viewer)"),
-});
-/**
- * Schema for retrieving board memberships
- * @property {string} boardId - The ID of the board to get memberships for
- */
-export const GetBoardMembershipsSchema = z.object({
-    boardId: z.string().describe("Board ID"),
-});
-/**
- * Schema for retrieving a specific board membership
- * @property {string} id - The ID of the board membership to retrieve
- */
-export const GetBoardMembershipSchema = z.object({
-    id: z.string().describe("Board Membership ID"),
-});
-/**
- * Schema for updating a board membership
- * @property {string} id - The ID of the board membership to update
- * @property {string} role - The new role for the user (editor or viewer)
- * @property {boolean} [canComment] - Whether the user can comment on cards
- */
-export const UpdateBoardMembershipSchema = z.object({
-    id: z.string().describe("Board Membership ID"),
-    role: z.enum(["editor", "viewer"]).describe("Membership role (editor or viewer)"),
-    canComment: z.boolean().optional().describe("Whether the user can comment on cards"),
-});
-/**
- * Schema for deleting a board membership
- * @property {string} id - The ID of the board membership to delete
- */
-export const DeleteBoardMembershipSchema = z.object({
-    id: z.string().describe("Board Membership ID"),
-});
-// Board membership schema
-const BoardMembershipSchema = z.object({
-    id: z.string(),
-    boardId: z.string(),
-    userId: z.string(),
-    role: z.string(),
-    canComment: z.boolean().nullable(),
-    createdAt: z.string(),
-    updatedAt: z.string().nullable(),
-});
-// Response schemas
-const BoardMembershipsResponseSchema = z.object({
-    items: z.array(BoardMembershipSchema),
-    included: z.record(z.any()).optional(),
-});
-const BoardMembershipResponseSchema = z.object({
-    item: BoardMembershipSchema,
-    included: z.record(z.any()).optional(),
-});
-// Function implementations
-/**
- * Creates a new board membership (adds a user to a board with specified permissions)
- *
- * @param {CreateBoardMembershipOptions} options - Options for creating the board membership
- * @param {string} options.boardId - The ID of the board to add the user to
- * @param {string} options.userId - The ID of the user to add to the board
- * @param {string} options.role - The role of the user on the board (editor or viewer)
- * @returns {Promise<object>} The created board membership
- * @throws {Error} If the board membership creation fails
- */
-export async function createBoardMembership(options) {
-    try {
-        const response = await plankaRequest(`/api/boards/${options.boardId}/memberships`, {
-            method: "POST",
-            body: {
-                userId: options.userId,
-                role: options.role,
-            },
-        });
-        const parsedResponse = BoardMembershipResponseSchema.parse(response);
-        return parsedResponse.item;
-    }
-    catch (error) {
-        throw new Error(`Failed to create board membership: ${error instanceof Error ? error.message : String(error)}`);
-    }
-}
-/**
- * Retrieves all memberships for a specific board
- *
- * @param {string} boardId - The ID of the board to get memberships for
- * @returns {Promise<Array<object>>} Array of board memberships
- * @throws {Error} If retrieving board memberships fails
- */
-export async function getBoardMemberships(boardId) {
-    try {
-        const response = await plankaRequest(`/api/boards/${boardId}/memberships`);
-        try {
-            // Try to parse as a BoardMembershipsResponseSchema first
-            const parsedResponse = BoardMembershipsResponseSchema.parse(response);
-            return parsedResponse.items;
-        }
-        catch (parseError) {
-            // If that fails, try to parse as an array directly
-            if (Array.isArray(response)) {
-                return z.array(BoardMembershipSchema).parse(response);
-            }
-            // If we get here, we couldn't parse the response in any expected format
-            throw new Error(`Could not parse board memberships response: ${JSON.stringify(response)}`);
-        }
-    }
-    catch (error) {
-        // If all else fails, return an empty array
-        return [];
-    }
-}
-/**
- * Retrieves a specific board membership by ID
- *
- * @param {string} id - The ID of the board membership to retrieve
- * @returns {Promise<object>} The requested board membership
- * @throws {Error} If retrieving the board membership fails
- */
-export async function getBoardMembership(id) {
-    try {
-        const response = await plankaRequest(`/api/board-memberships/${id}`);
-        const parsedResponse = BoardMembershipResponseSchema.parse(response);
-        return parsedResponse.item;
-    }
-    catch (error) {
-        throw new Error(`Failed to get board membership: ${error instanceof Error ? error.message : String(error)}`);
-    }
-}
-/**
- * Updates a board membership's properties (user permissions on a board)
- *
- * @param {string} id - The ID of the board membership to update
- * @param {Partial<Omit<CreateBoardMembershipOptions, "boardId" | "userId">>} options - The properties to update
- * @param {string} [options.role] - The new role for the user (editor or viewer)
- * @param {boolean} [options.canComment] - Whether the user can comment on cards
- * @returns {Promise<object>} The updated board membership
- * @throws {Error} If updating the board membership fails
- */
-export async function updateBoardMembership(id, options) {
-    try {
-        const response = await plankaRequest(`/api/board-memberships/${id}`, {
-            method: "PATCH",
-            body: options,
-        });
-        const parsedResponse = BoardMembershipResponseSchema.parse(response);
-        return parsedResponse.item;
-    }
-    catch (error) {
-        throw new Error(`Failed to update board membership: ${error instanceof Error ? error.message : String(error)}`);
-    }
-}
-/**
- * Deletes a board membership by ID (removes a user from a board)
- *
- * @param {string} id - The ID of the board membership to delete
- * @returns {Promise<{success: boolean}>} Success indicator
- * @throws {Error} If deleting the board membership fails
- */
-export async function deleteBoardMembership(id) {
-    try {
-        await plankaRequest(`/api/board-memberships/${id}`, {
-            method: "DELETE",
-        });
-        return { success: true };
-    }
-    catch (error) {
-        throw new Error(`Failed to delete board membership: ${error instanceof Error ? error.message : String(error)}`);
-    }
-}

package/dist/operations/boards.js

@@ -1,268 +0,0 @@
-/**
- * @fileoverview Board operations for the MCP Kanban server
- *
- * This module provides functions for interacting with boards in the Planka Kanban system,
- * including creating, retrieving, updating, and deleting boards. It also handles
- * the creation of default lists and labels when a new board is created.
- */
-import { z } from "zod";
-import { plankaRequest } from "../common/utils.js";
-import { PlankaBoardSchema } from "../common/types.js";
-import { getAdminUserId } from "../common/setup.js";
-import * as boardMemberships from "./boardMemberships.js";
-import * as lists from "./lists.js";
-import * as labels from "./labels.js";
-// Schema definitions
-/**
- * Schema for creating a new board
- * @property {string} projectId - The ID of the project to create the board in
- * @property {string} name - The name of the board
- * @property {number} [position] - The position of the board in the project (default: 65535)
- */
-export const CreateBoardSchema = z.object({
-    projectId: z.string().describe("Project ID"),
-    name: z.string().describe("Board name"),
-    position: z.number().default(65535).describe("Board position (default: 65535)"),
-});
-/**
- * Schema for retrieving boards from a project
- * @property {string} projectId - The ID of the project to get boards from
- */
-export const GetBoardsSchema = z.object({
-    projectId: z.string().describe("Project ID"),
-});
-/**
- * Schema for retrieving a specific board
- * @property {string} id - The ID of the board to retrieve
- */
-export const GetBoardSchema = z.object({
-    id: z.string().describe("Board ID"),
-});
-/**
- * Schema for updating a board
- * @property {string} id - The ID of the board to update
- * @property {string} [name] - The new name for the board
- * @property {number} [position] - The new position for the board
- * @property {string} [type] - The type of the board
- */
-export const UpdateBoardSchema = z.object({
-    id: z.string().describe("Board ID"),
-    name: z.string().optional().describe("Board name"),
-    position: z.number().optional().describe("Board position"),
-    type: z.string().optional().describe("Board type"),
-});
-/**
- * Schema for deleting a board
- * @property {string} id - The ID of the board to delete
- */
-export const DeleteBoardSchema = z.object({
-    id: z.string().describe("Board ID"),
-});
-// Response schemas
-const BoardsResponseSchema = z.object({
-    items: z.array(PlankaBoardSchema),
-    included: z.record(z.any()).optional(),
-});
-const BoardResponseSchema = z.object({
-    item: PlankaBoardSchema,
-    included: z.record(z.any()).optional(),
-});
-// Function implementations
-/**
- * Creates default lists for a new board
- *
- * @param {string} boardId - The ID of the board to create lists for
- * @returns {Promise<void>}
- * @private
- */
-async function createDefaultLists(boardId) {
-    try {
-        const defaultLists = [
-            { name: "Backlog", position: 65535 },
-            { name: "To Do", position: 131070 },
-            { name: "In Progress", position: 196605 },
-            { name: "On Hold", position: 262140 },
-            { name: "Review", position: 327675 },
-            { name: "Done", position: 393210 },
-        ];
-        for (const list of defaultLists) {
-            await lists.createList({
-                boardId,
-                name: list.name,
-                position: list.position,
-            });
-        }
-    }
-    catch (error) {
-        console.error(`Error creating default lists for board ${boardId}:`, error instanceof Error ? error.message : String(error));
-    }
-}
-/**
- * Creates default labels for a new board
- * @param boardId The ID of the board to create labels for
- */
-async function createDefaultLabels(boardId) {
-    try {
-        // Priority labels
-        const priorityLabels = [
-            { name: "P0: Critical", color: "berry-red", position: 65535 },
-            { name: "P1: High", color: "red-burgundy", position: 131070 },
-            { name: "P2: Medium", color: "pumpkin-orange", position: 196605 },
-            { name: "P3: Low", color: "sunny-grass", position: 262140 },
-        ];
-        // Type labels
-        const typeLabels = [
-            { name: "Bug", color: "coral-green", position: 327675 },
-            { name: "Feature", color: "lagoon-blue", position: 393210 },
-            { name: "Enhancement", color: "bright-moss", position: 458745 },
-            { name: "Documentation", color: "light-orange", position: 524280 },
-        ];
-        // Status labels
-        const statusLabels = [
-            { name: "Blocked", color: "midnight-blue", position: 589815 },
-            { name: "Needs Info", color: "desert-sand", position: 655350 },
-            { name: "Ready", color: "egg-yellow", position: 720885 },
-        ];
-        // Combine all labels
-        const defaultLabels = [
-            ...priorityLabels,
-            ...typeLabels,
-            ...statusLabels,
-        ];
-        for (const label of defaultLabels) {
-            await labels.createLabel({
-                boardId,
-                name: label.name,
-                color: label.color, // Type assertion needed due to enum constraints
-                position: label.position,
-            });
-        }
-    }
-    catch (error) {
-        console.error(`Error creating default labels for board ${boardId}:`, error instanceof Error ? error.message : String(error));
-    }
-}
-/**
- * Creates a new board in a project with default lists and labels
- *
- * @param {CreateBoardOptions} options - Options for creating the board
- * @param {string} options.projectId - The ID of the project to create the board in
- * @param {string} options.name - The name of the board
- * @param {number} [options.position] - The position of the board in the project
- * @returns {Promise<object>} The created board
- * @throws {Error} If the board creation fails
- */
-export async function createBoard(options) {
-    try {
-        const response = await plankaRequest(`/api/projects/${options.projectId}/boards`, {
-            method: "POST",
-            body: {
-                name: options.name,
-                position: options.position,
-            },
-        });
-        const parsedResponse = BoardResponseSchema.parse(response);
-        const board = parsedResponse.item;
-        // Add the admin user as a board member
-        try {
-            const adminUserId = await getAdminUserId();
-            if (adminUserId) {
-                await boardMemberships.createBoardMembership({
-                    boardId: board.id,
-                    userId: adminUserId,
-                    role: "editor",
-                });
-            }
-            else {
-                console.error("Could not add admin user as board member: Admin user ID not found");
-            }
-        }
-        catch (error) {
-            console.error("Error adding admin user as board member:", error);
-        }
-        // Create default lists and labels
-        await createDefaultLists(board.id);
-        await createDefaultLabels(board.id);
-        return board;
-    }
-    catch (error) {
-        throw new Error(`Failed to create board: ${error instanceof Error ? error.message : String(error)}`);
-    }
-}
-/**
- * Retrieves all boards for a specific project
- *
- * @param {string} projectId - The ID of the project to get boards from
- * @returns {Promise<Array<object>>} Array of boards in the project
- * @throws {Error} If retrieving boards fails
- */
-export async function getBoards(projectId) {
-    try {
-        // Get all projects which includes boards in the response
-        const response = await plankaRequest(`/api/projects`);
-        // Check if the response has the expected structure
-        if (response &&
-            typeof response === "object" &&
-            "included" in response &&
-            response.included &&
-            typeof response.included === "object" &&
-            "boards" in response.included) {
-            // Filter boards by projectId
-            const allBoards = response.included.boards;
-            if (Array.isArray(allBoards)) {
-                const filteredBoards = allBoards.filter((board) => typeof board === "object" &&
-                    board !== null &&
-                    "projectId" in board &&
-                    board.projectId === projectId);
-                return filteredBoards;
-            }
-        }
-        // If we can't find boards in the expected format, return an empty array
-        return [];
-    }
-    catch (error) {
-        // If all else fails, return an empty array
-        return [];
-    }
-}
-/**
- * Retrieves a specific board by ID
- *
- * @param {string} id - The ID of the board to retrieve
- * @returns {Promise<object>} The requested board
- * @throws {Error} If retrieving the board fails
- */
-export async function getBoard(id) {
-    const response = await plankaRequest(`/api/boards/${id}`);
-    const parsedResponse = BoardResponseSchema.parse(response);
-    return parsedResponse.item;
-}
-/**
- * Updates a board's properties
- *
- * @param {string} id - The ID of the board to update
- * @param {Partial<Omit<CreateBoardOptions, "projectId">>} options - The properties to update
- * @returns {Promise<object>} The updated board
- * @throws {Error} If updating the board fails
- */
-export async function updateBoard(id, options) {
-    const response = await plankaRequest(`/api/boards/${id}`, {
-        method: "PATCH",
-        body: options,
-    });
-    const parsedResponse = BoardResponseSchema.parse(response);
-    return parsedResponse.item;
-}
-/**
- * Deletes a board by ID
- *
- * @param {string} id - The ID of the board to delete
- * @returns {Promise<{success: boolean}>} Success indicator
- * @throws {Error} If deleting the board fails
- */
-export async function deleteBoard(id) {
-    await plankaRequest(`/api/boards/${id}`, {
-        method: "DELETE",
-    });
-    return { success: true };
-}