@hauptsache.net/clickup-mcp 1.0.0

package/README.md

@@ -0,0 +1,125 @@
+# ClickUp MCP (Model Context Protocol)
+
+A minimal implementation of a Model Context Protocol (MCP) server for ClickUp integration, designed to allow Large Language Models (LLMs) to read ClickUp tasks and data.
+
+The main focus is to represent tickets in a way that is easy for LLMs to process and understand.
+This especially includes images in the description and in comments of tickets,
+which are not that easy to understand by just passing the api responses.
+
+## Overview
+
+This MCP provides a lightweight interface for LLMs to:
+- Retrieve detailed task information by ID
+- Search for tasks using keywords
+- List open tasks assigned to the current user
+
+The implementation includes image handling for task descriptions, allowing LLMs to process both text content and visual information from ClickUp tasks.
+
+## Prerequisites
+
+- Node.js (v16 or higher)
+- A ClickUp account with API access
+- ClickUp API key and Team ID
+
+## Installation
+
+1. Clone this repository
+2. Install dependencies:
+
+```bash
+npm install
+```
+
+3. Build the TypeScript code:
+
+```bash
+npm run build
+```
+
+## Configuration
+
+Set the following environment variables:
+
+- `CLICKUP_API_KEY`: Your ClickUp API key
+- `CLICKUP_TEAM_ID`: Your ClickUp team ID
+
+You can set these variables in your environment or create a `.env` file at the root of the project.
+
+## Usage
+
+### As an MCP Server
+
+To use this as an MCP server with an LLM:
+
+```bash
+npm start
+```
+
+This will start the server using the standard input/output for communication, following the Model Context Protocol.
+
+### CLI Usage
+
+For testing or manual usage, you can use the CLI interface:
+
+```bash
+# List all available tools
+npm run cli
+
+# Get a task by ID
+npm run cli getTaskById id=abc1234
+
+# Search for tasks
+npm run cli searchTask terms="feature|bug|enhancement"
+
+# List open tasks for the current user
+npm run cli listTodo
+```
+
+## Available Tools
+
+### getTaskById
+
+Retrieves a complete ClickUp task with its description, comments, and embedded images.
+
+Parameters:
+- `id`: The 7-9 character ClickUp task ID (without "#" or "CU-" prefix)
+
+### searchTask
+
+Searches for tasks by name with support for multiple search terms (using OR logic).
+
+Parameters:
+- `terms`: Search terms separated by '|' (e.g., 'term1|term2|term3')
+
+### listTodo
+
+Lists all open tasks assigned to the current user.
+
+Parameters: None
+
+## Development
+
+For development with hot reloading:
+
+```bash
+npm run dev
+```
+
+Format code with Prettier:
+
+```bash
+npm run prettier
+```
+
+## How It Works
+
+This MCP implementation:
+
+1. Connects to the ClickUp API using your API key
+2. Provides tools for LLMs to query and process ClickUp data
+3. Handles image processing in Markdown descriptions
+4. Returns structured data in a format optimized for LLM consumption
+
+## License
+
+ISC

package/dist/cli.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=cli.d.ts.map

package/dist/cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":""}

package/dist/cli.js

