@hauptsache.net/clickup-mcp 1.0.4 → 1.1.0

package/dist/shared/utils.js

@@ -0,0 +1,185 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isTaskId = isTaskId;
+exports.getCurrentUser = getCurrentUser;
+exports.limitImages = limitImages;
+exports.getSpaceDetails = getSpaceDetails;
+exports.getTaskSearchIndex = getTaskSearchIndex;
+const config_1 = require("./config");
+const fuse_js_1 = __importDefault(require("fuse.js"));
+const GLOBAL_REFRESH_INTERVAL = 60000; // 60 seconds - that is the rate limit time frame
+/**
+ * Checks if a string looks like a valid ClickUp task ID
+ * Valid task IDs are 6-9 characters long and contain only alphanumeric characters
+ */
+function isTaskId(str) {
+    // Task IDs are 6-9 characters long and contain only alphanumeric characters
+    return /^[a-z0-9]{6,9}$/i.test(str);
+}
+// Cache for current user info to avoid repeated API calls
+let cachedUserData = null;
+/**
+ * Get current authenticated user information from ClickUp API
+ * Caches the result after first successful fetch to avoid repeated API calls during the session
+ */
+async function getCurrentUser() {
+    // Return cached data if available
+    if (cachedUserData) {
+        return cachedUserData;
+    }
+    const userResponse = await fetch("https://api.clickup.com/api/v2/user", {
+        headers: { Authorization: config_1.CONFIG.apiKey },
+    });
+    if (!userResponse.ok) {
+        throw new Error(`Error fetching user info: ${userResponse.status} ${userResponse.statusText}`);
+    }
+    // Cache the result for future calls
+    cachedUserData = await userResponse.json();
+    return cachedUserData;
+}
+/**
+ * Limits the number of images in the content array, replacing excess images with text placeholders
+ * Prioritizes keeping the most recent images (assumes content is ordered with newest items last)
+ *
+ * @param content Array of content blocks that may contain images
+ * @param maxImages Maximum number of images to keep
+ * @returns Modified content array with limited images
+ */
+function limitImages(content, maxImages) {
+    // Count how many images we have
+    const imageIndices = [];
+    // Find all image blocks
+    content.forEach((block, index) => {
+        if (block.type === "image") {
+            imageIndices.push(index);
+        }
+    });
+    // If we have fewer images than the limit, return the original content
+    if (imageIndices.length <= maxImages) {
+        return content;
+    }
+    // Determine which images to keep (the most recent ones)
+    // We want to keep the last 'maxImages' images
+    const imagesToRemove = imageIndices.slice(0, imageIndices.length - maxImages);
+    // Create a new content array with excess images replaced by text
+    return content.map((block, index) => {
+        if (block.type === "image" && imagesToRemove.includes(index)) {
+            return {
+                type: "text",
+                text: "[Image removed due to size limitations. Only the most recent images are shown.]",
+            };
+        }
+        return block;
+    });
+}
+const spaceCache = new Map(); // Global cache for space details promises
+/**
+ * Function to get space details, using a cache to avoid redundant fetches
+ */
+function getSpaceDetails(spaceId) {
+    if (!spaceId) {
+        return Promise.reject(new Error('Invalid space ID'));
+    }
+    const cachedSpace = spaceCache.get(spaceId);
+    if (cachedSpace) {
+        return cachedSpace;
+    }
+    const fetchPromise = fetch(`https://api.clickup.com/api/v2/space/${spaceId}`, { headers: { Authorization: config_1.CONFIG.apiKey } })
+        .then(res => {
+        if (!res.ok) {
+            throw new Error(`Error fetching space ${spaceId}: ${res.status}`);
+        }
+        return res.json();
+    })
+        .catch(error => {
+        console.error(`Network error fetching space ${spaceId}:`, error);
+        throw new Error(`Error fetching space ${spaceId}: ${error}`);
+    });
+    spaceCache.set(spaceId, fetchPromise);
+    return fetchPromise;
+}
+// Task search index management
+const taskIndices = new Map();
+/**
+ * Get or create a task search index with specified filters
+ */
+async function getTaskSearchIndex(space_ids, list_ids, assignees) {
+    // Create cache key from sorted filter arrays
+    const key = JSON.stringify({
+        space_ids: space_ids?.sort(),
+        list_ids: list_ids?.sort(),
+        assignees: assignees?.sort()
+    });
+    // Check for existing valid index
+    const cachedIndex = taskIndices.get(key);
+    if (cachedIndex) {
+        return cachedIndex;
+    }
+    // Fetch tasks with specified filters
+    console.error(`Refreshing task index for filters: ${key}`);
+    const tasks = await fetchTasks(space_ids, list_ids, assignees);
+    const index = createFuseIndex(tasks);
+    // Store with auto-cleanup
+    taskIndices.set(key, index);
+    setTimeout(() => {
+        taskIndices.delete(key);
+        console.error(`Auto-cleaned index for filters: ${key}`);
+    }, GLOBAL_REFRESH_INTERVAL);
+    console.error(`Task index created with ${tasks.length} tasks`);
+    return index;
+}
+/**
+ * Fetch tasks using team endpoint with dynamic filters
+ */
+async function fetchTasks(space_ids, list_ids, assignees) {
+    const queryParams = ['order_by=updated', 'subtasks=true'];
+    // Add filter parameters
+    if (space_ids?.length) {
+        space_ids.forEach(id => queryParams.push(`space_ids[]=${id}`));
+    }
+    if (list_ids?.length) {
+        list_ids.forEach(id => queryParams.push(`list_ids[]=${id}`));
+    }
+    if (assignees?.length) {
+        assignees.forEach(id => queryParams.push(`assignees[]=${id}`));
+    }
+    const queryString = queryParams.join('&');
+    // Fetch multiple pages in parallel
+    const maxPages = space_ids?.length || list_ids?.length || assignees?.length ? 10 : 30; // Fewer pages for filtered searches
+    const taskListsPromises = [...Array(maxPages)].map(async (_, i) => {
+        const url = `https://api.clickup.com/api/v2/team/${config_1.CONFIG.teamId}/task?${queryString}&page=${i}`;
+        try {
+            const res = await fetch(url, { headers: { Authorization: config_1.CONFIG.apiKey } });
+            return await res.json();
+        }
+        catch (e) {
+            console.error(`Error fetching page ${i}:`, e);
+            return { tasks: [] };
+        }
+    });
+    const taskLists = await Promise.all(taskListsPromises);
+    return taskLists.flatMap(taskList => taskList.tasks || []);
+}
+/**
+ * Create a Fuse index from tasks array
+ */
+function createFuseIndex(tasks) {
+    return new fuse_js_1.default(tasks, {
+        keys: [
+            { name: 'name', weight: 0.7 },
+            { name: 'id', weight: 0.6 },
+            { name: 'text_content', weight: 0.5 },
+            { name: 'tags.name', weight: 0.4 },
+            { name: 'assignees.username', weight: 0.4 },
+            { name: 'list.name', weight: 0.3 },
+            { name: 'folder.name', weight: 0.2 },
+            { name: 'space.name', weight: 0.1 }
+        ],
+        includeScore: true,
+        threshold: 0.4,
+        minMatchCharLength: 2,
+    });
+}

