@hauptsache.net/clickup-mcp 1.0.3 → 1.0.4

package/README.md

@@ -69,6 +69,24 @@ Once connected, your AI assistant can:
 
 The AI will retrieve the information directly from ClickUp, including all text content, comments, and images, providing you with comprehensive assistance on your tasks.
 
+## Configuration
+
+This MCP server can be configured using environment variables:
+
+- `CLICKUP_API_KEY`: (Required) Your ClickUp API key.
+- `CLICKUP_TEAM_ID`: (Required) Your ClickUp Team ID (formerly Workspace ID).
+- `MAX_IMAGES`: (Optional) The maximum number of images to return for a task in `getTaskById`. Defaults to 4.
+- `CLICKUP_PRIMARY_LANGUAGE`: (Optional) A hint for the primary language used in your ClickUp tasks (e.g., "de" for German, "en" for English). This helps the `searchTask` tool provide more tailored guidance in its description for multilingual searches.
+- `LANG`: (Optional) If `CLICKUP_PRIMARY_LANGUAGE` is not set, the MCP will check this standard environment variable (e.g., "en_US.UTF-8", "de_DE") as a fallback to infer the primary language.
+
+### Language-Aware Search Guidance
+
+The `searchTask` tool's description will dynamically adjust based on the detected primary language:
+- If `CLICKUP_PRIMARY_LANGUAGE` or `LANG` suggests a known primary language (e.g., German), the tool's description will specifically recommend providing search terms in both English and that detected language (e.g., German) for optimal results.
+- If no primary language is detected, a more general recommendation for multilingual workspaces will be provided.
+
+This feature aims to improve search effectiveness when the language of user queries (often English) differs from the language of the tasks in ClickUp, without making the MCP itself perform translations. The responsibility for providing bilingual search terms still lies with the agent calling the MCP, but the MCP offers more specific advice if it has a language hint.
+
 ## License
 
 ISC

package/dist/cli.d.ts

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

package/dist/cli.d.ts.map

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

package/dist/cli.js

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+require("dotenv/config"); // Load .env file
 const index_1 = require("./index");
 async function main() {
     const args = process.argv.slice(2);
@@ -12,13 +13,17 @@ async function main() {
         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}`);
+                if (tool.inputSchema && tool.inputSchema._def && typeof tool.inputSchema._def.shape === 'function') {
+                    console.error("    Parameters:");
+                    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}`);
+                    }
+                }
+                else {
+                    console.error("    Parameters: None");
                 }
                 console.error("");
             }
@@ -57,13 +62,20 @@ async function main() {
             process.exit(1);
         }
         const tool = tools[toolName];