@@ -0,0 +1,89 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_1 = require("./index");
+async function main() {
+    const args = process.argv.slice(2);
+    if (args.length < 1) {
+        console.error("Usage: npm run cli <tool-name> [param1=value1 param2=value2 ...]");
+        console.error("\nAvailable tools:");
+        // @ts-ignore - Accessing private property for testing purposes
+        const tools = index_1.server._registeredTools;
+        if (tools) {
+            for (const [name, tool] of Object.entries(tools)) {
+                console.error(`  - ${name}: ${tool.description}`);
+                console.error("    Parameters:");
+                // Get parameter information from the inputSchema
+                const shape = tool.inputSchema._def.shape();
+                for (const [paramName, schema] of Object.entries(shape)) {
+                    // @ts-ignore - Accessing schema description
+                    const description = schema.description || "No description";
+                    console.error(`      - ${paramName}: ${description}`);
+                }
+                console.error("");
+            }
+        }
+        process.exit(1);
+    }
+    const toolName = args[0];
+    const params = {};
+    // Parse parameters
+    for (let i = 1; i < args.length; i++) {
+        const arg = args[i];
+        const match = arg.match(/^([^=]+)=(.*)$/);
+        if (match) {
+            const [, key, value] = match;
+            // Try to parse as JSON if it looks like a JSON value
+            try {
+                if (value.startsWith('{') || value.startsWith('[') ||
+                    value === 'true' || value === 'false' ||
+                    !isNaN(Number(value))) {
+                    params[key] = JSON.parse(value);
+                }
+                else {
+                    params[key] = value;
+                }
+            }
+            catch (e) {
+                params[key] = value;
+            }
+        }
+    }
+    try {
+        // @ts-ignore - Accessing private property for testing purposes
+        const tools = index_1.server._registeredTools;
+        if (!tools || !tools[toolName]) {
+            console.error(`Unknown tool: ${toolName}`);
+            process.exit(1);
+        }
+        const tool = tools[toolName];
+        // Validate parameters using the tool's schema
+        try {
+            tool.inputSchema.parse(params);
+        }
+        catch (error) {
+            const validationError = error;
+            console.error("Parameter validation error:", validationError.message);
+            process.exit(1);
+        }
+        // Mock environment variables for testing if they're not set
+        if (!process.env.CLICKUP_API_KEY || !process.env.CLICKUP_TEAM_ID) {
+            console.warn("Warning: Using mock API credentials. This will not return real data.");
+            process.env.CLICKUP_API_KEY = process.env.CLICKUP_API_KEY || 'test_api_key';
+            process.env.CLICKUP_TEAM_ID = process.env.CLICKUP_TEAM_ID || 'test_team_id';
+        }
+        // Call the tool's callback function
+        const result = await tool.callback(params);
+        console.dir(result.content);
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            console.error("Error:", error.message);
+        }
+        else {
+            console.error("Unknown error occurred");
+        }
+        process.exit(1);
+    }
+}
+main().catch(console.error);

package/dist/clickup-text.d.ts

@@ -0,0 +1,45 @@
+import { CallToolResult } from "@modelcontextprotocol/sdk/types";
+/**
+ * Represents a ClickUp text item which can be plain text or an image
+ */
+export interface ClickUpTextItem {
+    text?: string;
+    type?: string;
+    image?: {
+        id?: string;
+        name?: string;
+        title?: string;
+        type?: string;
+        extension?: string;
+        thumbnail_large?: string;
+        thumbnail_medium?: string;
+        thumbnail_small?: string;
+        url: string;
+        uploaded?: boolean;
+    };
+    attributes?: any;
+}
+/**
+ * Represents a ClickUp attachment
+ */
+export interface ClickUpAttachment {
+    thumbnail_large?: string;
+    url: string;
+    [key: string]: any;
+}
+/**
+ * Process an array of ClickUp text items into a structured content format
+ * that includes both text and images in their original sequence
+ *
+ * @param textItems Array of text items from ClickUp API
+ * @returns Promise resolving to an array of content blocks (text and images)
+ */
+export declare function processClickUpText(textItems: ClickUpTextItem[]): Promise<CallToolResult["content"]>;
+/**
+ * Splits markdown text at image references and converts them to image blocks
+ * @param markdownText The markdown text to process
+ * @param attachments Array of attachments from the Clickup API
+ * @returns Array of content blocks (text and images)
+ */
+export declare function processClickUpMarkdown(markdownText: string, attachments: ClickUpAttachment[]): Promise<CallToolResult["content"]>;
+//# sourceMappingURL=clickup-text.d.ts.map