package/dist/tools/list-tools.d.ts

@@ -0,0 +1,4 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerListToolsRead(server: McpServer): void;
+export declare function registerListToolsWrite(server: McpServer): void;
+//# sourceMappingURL=list-tools.d.ts.map

package/dist/tools/list-tools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"list-tools.d.ts","sourceRoot":"","sources":["../../src/tools/list-tools.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAKpE,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,SAAS,QA4OtD;AAED,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,SAAS,QAuEvD"}

package/dist/tools/list-tools.js

@@ -0,0 +1,278 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerListToolsRead = registerListToolsRead;
+exports.registerListToolsWrite = registerListToolsWrite;
+const zod_1 = require("zod");
+const config_1 = require("../shared/config");
+function registerListToolsRead(server) {
+    server.tool("listLists", "Lists all lists and folders in a space. They might also be referred to as boards or tables. Shows both direct lists (folderless) and folders containing lists. If folder_id is provided, lists only the lists within that specific folder.", {
+        space_id: zod_1.z.string().min(1).describe("The ID of the space to list content from"),
+        folder_id: zod_1.z.string().optional().describe("Optional folder ID. If provided, lists only lists within this folder. If not provided, shows both folders and folderless lists in the space."),
+        archived: zod_1.z.boolean().optional().describe("Include archived items (default: false)")
+    }, async ({ space_id, folder_id, archived = false }) => {
+        try {
+            if (folder_id) {
+                // List lists within a specific folder
+                const url = `https://api.clickup.com/api/v2/folder/${folder_id}/list${archived ? '?archived=true' : ''}`;
+                const response = await fetch(url, {
+                    headers: { Authorization: config_1.CONFIG.apiKey },
+                });
+                if (!response.ok) {
+                    const errorText = await response.text();
+                    console.error(`API Error: ${response.status} ${response.statusText}`, errorText);
+                    throw new Error(`Error fetching lists in folder ${folder_id}: ${response.status} ${response.statusText}`);
+                }
+                const data = await response.json();
+                if (!data.lists || !Array.isArray(data.lists)) {
+                    return {
+                        content: [{ type: "text", text: `No lists found in folder ${folder_id}.` }],
+                    };
+                }
+                const listBlocks = data.lists.map((list) => ({
+                    type: "text",
+                    text: [
+                        `type: list`,
+                        `list_id: ${list.id}`,
+                        `name: ${list.name}`,
+                        `space_id: ${list.space?.id || space_id}`,
+                        `folder_id: ${folder_id}`,
+                        `task_count: ${list.task_count || 0}`,
+                        `private: ${list.private || false}`,
+                        ...(list.archived ? ['archived: true'] : []),
+                        ...(list.color ? [`color: ${list.color}`] : []),
+                        ...(list.access ? [`access: ${list.access}`] : []),
+                    ].join('\n')
+                }));
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `Found ${data.lists.length} list(s) in folder ${folder_id}:`
+                        },
+                        ...listBlocks
+                    ],
+                };
+            }
+            else {
+                // List both folders and folderless lists in the space (parallel requests)
+                const archiveQuery = archived ? '?archived=true' : '';
+                const [foldersResponse, listsResponse] = await Promise.all([
+                    fetch(`https://api.clickup.com/api/v2/space/${space_id}/folder${archiveQuery}`, {
+                        headers: { Authorization: config_1.CONFIG.apiKey },
+                    }),
+                    fetch(`https://api.clickup.com/api/v2/space/${space_id}/list${archiveQuery}`, {
+                        headers: { Authorization: config_1.CONFIG.apiKey },
+                    })
+                ]);
+                const results = [];
+                let totalItems = 0;
+                // Process folders
+                if (foldersResponse.ok) {
+                    const foldersData = await foldersResponse.json();
+                    if (foldersData.folders && Array.isArray(foldersData.folders)) {
+                        const folderBlocks = foldersData.folders.map((folder) => ({
+                            type: "text",
+                            text: [
+                                `type: folder`,
+                                `folder_id: ${folder.id}`,
+                                `name: ${folder.name}`,
+                                `space_id: ${space_id}`,
+                                `task_count: ${folder.task_count || 0}`,
+                                `private: ${folder.private || false}`,
+                                ...(folder.archived ? ['archived: true'] : []),
+                                ...(folder.color ? [`color: ${folder.color}`] : []),
+                                `contains_lists: true`
+                            ].join('\n')
+                        }));
+                        results.push(...folderBlocks);
+                        totalItems += foldersData.folders.length;
+                    }
+                }
+                else {
+                    console.warn(`Failed to fetch folders: ${foldersResponse.status} ${foldersResponse.statusText}`);
+                }
+                // Process folderless lists
+                if (listsResponse.ok) {
+                    const listsData = await listsResponse.json();
+                    if (listsData.lists && Array.isArray(listsData.lists)) {
+                        const listBlocks = listsData.lists.map((list) => ({
+                            type: "text",
+                            text: [
+                                `type: list`,
+                                `list_id: ${list.id}`,
+                                `name: ${list.name}`,
+                                `space_id: ${list.space?.id || space_id}`,
+                                `task_count: ${list.task_count || 0}`,
+                                `private: ${list.private || false}`,
+                                ...(list.archived ? ['archived: true'] : []),
+                                ...(list.color ? [`color: ${list.color}`] : []),
+                                ...(list.access ? [`access: ${list.access}`] : []),
+                            ].join('\n')
+                        }));
+                        results.push(...listBlocks);
+                        totalItems += listsData.lists.length;
+                    }
+                }
+                else {
+                    console.warn(`Failed to fetch lists: ${listsResponse.status} ${listsResponse.statusText}`);
+                }
+                if (totalItems === 0) {
+                    return {
+                        content: [{ type: "text", text: `No folders or lists found in space ${space_id}.` }],
+                    };
+                }
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `Found ${totalItems} item(s) in space ${space_id} (folders and lists):`
+                        },
+                        ...results
+                    ],
+                };
+            }
+        }
+        catch (error) {
+            console.error('Error fetching space content:', error);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error fetching space content: ${error instanceof Error ? error.message : 'Unknown error'}`,
+                    },
+                ],
+            };
+        }
+    });
+    server.tool("getListInfo", [
+        "Gets comprehensive information about a list including description and available statuses.",
+        "Use this before creating tasks to understand the list context and available statuses for new tasks.",
+        "IMPORTANT: The list description often contains valuable project context, requirements, or guidelines - read and consider this information when creating or updating tasks in this list."
+    ].join("\n"), {
+        list_id: zod_1.z.string().min(1).describe("The list ID to get information for")
+    }, async ({ list_id }) => {
+        try {
+            // Get list details including statuses (try to get markdown content)
+            const listResponse = await fetch(`https://api.clickup.com/api/v2/list/${list_id}?include_markdown_description=true`, {
+                headers: { Authorization: config_1.CONFIG.apiKey },
+            });
+            if (!listResponse.ok) {
+                throw new Error(`Error fetching list details: ${listResponse.status} ${listResponse.statusText}`);
+            }
+            const listData = await listResponse.json();
+            const responseLines = [
+                `List Information:`,
+                `list_id: ${list_id}`,
+                `name: ${listData.name}`,
+                `folder: ${listData.folder?.name || 'No folder'}`,
+                `space: ${listData.space?.name || 'Unknown'} (${listData.space?.id || 'N/A'})`,
+                `archived: ${listData.archived || false}`,
+                `task_count: ${listData.task_count || 0}`,
+            ];
+            // Add description if available (check both content and markdown fields)
+            const description = listData.markdown_description || listData.markdown_content || listData.content;
+            if (description) {
+                responseLines.push(`description: ${description}`);
+            }
+            // Add available statuses
+            if (listData.statuses && Array.isArray(listData.statuses)) {
+                const statuses = listData.statuses.map((status) => ({
+                    name: status.status,
+                    color: status.color || 'none',
+                    type: status.type || 'custom'
+                }));
+                responseLines.push('');
+                responseLines.push(`Available statuses (${statuses.length} total):`);
+                statuses.forEach((status) => {
+                    responseLines.push(`  - ${status.name} (${status.type})`);
+                });
+                responseLines.push('');
+                responseLines.push(`Valid status names for createTask/updateTask: ${statuses.map((s) => s.name).join(', ')}`);
+            }
+            else {
+                responseLines.push('');
+                responseLines.push('No statuses found for this list.');
+            }
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: responseLines.join('\n')
+                    }
+                ],
+            };
+        }
+        catch (error) {
+            console.error('Error getting list info:', error);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error getting list info: ${error instanceof Error ? error.message : 'Unknown error'}`,
+                    },
+                ],
+            };
+        }
+    });
+}
+function registerListToolsWrite(server) {
+    server.tool("updateListInfo", [
+        "Appends documentation or context to a list's description.",
+        "SAFETY FEATURE: Description updates are APPEND-ONLY to prevent data loss - existing content is preserved.",
+        "Use this to add project context, requirements, or guidelines that LLMs should consider when working with tasks in this list.",
+        "Content is appended in markdown format with timestamp for tracking changes."
+    ].join("\n"), {
+        list_id: zod_1.z.string().min(1).describe("The list ID to update"),
+        append_description: zod_1.z.string().min(1).describe("Markdown content to APPEND to existing list description (preserves existing content for safety)")
+    }, async ({ list_id, append_description }) => {
+        try {
+            // Get current list info including description (try to get markdown content)
+            const listResponse = await fetch(`https://api.clickup.com/api/v2/list/${list_id}?include_markdown_description=true`, {
+                headers: { Authorization: config_1.CONFIG.apiKey },
+            });
+            if (!listResponse.ok) {
+                throw new Error(`Error fetching list: ${listResponse.status} ${listResponse.statusText}`);
+            }
+            const listData = await listResponse.json();
+            // Handle append-only description update with markdown support
+            const currentDescription = listData.markdown_description || listData.markdown_content || listData.content || "";
+            const timestamp = new Date().toISOString().split('T')[0]; // YYYY-MM-DD format
+            const separator = currentDescription.trim() ? "\n\n---\n" : "";
+            const finalDescription = currentDescription + separator + `**Edit (${timestamp}):** ${append_description}`;
+            // Update the list description using markdown_content
+            const updateResponse = await fetch(`https://api.clickup.com/api/v2/list/${list_id}`, {
+                method: 'PUT',
+                headers: {
+                    Authorization: config_1.CONFIG.apiKey,
+                    'Content-Type': 'application/json'
+                },
+                body: JSON.stringify({
+                    markdown_content: finalDescription
+                })
+            });
+            if (!updateResponse.ok) {
+                const errorData = await updateResponse.json().catch(() => ({}));
+                throw new Error(`Error updating list: ${updateResponse.status} ${updateResponse.statusText} - ${JSON.stringify(errorData)}`);
+            }
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Successfully appended content to list "${listData.name}". The new content has been added with timestamp (${timestamp}) while preserving existing description.`,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            console.error('Error updating list info:', error);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error updating list info: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+            };
+        }
+    });
+}

package/dist/tools/search-tools.d.ts

@@ -0,0 +1,3 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerSearchTools(server: McpServer): void;
+//# sourceMappingURL=search-tools.d.ts.map

package/dist/tools/search-tools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"search-tools.d.ts","sourceRoot":"","sources":["../../src/tools/search-tools.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,SAAS,EAAC,MAAM,yCAAyC,CAAC;AAQlE,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,SAAS,QAsMpD"}

package/dist/tools/search-tools.js

@@ -0,0 +1,182 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerSearchTools = registerSearchTools;
+const zod_1 = require("zod");
+const config_1 = require("../shared/config");
+const utils_1 = require("../shared/utils");
+const task_tools_1 = require("./task-tools");
+const MAX_SEARCH_RESULTS = 50;
+function registerSearchTools(server) {
+    // Dynamically construct the searchTasks description
+    const searchTasksDescriptionBase = [
+        "Searches tasks by name, content, assignees, and ID (case insensitive) with fuzzy matching and support for multiple search terms (OR logic).",
+        "Can filter by multiple list_ids, space_ids, todo status, or tasks assigned to the current user. If no search terms provided, returns most recently updated tasks.",
+        // Placeholder for language-specific guidance
+        "You'll get a rough overview of the tasks that match the search terms, sorted by relevance.",
+        "Always use getTaskById to get more specific information if a task is relevant.",
+    ];
+    if (config_1.CONFIG.primaryLanguageHint && config_1.CONFIG.primaryLanguageHint.toLowerCase() !== 'en') {
+        searchTasksDescriptionBase.splice(2, 0, `For optimal results, as your ClickUp tasks may be primarily in '${config_1.CONFIG.primaryLanguageHint}', consider providing search terms in English and '${config_1.CONFIG.primaryLanguageHint}'.`);
+    }
+    server.tool("searchTasks", searchTasksDescriptionBase.join("\n"), {
+        terms: zod_1.z
+            .array(zod_1.z.string())
+            .optional()
+            .describe("Array of search terms (OR logic). Can include task IDs. Optional - if not provided, returns most recent tasks."),
+        list_ids: zod_1.z
+            .array(zod_1.z.string())
+            .optional()
+            .describe("Filter tasks to specific list IDs"),
+        space_ids: zod_1.z
+            .array(zod_1.z.string())
+            .optional()
+            .describe("Filter tasks to specific space IDs"),
+        todo: zod_1.z
+            .boolean()
+            .optional()
+            .describe("Filter for open/todo tasks only (exclude done tasks)"),
+        assigned_to_me: zod_1.z
+            .boolean()
+            .optional()
+            .describe("Filter for tasks assigned to the current user"),
+    }, async ({ terms, list_ids, space_ids, todo, assigned_to_me }) => {
+        // Get current user ID if filtering by assigned_to_me
+        let assignees;
+        if (assigned_to_me) {
+            try {
+                const userData = await (0, utils_1.getCurrentUser)();
+                assignees = [userData.user.id];
+            }
+            catch (error) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: "Error: Failed to get current user information.",
+                        },
+                    ],
+                };
+            }
+        }
+        const searchIndex = await (0, utils_1.getTaskSearchIndex)(space_ids, list_ids, assignees);
+        if (!searchIndex) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: "No tasks available or index could not be built.",
+                    },
+                ],
+            };
+        }
+        // Early return for no search terms
+        if (!terms || terms.length === 0) {
+            let allTasks = searchIndex._docs || [];
+            if (todo) {
+                allTasks = allTasks.filter((task) => task.status.type !== "done");
+            }
+            // Sort by updated date (most recent first) and limit
+            const resultTasks = allTasks
+                .sort((a, b) => {
+                const dateA = parseInt(a.date_updated || "0");
+                const dateB = parseInt(b.date_updated || "0");
+                return dateB - dateA;
+            })
+                .slice(0, MAX_SEARCH_RESULTS);
+            if (resultTasks.length === 0) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: "No tasks found.",
+                        },
+                    ],
+                };
+            }
+            return {
+                content: await Promise.all(resultTasks.map((task) => (0, task_tools_1.generateTaskMetadata)(task))),
+            };
+        }
+        // Filter valid search terms
+        const validTerms = terms.filter(term => term && term.trim().length > 0);
+        if (validTerms.length === 0) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: "No valid search terms provided.",
+                    },
+                ],
+            };
+        }
+        const uniqueResults = new Map();
+        // Search with each term
+        validTerms.forEach(term => {
+            const results = searchIndex.search(term.toLowerCase());
+            results.forEach(result => {
+                if (result.item && typeof result.item.id === 'string') {
+                    const currentScore = result.score ?? 1;
+                    const existing = uniqueResults.get(result.item.id);
+                    if (!existing || currentScore < existing.score) {
+                        uniqueResults.set(result.item.id, {
+                            item: result.item,
+                            score: currentScore
+                        });
+                    }
+                }
+            });
+        });
+        // Task ID Fallback Logic
+        const potentialTaskIds = validTerms.filter(utils_1.isTaskId);
+        const foundTaskIdsByFuse = new Set(Array.from(uniqueResults.keys()).map(id => id.toLowerCase()));
+        const taskIdsToFetchDirectly = potentialTaskIds.filter(id => {
+            const lowerId = id.toLowerCase();
+            return !foundTaskIdsByFuse.has(lowerId);
+        });
+        if (taskIdsToFetchDirectly.length > 0) {
+            console.error(`Attempting direct fetch for task IDs: ${taskIdsToFetchDirectly.join(', ')}`);
+            const directFetchPromises = taskIdsToFetchDirectly.map(async (id) => {
+                try {
+                    const response = await fetch(`https://api.clickup.com/api/v2/task/${id}`, { headers: { Authorization: config_1.CONFIG.apiKey } });
+                    if (response.ok) {
+                        const task = await response.json();
+                        if (task && typeof task.id === 'string') {
+                            const existing = uniqueResults.get(task.id);
+                            if (!existing || 0 < existing.score) {
+                                uniqueResults.set(task.id, { item: task, score: 0 });
+                            }
+                        }
+                        return task;
+                    }
+                    return null;
+                }
+                catch (error) {
+                    console.error(`Error directly fetching task ${id}:`, error);
+                    return null;
+                }
+            });
+            await Promise.all(directFetchPromises);
+        }
+        let resultTasks = Array.from(uniqueResults.values())
+            .sort((a, b) => a.score - b.score)
+            .map(entry => entry.item);
+        if (todo) {
+            resultTasks = resultTasks.filter((task) => task.status.type !== "done");
+        }
+        // Apply result limit
+        resultTasks = resultTasks.slice(0, MAX_SEARCH_RESULTS);
+        if (resultTasks.length === 0) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: "No tasks found matching the search criteria.",
+                    },
+                ],
+            };
+        }
+        return {
+            content: await Promise.all(resultTasks.map((task) => (0, task_tools_1.generateTaskMetadata)(task))),
+        };
+    });
+}

package/dist/tools/space-tools.d.ts

@@ -0,0 +1,3 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerSpaceTools(server: McpServer): void;
+//# sourceMappingURL=space-tools.d.ts.map

package/dist/tools/space-tools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"space-tools.d.ts","sourceRoot":"","sources":["../../src/tools/space-tools.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAKpE,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,SAAS,QAiEnD"}