-        // Validate parameters using the tool's schema
-        try {
-            tool.inputSchema.parse(params);
+        // Validate parameters using the tool's schema, if it exists
+        if (tool.inputSchema) {
+            try {
+                tool.inputSchema.parse(params);
+            }
+            catch (error) {
+                const validationError = error;
+                console.error("Parameter validation error:", validationError.message);
+                process.exit(1);
+            }
         }
-        catch (error) {
-            const validationError = error;
-            console.error("Parameter validation error:", validationError.message);
+        else if (Object.keys(params).length > 0) {
+            // If there's no schema, but parameters were provided, it's an error
+            console.error(`Error: Tool '${toolName}' does not accept any parameters, but parameters were provided.`);
             process.exit(1);
         }
         // Mock environment variables for testing if they're not set

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

@@ -1 +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"}
+{"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,CAqDpC;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

@@ -35,9 +35,13 @@ async function processClickUpText(textItems) {
             }
         }
         // Handle text items
-        else if (item.text !== undefined) {
+        else if (typeof item.text === "string") {
             currentTextBlock += item.text;
         }
+        // Handle other types of items like bookmarks or whatever clickup can think of
+        else {
+            currentTextBlock += JSON.stringify(item);
+        }
     }
     // Add any remaining text
     if (currentTextBlock.trim()) {

package/dist/index.d.ts.map

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

package/dist/index.js

@@ -1,15 +1,31 @@
 #!/usr/bin/env node
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 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 fuse_js_1 = __importDefault(require("fuse.js"));
+// --- End Simplified Event Wrapper ---
+const rawPrimaryLang = process.env.CLICKUP_PRIMARY_LANGUAGE || process.env.LANG;
+let detectedLanguageHint = undefined;
+if (rawPrimaryLang) {
+    // Extract the primary language part (e.g., 'en' from 'en_US.UTF-8' or 'en-GB')
+    // and convert to lowercase.
+    const langPart = rawPrimaryLang.match(/^[a-zA-Z]{2,3}/);
+    if (langPart) {
+        detectedLanguageHint = langPart[0].toLowerCase();
+    }
+}
 const CONFIG = {
     apiKey: process.env.CLICKUP_API_KEY,
     teamId: process.env.CLICKUP_TEAM_ID,
     maxImages: process.env.MAX_IMAGES ? parseInt(process.env.MAX_IMAGES) : 4,
+    primaryLanguageHint: detectedLanguageHint, // Store the cleaned code directly
 };
 if (!CONFIG.apiKey || !CONFIG.teamId) {
     throw new Error("Missing Clickup API key or team ID");
@@ -37,21 +53,124 @@ exports.server.tool("getTaskById", "Get a Clickup task with images and comments
     })
         .describe(`The 7-9 character ID of the task to get without a prefix like "#", "CU-" or "https://app.clickup.com/t/"`),
 }, async ({ id }) => {
-    const [content, comments] = await Promise.all([
-        loadTaskContent(id),
-        loadTaskComments(id),
+    // 1. Load base task content, comment events, and status change events in parallel
+    const [taskDetailContentBlocks, commentEvents, statusChangeEvents] = await Promise.all([
+        loadTaskContent(id), // Returns Promise<ContentBlock[]>
+        loadTaskComments(id), // Returns Promise<DatedContentEvent[]>
+        loadTimeInStatusHistory(id), // Returns Promise<DatedContentEvent[]>
     ]);
-    // Combine all content and limit the number of images
-    const allContent = [...content, ...comments];
-    const limitedContent = limitImages(allContent, CONFIG.maxImages);
+    // 2. Combine comment and status change events
+    const allDatedEvents = [...commentEvents, ...statusChangeEvents];
+    // 3. Sort all dated events chronologically
+    allDatedEvents.sort((a, b) => {
+        const dateA = a.date ? parseInt(a.date) : 0;
+        const dateB = b.date ? parseInt(b.date) : 0;
+        return dateA - dateB;
+    });
+    // 4. Flatten sorted events into a single ContentBlock stream
+    let processedEventBlocks = [];
+    for (const event of allDatedEvents) {
+        processedEventBlocks.push(...event.contentBlocks);
+    }
+    // 5. Combine task details with processed event blocks
+    const allContentBlocks = [...taskDetailContentBlocks, ...processedEventBlocks];
+    // 6. Limit images
+    const limitedContent = limitImages(allContentBlocks, CONFIG.maxImages);
     return {
         content: limitedContent,
     };
 });
+async function loadTaskContent(taskId) {
+    const response = await fetch(`https://api.clickup.com/api/v2/task/${taskId}?include_markdown_description=true&include_subtasks=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 using the helper function
+    const taskMetadata = await generateTaskMetadata(task);
+    return [taskMetadata, ...content];
+}
+async function loadTaskComments(id) {
+    const response = await fetch(`https://api.clickup.com/api/v2/task/${id}/comment?start_date=0`, // Ensure all comments are fetched
+    { headers: { Authorization: CONFIG.apiKey } });
+    if (!response.ok) {
+        console.error(`Error fetching comments for task ${id}: ${response.status} ${response.statusText}`);
+        return [];
+    }
+    const commentsData = await response.json();
+    if (!commentsData.comments || !Array.isArray(commentsData.comments)) {
+        console.error(`Unexpected comment data structure for task ${id}`);
+        return [];
+    }
+    const commentEvents = await Promise.all(commentsData.comments.map(async (comment) => {
+        const headerBlock = {
+            type: "text",
+            text: `Comment by ${comment.user.username} on ${new Date(+comment.date)}:`,
+        };
+        const commentBodyBlocks = await (0, clickup_text_1.processClickUpText)(comment.comment);
+        return {
+            date: comment.date, // String timestamp from ClickUp for sorting
+            contentBlocks: [headerBlock, ...commentBodyBlocks],
+        };
+    }));
+    return commentEvents;
+}
+async function loadTimeInStatusHistory(taskId) {
+    const url = `https://api.clickup.com/api/v2/task/${taskId}/time_in_status`;
+    try {
+        const response = await fetch(url, { headers: { Authorization: CONFIG.apiKey } });
+        if (!response.ok) {
+            console.error(`Error fetching time in status for task ${taskId}: ${response.status} ${response.statusText}`);
+            return [];
+        }
+        // Using 'any' for less strict typing as per user preference, but keeping structure for clarity
+        const data = await response.json();
+        const events = [];
+        const processStatusEntry = (entry) => {
+            if (!entry || !entry.total_time || !entry.total_time.since || !entry.status)
+                return null;
+            return {
+                date: entry.total_time.since,
+                contentBlocks: [{
+                        type: "text",
+                        text: `Status set to '${entry.status}' on ${new Date(+entry.total_time.since)}`,
+                    }],
+            };
+        };
+        if (data.status_history && Array.isArray(data.status_history)) {
+            data.status_history.forEach((historyEntry) => {
+                const event = processStatusEntry(historyEntry);
+                if (event)
+                    events.push(event);
+            });
+        }
+        if (data.current_status) {
+            const event = processStatusEntry(data.current_status);
+            // Ensure current_status is only added if it's distinct or more recent than the last history item.
+            // The deduplication logic below handles if it's the same as the last history entry.
+            if (event)
+                events.push(event);
+        }
+        // Deduplicate events based on date and status name to avoid adding current_status if it's identical to the last history entry
+        const uniqueEvents = Array.from(new Map(events.map(event => [`${event.date}-${event.contentBlocks[0]?.text}`, event] // Keying by date and text content of first block
+        )).values());
+        return uniqueEvents;
+    }
+    catch (error) {
+        console.error(`Exception fetching time in status for task ${taskId}:`, error);
+        return [];
+    }
+}
 /**
  * Helper function to generate consistent task metadata
  */
-function generateTaskMetadata(task) {
+async function generateTaskMetadata(task) {
+    let spaceName = task.space?.name || 'Unknown Space';
+    let spaceIdForDisplay = task.space?.id || 'N/A';
+    if (spaceName === 'Unknown Space' && task.space?.id) {
+        const spaceDetails = await getSpaceDetails(task.space.id);
+        if (spaceDetails && spaceDetails.name) {
+            spaceName = spaceDetails.name;
+        }
+    }
     const metadataLines = [
         `task_id: ${task.id}`,
         `name: ${task.name}`,
@@ -59,7 +178,9 @@ function generateTaskMetadata(task) {
         `date_created: ${new Date(+task.date_created)}`,
         `date_updated: ${new Date(+task.date_updated)}`,
         `creator: ${task.creator.username}`,
+        `assignee: ${task.assignees.map((a) => a.username).join(', ')}`,
         `list: ${task.list.name} (${task.list.id})`,
+        `space: ${spaceName} (${spaceIdForDisplay})`,
     ];
     // Add parent task information if it exists
     if (typeof task.parent === "string") {
@@ -74,42 +195,35 @@ function generateTaskMetadata(task) {
         text: metadataLines.join("\n"),
     };
 }
-async function loadTaskContent(id) {
-    const response = await fetch(`https://api.clickup.com/api/v2/task/${id}?include_markdown_description=true&include_subtasks=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 using the helper function
-    const taskMetadata = generateTaskMetadata(task);
-    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 comments by date, newest first to prioritize recent images
-        .sort((a, b) => +b.date - +a.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 },
-            ];
-        }
-    }));
+const spaceCache = new Map(); // Global cache for space details promises
+/**
+ * Function to get space details, using a cache to avoid redundant fetches
+ */
+async function getSpaceDetails(spaceId) {
+    if (!spaceId) {
+        return null;
+    }
+    if (!spaceCache.has(spaceId)) {
+        const fetchPromise = fetch(`https://api.clickup.com/api/v2/space/${spaceId}`, {
+            headers: { Authorization: CONFIG.apiKey },
+        })
+            .then(res => {
+            if (!res.ok) {
+                // Don't cache failed requests, or handle errors more gracefully
+                console.error(`Error fetching space ${spaceId}: ${res.status}`);
+                spaceCache.delete(spaceId); // Allow retry on next call
+                return null;
+            }
+            return res.json();
+        })
+            .catch(error => {
+            console.error(`Network error fetching space ${spaceId}:`, error);
+            spaceCache.delete(spaceId); // Allow retry on next call
+            return null;
+        });
+        spaceCache.set(spaceId, fetchPromise);
+    }
+    return spaceCache.get(spaceId);
 }
 /**
  * Limits the number of images in the content array, replacing excess images with text placeholders
@@ -146,65 +260,122 @@ function limitImages(content, maxImages) {
         return block;
     });
 }
-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.",
+let taskSearchIndex = null;
+let lastIndexUpdateTime = 0;
+const INDEX_REFRESH_INTERVAL = 60000; // 60 seconds
+const MAX_SEARCH_RESULTS = 50;
+// Dynamically construct the searchTask description
+const searchTaskDescriptionBase = [
+    "Searches tasks by name, content, assignees, and ID (case insensitive) with fuzzy matching and support for multiple search terms (OR logic).",
+    // 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.",
-].join("\n"), {
+];
+if (CONFIG.primaryLanguageHint && CONFIG.primaryLanguageHint.toLowerCase() !== 'en') {
+    searchTaskDescriptionBase.splice(1, 0, `For optimal results, as your ClickUp tasks may be primarily in '${CONFIG.primaryLanguageHint}', consider providing search terms in English and '${CONFIG.primaryLanguageHint}'.`);
+}
+exports.server.tool("searchTask", searchTaskDescriptionBase.join("\n"), {
     terms: zod_1.z
         .string()
         .min(3)
-        .describe("Search terms separated by '|' for OR logic (e.g., 'term1|term2|term3')"),
+        .describe("Search terms separated by '|' for OR logic (e.g., 'term1|term2|term3') or a direct task ID"),
 }, 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());
-    // Check if any search term looks like a task ID
-    const potentialTaskIds = searchTerms.filter(isTaskId);
-    // Fetch tasks from cache that match search terms
-    const tasksFromCache = cachedTasks.filter((task) => {
-        const taskNameLower = task.name.toLowerCase();
-        const taskId = task.id.toLowerCase();
-        return searchTerms.some((term) => taskNameLower.includes(term) || taskId.includes(term));
-    });
-    // Fetch tasks by ID directly if they look like task IDs and they're not already in the cache
-    const tasksToFetch = potentialTaskIds.filter(id => {
-        // Check if this ID is already in the tasksFromCache
-        return !tasksFromCache.some(task => task.id.toLowerCase() === id.toLowerCase());
-    });
-    const taskPromises = tasksToFetch.map(async (id) => {
-        try {
-            // Fetch task directly from API
-            const response = await fetch(`https://api.clickup.com/api/v2/task/${id}`, { headers: { Authorization: CONFIG.apiKey } });
-            if (!response.ok)
-                return null;
-            const task = await response.json();
-            return task;
+    const now = Date.now();
+    if (!taskSearchIndex || (now - lastIndexUpdateTime > INDEX_REFRESH_INTERVAL)) {
+        console.error('Refreshing ClickUp task index...');
+        const taskListsPromises = [...Array(30)].map((_, i) => {
+            return fetch(`https://api.clickup.com/api/v2/team/${CONFIG.teamId}/task?order_by=updated&page=${i}&subtasks=true`, { headers: { Authorization: CONFIG.apiKey } }).then((res) => res.json()).catch(e => {
+                console.error(`Error fetching page ${i} for index:`, e);
+                return { tasks: [] };
+            });
+        });
+        const taskLists = await Promise.all(taskListsPromises);
+        const allFetchedTasks = taskLists.flatMap(taskList => taskList.tasks);
+        if (allFetchedTasks.length > 0) {
+            taskSearchIndex = new fuse_js_1.default(allFetchedTasks, {
+                keys: [
+                    { name: 'name', weight: 0.7 },
+                    { name: 'id', weight: 0.6 },
+                    { name: 'text_content', weight: 0.5 }, // Task description/content
+                    { name: 'tags.name', weight: 0.4 }, // Task Tags
+                    { name: 'assignees.username', weight: 0.4 }, // Task Assignees
+                    { name: 'list.name', weight: 0.3 }, // Name of the List the task is in
+                    { name: 'folder.name', weight: 0.2 }, // Name of the Folder the task is in
+                    { name: 'space.name', weight: 0.1 } // Name of the Space the task is in
+                ],
+                includeScore: true,
+                threshold: 0.4,
+                minMatchCharLength: 2,
+            });
+            lastIndexUpdateTime = now;
+            console.error(`Task index refreshed with ${allFetchedTasks.length} tasks.`);
         }
-        catch (error) {
-            console.error(`Error fetching task ${id}:`, error);
-            return null;
+        else {
+            console.error('No tasks fetched to build search index.');
+            // Potentially keep the old index if fetching failed, or clear it
+            // For now, if fetching fails to get any tasks, the index won't update.
         }
+    }
+    const searchTermsArray = terms
+        .split("|")
+        .map((term) => term.trim())
+        .filter(term => term.length > 0);
+    if (searchTermsArray.length === 0) {
+        return { content: [{ type: "text", text: "No search terms provided." }] };
+    }
+    const uniqueResults = new Map();
+    if (taskSearchIndex) {
+        searchTermsArray.forEach(term => {
+            const results = taskSearchIndex.search(term.toLowerCase());
+            results.forEach(result => {
+                if (result.item && typeof result.item.id === 'string') {
+                    const currentScore = result.score ?? 1; // Default to 1 if undefined
+                    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 = searchTermsArray.filter(isTaskId);
+    const foundTaskIdsByFuse = new Set(Array.from(uniqueResults.keys()).map(id => id.toLowerCase())); // Store lowercase for comparison
+    // Filter task IDs that were not found by Fuse, comparing case-insensitively
+    const taskIdsToFetchDirectly = potentialTaskIds.filter(id => {
+        const lowerId = id.toLowerCase();
+        return !foundTaskIdsByFuse.has(lowerId);
     });
-    // Wait for all task fetches to complete
-    const directlyFetchedTasks = await Promise.all(taskPromises);
-    // Combine tasks from cache and directly fetched tasks, removing nulls
-    const allTasks = [
-        ...tasksFromCache,
-        ...directlyFetchedTasks.filter(Boolean)
-    ];
-    const tasks = allTasks;
-    if (tasks.length === 0) {
+    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.apiKey } });
+                if (response.ok) {
+                    const task = await response.json();
+                    if (task && typeof task.id === 'string') {
+                        // Add/update with a perfect score if fetched directly, unless a better Fuse score already exists
+                        const existing = uniqueResults.get(task.id);
+                        if (!existing || 0 < existing.score) { // 0 is a perfect 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);
+    }
+    const sortedResults = Array.from(uniqueResults.values())
+        .sort((a, b) => a.score - b.score) // Sort by score, ascending (lower is better)
+        .map(entry => entry.item)
+        .slice(0, MAX_SEARCH_RESULTS); // Limit the number of results
+    if (sortedResults.length === 0) {
         return {
             content: [
                 {
@@ -215,10 +386,10 @@ exports.server.tool("searchTask", [
         };
     }
     return {
-        content: tasks.map((task) => generateTaskMetadata(task)),
+        content: await Promise.all(sortedResults.map((task) => generateTaskMetadata(task))),
     };
 });
-exports.server.tool("listTodo", "Lists all open tasks for the current user.", {}, async () => {
+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 },
@@ -239,7 +410,7 @@ exports.server.tool("listTodo", "Lists all open tasks for the current user.", {}
         };
     }
     return {
-        content: openTasks.map((task) => generateTaskMetadata(task)),
+        content: await Promise.all(openTasks.map((task) => generateTaskMetadata(task))),
     };
 });
 // Only connect to the transport if this file is being run directly (not imported)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hauptsache.net/clickup-mcp",
-  "version": "1.0.3",
+  "version": "1.0.4",
   "description": "A minimal implementation of a Model Context Protocol (MCP) server for ClickUp integration",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -29,10 +29,12 @@
   "license": "ISC",
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.9.0",
+    "fuse.js": "^7.1.0",
     "zod": "^3.24.2"
   },
   "devDependencies": {
     "@types/node": "^22.14.1",
+    "dotenv": "^16.5.0",
     "nodemon": "^3.1.9",
     "prettier": "^3.5.3",
     "typescript": "^5.8.3"