package/dist/clickup-text.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"clickup-text.d.ts","sourceRoot":"","sources":["../src/clickup-text.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,iCAAiC,CAAC;AAGjE;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE;QACN,EAAE,CAAC,EAAE,MAAM,CAAC;QACZ,IAAI,CAAC,EAAE,MAAM,CAAC;QACd,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,IAAI,CAAC,EAAE,MAAM,CAAC;QACd,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,eAAe,CAAC,EAAE,MAAM,CAAC;QACzB,gBAAgB,CAAC,EAAE,MAAM,CAAC;QAC1B,eAAe,CAAC,EAAE,MAAM,CAAC;QACzB,GAAG,EAAE,MAAM,CAAC;QACZ,QAAQ,CAAC,EAAE,OAAO,CAAC;KACpB,CAAC;IACF,UAAU,CAAC,EAAE,GAAG,CAAC;CAClB;AAED;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,GAAG,EAAE,MAAM,CAAC;IACZ,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAC;CACpB;AAED;;;;;;GAMG;AACH,wBAAsB,kBAAkB,CACtC,SAAS,EAAE,eAAe,EAAE,GAC3B,OAAO,CAAC,cAAc,CAAC,SAAS,CAAC,CAAC,CAiDpC;AAED;;;;;GAKG;AACH,wBAAsB,sBAAsB,CAC1C,YAAY,EAAE,MAAM,EACpB,WAAW,EAAE,iBAAiB,EAAE,GAC/B,OAAO,CAAC,cAAc,CAAC,SAAS,CAAC,CAAC,CAsEpC"}

package/dist/clickup-text.js

@@ -0,0 +1,131 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processClickUpText = processClickUpText;
+exports.processClickUpMarkdown = processClickUpMarkdown;
+const buffer_1 = require("buffer");
+/**
+ * Process an array of ClickUp text items into a structured content format
+ * that includes both text and images in their original sequence
+ *
+ * @param textItems Array of text items from ClickUp API
+ * @returns Promise resolving to an array of content blocks (text and images)
+ */
+async function processClickUpText(textItems) {
+    const contentBlocks = [];
+    let currentTextBlock = "";
+    for (let i = 0; i < textItems.length; i++) {
+        const item = textItems[i];
+        // Handle image items
+        if (item.type === "image" && item.image && item.image.thumbnail_large) {
+            // If we have accumulated text, add it as a text block before adding the image
+            if (currentTextBlock.trim()) {
+                contentBlocks.push(Promise.resolve({
+                    type: "text",
+                    text: currentTextBlock.trim(),
+                }));
+            }
+            // Reset current text block after pushing it
+            currentTextBlock = "";
+            // Add this image as an image block
+            if (typeof item.image.thumbnail_large === "string") {
+                contentBlocks.push(loadImageContentBlock(item.image.thumbnail_large, {
+                    type: "text",
+                    text: item.text || "Image",
+                }));
+            }
+        }
+        // Handle text items
+        else if (item.text !== undefined) {
+            currentTextBlock += item.text;
+        }
+    }
+    // Add any remaining text
+    if (currentTextBlock.trim()) {
+        contentBlocks.push(Promise.resolve({
+            type: "text",
+            text: currentTextBlock.trim(),
+        }));
+    }
+    return Promise.all(contentBlocks);
+}
+/**
+ * Splits markdown text at image references and converts them to image blocks
+ * @param markdownText The markdown text to process
+ * @param attachments Array of attachments from the Clickup API
+ * @returns Array of content blocks (text and images)
+ */
+async function processClickUpMarkdown(markdownText, attachments) {
+    const contentBlocks = [];
+    let currentTextBlock = "";
+    // Create a map of attachment URLs to their thumbnail_large URLs for easy lookup
+    const thumbnailMap = new Map();
+    for (const attachment of attachments) {
+        if (typeof attachment.thumbnail_large === "string") {
+            thumbnailMap.set(attachment.url, attachment.thumbnail_large);
+        }
+    }
+    // Regular expression to match markdown image syntax: ![alt text](url)
+    const imageRegex = /!\[([^\]]*)\]\(([^\)]+)\)/g;
+    let lastIndex = 0;
+    let match;
+    while ((match = imageRegex.exec(markdownText)) !== null) {
+        const [fullMatch, altText, imageUrl] = match;
+        // Add text before the image reference to the current text block
+        currentTextBlock += markdownText.substring(lastIndex, match.index);
+        // Check if this image URL exists in our attachments
+        const thumbnailUrl = thumbnailMap.get(imageUrl);
+        if (thumbnailUrl) {
+            // If we have accumulated text, add it as a text block before adding the image
+            if (currentTextBlock.trim()) {
+                contentBlocks.push(Promise.resolve({
+                    type: "text",
+                    text: currentTextBlock.trim(),
+                }));
+            }
+            // Reset current text block after pushing it
+            currentTextBlock = "";
+            // Add this image as an image block
+            contentBlocks.push(loadImageContentBlock(thumbnailUrl, {
+                type: "text",
+                text: fullMatch.trim(),
+            }));
+        }
+        else {
+            // If the image URL doesn't match any attachment, keep the original markdown in the current text block
+            currentTextBlock += fullMatch;
+            console.error(`Image URL ${imageUrl} not found in attachments`, thumbnailMap);
+        }
+        lastIndex = match.index + fullMatch.length;
+    }
+    // Add any remaining text after the last image
+    currentTextBlock += markdownText.substring(lastIndex);
+    if (currentTextBlock.trim()) {
+        contentBlocks.push(Promise.resolve({
+            type: "text",
+            text: currentTextBlock.trim(),
+        }));
+    }
+    return Promise.all(contentBlocks);
+}
+/**
+ * Loads an image from a URL and converts it to a base64-encoded content block
+ *
+ * @param url URL of the image to load
+ * @param fallback Fallback content if image loading fails
+ * @returns Promise resolving to a content block (either image or fallback text)
+ */
+async function loadImageContentBlock(url, fallback) {
+    try {
+        const response = await fetch(url);
+        const imageBuffer = await response.arrayBuffer();
+        return {
+            type: "image",
+            mimeType: response.headers.get("Content-Type") || "image/png",
+            data: buffer_1.Buffer.from(imageBuffer).toString("base64"),
+        };
+    }
+    catch (error) {
+        console.error(`Error fetching image: ${error.message || "Unknown error"}`);
+        return fallback;
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare const server: McpServer;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAgBpE,eAAO,MAAM,MAAM,WAGjB,CAAC"}

package/dist/index.js

@@ -0,0 +1,174 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.server = void 0;
+const mcp_js_1 = require("@modelcontextprotocol/sdk/server/mcp.js");
+const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
+const zod_1 = require("zod");
+const clickup_text_1 = require("./clickup-text");
+const CONFIG = {
+    apiKey: process.env.CLICKUP_API_KEY,
+    teamId: process.env.CLICKUP_TEAM_ID,
+};
+if (!CONFIG.apiKey || !CONFIG.teamId) {
+    throw new Error("Missing Clickup API key or team ID");
+}
+// Create an MCP server
+exports.server = new mcp_js_1.McpServer({
+    name: "Clickup MCP",
+    version: "1.0.0",
+});
+exports.server.tool("getTaskById", "Get a Clickup task with images and comments by ID", {
+    id: zod_1.z
+        .string()
+        .min(7)
+        .max(9)
+        .describe(`The 7-9 character ID of the task to get without a prefix like "#" or "CU-"`),
+}, async ({ id }) => {
+    const [content, comments] = await Promise.all([
+        loadTaskContent(id),
+        loadTaskComments(id),
+    ]);
+    return {
+        content: [...content, ...comments],
+    };
+});
+async function loadTaskContent(id) {
+    const response = await fetch(`https://api.clickup.com/api/v2/task/${id}?include_markdown_description=true`, { headers: { Authorization: CONFIG.apiKey } });
+    const task = await response.json();
+    const content = await (0, clickup_text_1.processClickUpMarkdown)(task.markdown_description || "", task.attachments);
+    // Create the task metadata block
+    const taskMetadata = {
+        type: "text",
+        text: [
+            `task_id: ${task.id}`,
+            `name: ${task.name}`,
+            `status: ${task.status.status}`,
+            `date_created: ${new Date(+task.date_created)}`,
+            `date_updated: ${new Date(+task.date_updated)}`,
+            `creator: ${task.creator.username}`,
+            `list: ${task.list.name} (${task.list.id})`,
+        ].join("\n"),
+    };
+    return [taskMetadata, ...content];
+}
+async function loadTaskComments(id) {
+    const response = await fetch(`https://api.clickup.com/api/v2/task/${id}/comment`, { headers: { Authorization: CONFIG.apiKey } });
+    const comments = await response.json();
+    return Promise.all(comments.comments
+        .sort((a, b) => +a.date - +b.date)
+        .map(async (comment) => {
+        // Create a header for the comment
+        const commentHeader = {
+            type: "text",
+            text: [
+                `comment_id: ${comment.id}`,
+                `date: ${new Date(+comment.date)}`,
+                `user: ${comment.user.username}`,
+            ].join("\n"),
+        };
+        // Process comment items if they exist
+        if (comment.comment && Array.isArray(comment.comment)) {
+            const commentContentBlocks = await (0, clickup_text_1.processClickUpText)(comment.comment);
+            return [commentHeader, ...commentContentBlocks];
+        }
+        else {
+            return [
+                { type: "text", text: commentHeader.text },
+                { type: "text", text: comment.comment_text },
+            ];
+        }
+    }));
+}
+let cachedTasks = [];
+let lastTaskCacheUpdate = 0;
+exports.server.tool("searchTask", [
+    "Searches tasks by name (case insensitive) with support for multiple search terms (OR logic).",
+    "You'll get a rough overview of the tasks that match the search terms.",
+    "Always use getTaskById to get more specific information if a task is relevant.",
+].join("\n"), {
+    terms: zod_1.z
+        .string()
+        .min(3)
+        .describe("Search terms separated by '|' for OR logic (e.g., 'term1|term2|term3')"),
+}, async ({ terms }) => {
+    const timeSinceLastUpdate = Date.now() - lastTaskCacheUpdate;
+    if (timeSinceLastUpdate > 10000) {
+        const taskLists = await Promise.all([...Array(30)].map((_, i) => {
+            return fetch(`https://api.clickup.com/api/v2/team/${CONFIG.teamId}/task?order_by=updated&page=${i}`, { headers: { Authorization: CONFIG.apiKey } }).then((res) => res.json());
+        }));
+        cachedTasks = taskLists.flatMap((taskList) => taskList.tasks);
+        lastTaskCacheUpdate = Date.now();
+    }
+    const searchTerms = terms
+        .split("|")
+        .map((term) => term.trim().toLowerCase());
+    const tasks = cachedTasks.filter((task) => {
+        const taskNameLower = task.name.toLowerCase();
+        return searchTerms.some((term) => taskNameLower.includes(term));
+    });
+    if (tasks.length === 0) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: "No tasks found matching the search terms.",
+                },
+            ],
+        };
+    }
+    return {
+        content: tasks.map((task) => ({
+            type: "text",
+            text: [
+                `task_id: ${task.id}`,
+                `name: ${task.name}`,
+                `status: ${task.status.status}`,
+                `date_created: ${new Date(+task.date_created)}`,
+                `date_updated: ${new Date(+task.date_updated)}`,
+                `creator: ${task.creator.username}`,
+                `list: ${task.list.name} (${task.list.id})`,
+            ].join("\n"),
+        })),
+    };
+});
+exports.server.tool("listTodo", "Lists all open tasks for the current user.", {}, async () => {
+    // fetch current user ID
+    const userResp = await fetch("https://api.clickup.com/api/v2/user", {
+        headers: { Authorization: CONFIG.apiKey },
+    }).then((res) => res.json());
+    const userId = userResp.user.id;
+    // page through team tasks assigned to this user
+    const taskLists = await Promise.all([...Array(10)].map((_, i) => fetch(`https://api.clickup.com/api/v2/team/${CONFIG.teamId}/task?order_by=updated&page=${i}&assignees[]=${userId}`, { headers: { Authorization: CONFIG.apiKey } }).then((res) => res.json())));
+    const tasks = taskLists.flatMap((tl) => tl.tasks);
+    // filter out closed tasks
+    const openTasks = tasks
+        .filter((task) => task.status.type !== "done")
+        .slice(0, 100);
+    if (openTasks.length === 0) {
+        return {
+            content: [
+                { type: "text", text: "No open tasks found for the current user." },
+            ],
+        };
+    }
+    return {
+        content: openTasks.map((task) => ({
+            type: "text",
+            text: [
+                `task_id: ${task.id}`,
+                `name: ${task.name}`,
+                `status: ${task.status.status}`,
+                `date_created: ${new Date(+task.date_created)}`,
+                `date_updated: ${new Date(+task.date_updated)}`,
+                `creator: ${task.creator.username}`,
+                `list: ${task.list.name} (${task.list.id})`,
+            ].join("\n"),
+        })),
+    };
+});
+// Only connect to the transport if this file is being run directly (not imported)
+if (require.main === module) {
+    // Start receiving messages on stdin and sending messages on stdout
+    const transport = new stdio_js_1.StdioServerTransport();
+    exports.server.connect(transport);
+}

package/dist/test-utils.d.ts

@@ -0,0 +1,23 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { CallToolResult } from "@modelcontextprotocol/sdk/types";
+/**
+ * A simple utility to test MCP tools directly without using the StdioServerTransport
+ */
+export declare class ToolTester {
+    private server;
+    constructor(server: McpServer);
+    /**
+     * Test a tool by name with the provided parameters
+     * @param toolName The name of the tool to test
+     * @param params The parameters to pass to the tool
+     * @returns A promise that resolves to the tool's result
+     */
+    testTool(toolName: string, params: Record<string, any>): Promise<CallToolResult>;
+}
+/**
+ * Create a tool tester for the provided server
+ * @param server The MCP server instance
+ * @returns A ToolTester instance
+ */
+export declare function createToolTester(server: McpServer): ToolTester;
+//# sourceMappingURL=test-utils.d.ts.map

package/dist/test-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-utils.d.ts","sourceRoot":"","sources":["../src/test-utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AACpE,OAAO,EAAE,cAAc,EAAE,MAAM,iCAAiC,CAAC;AAEjE;;GAEG;AACH,qBAAa,UAAU;IACrB,OAAO,CAAC,MAAM,CAAY;gBAEd,MAAM,EAAE,SAAS;IAI7B;;;;;OAKG;IACG,QAAQ,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,OAAO,CAAC,cAAc,CAAC;CAwBvF;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,SAAS,GAAG,UAAU,CAE9D"}

package/dist/test-utils.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ToolTester = void 0;
+exports.createToolTester = createToolTester;
+/**
+ * A simple utility to test MCP tools directly without using the StdioServerTransport
+ */
+class ToolTester {
+    constructor(server) {
+        this.server = server;
+    }
+    /**
+     * Test a tool by name with the provided parameters
+     * @param toolName The name of the tool to test
+     * @param params The parameters to pass to the tool
+     * @returns A promise that resolves to the tool's result
+     */
+    async testTool(toolName, params) {
+        // @ts-ignore - Accessing private property for testing purposes
+        const tools = this.server._registeredTools;
+        if (!tools || !tools[toolName]) {
+            throw new Error(`Tool "${toolName}" not found`);
+        }
+        const tool = tools[toolName];
+        // Validate parameters using the tool's schema
+        try {
+            tool.inputSchema.parse(params);
+        }
+        catch (error) {
+            throw new Error(`Parameter validation error: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+        // Call the tool's callback directly with the provided parameters
+        return await tool.callback(params);
+    }
+}
+exports.ToolTester = ToolTester;
+/**
+ * Create a tool tester for the provided server
+ * @param server The MCP server instance
+ * @returns A ToolTester instance
+ */
+function createToolTester(server) {
+    return new ToolTester(server);
+}

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@hauptsache.net/clickup-mcp",
+  "version": "1.0.0",
+  "description": "A minimal implementation of a Model Context Protocol (MCP) server for ClickUp integration",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "dev": "tsc -w & nodemon dist/index.js",
+    "cli": "npx ts-node src/cli.ts",
+    "prettier": "prettier --write src/**/*.ts",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "clickup",
+    "mcp",
+    "model-context-protocol",
+    "llm",
+    "ai"
+  ],
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.9.0",
+    "zod": "^3.24.2"
+  },
+  "devDependencies": {
+    "@types/node": "^22.14.1",
+    "nodemon": "^3.1.9",
+    "prettier": "^3.5.3",
+    "typescript": "^5.8.3"
+  },
+  "engines": {
+    "node": ">=16.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/hauptsacheNet/clickup-mcp.git"
+  },
+  "bugs": {
+    "url": "https://github.com/hauptsacheNet/clickup-mcp/issues"
+  },
+  "homepage": "https://github.com/hauptsacheNet/clickup-mcp#readme"
+}