@hauptsache.net/clickup-mcp 1.1.1 → 1.2.0

package/dist/tools/search-tools.js

@@ -6,19 +6,19 @@ 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) {
+function registerSearchTools(server, userData) {
     // 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).",
+        "Searches tasks (sometimes called Tickets or Cards) 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
-        "Always reference tasks by their URLs when discussing search results or suggesting actions.",
-        "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, and always share the task URL.",
+        "Can also be used to find tasks for the current user by providing the assigned_to_me flag."
     ];
     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}'.`);
+        searchTasksDescriptionBase.push(`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}'.`);
     }
+    searchTasksDescriptionBase.push("Always reference tasks by their URLs when discussing search results or suggesting actions.");
+    searchTasksDescriptionBase.push("You'll get a rough overview of the tasks that match the search terms, sorted by relevance.");
+    searchTasksDescriptionBase.push("Always use getTaskById to get more specific information if a task is relevant, and always share the task URL.");
     server.tool("searchTasks", searchTasksDescriptionBase.join("\n"), {
         terms: zod_1.z
             .array(zod_1.z.string())
@@ -32,33 +32,21 @@ function registerSearchTools(server) {
             .array(zod_1.z.string())
             .optional()
             .describe("Filter tasks to specific space IDs"),
-        todo: zod_1.z
+        only_todo: zod_1.z
             .boolean()
             .optional()
-            .describe("Filter for open/todo tasks only (exclude done tasks)"),
+            .describe("Filter for open/todo tasks only (exclude done and closed tasks)"),
+        status: zod_1.z
+            .array(zod_1.z.string())
+            .optional()
+            .describe("Filter for tasks with specific status names (overrides only_todo if provided)"),
         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 }) => {
+            .describe(`Filter for tasks assigned to the current user (${userData.user.username} (${userData.user.id}))`),
+    }, async ({ terms, list_ids, space_ids, only_todo, status, 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 assignees = assigned_to_me ? [userData.user.id] : [];
         const searchIndex = await (0, utils_1.getTaskSearchIndex)(space_ids, list_ids, assignees);
         if (!searchIndex) {
             return {
@@ -73,8 +61,13 @@ function registerSearchTools(server) {
         // 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");
+            // Apply status filtering
+            if (status && status.length > 0) {
+                const statusLower = status.map(s => s.toLowerCase());
+                allTasks = allTasks.filter((task) => statusLower.includes(task.status.status.toLowerCase()));
+            }
+            else if (only_todo) {
+                allTasks = allTasks.filter((task) => task.status.type !== "done" && task.status.type !== "closed");
             }
             // Sort by updated date (most recent first) and limit
             const resultTasks = allTasks
@@ -94,8 +87,11 @@ function registerSearchTools(server) {
                     ],
                 };
             }
+            // Fetch time entries for all unique list IDs
+            const uniqueListIds = [...new Set(resultTasks.map((task) => task.list?.id).filter(Boolean))];
+            const timeEntries = await fetchBulkTimeEntries(uniqueListIds);
             return {
-                content: await Promise.all(resultTasks.map((task) => (0, task_tools_1.generateTaskMetadata)(task))),
+                content: await Promise.all(resultTasks.map((task) => (0, task_tools_1.generateTaskMetadata)(task, timeEntries))),
             };
         }
         // Filter valid search terms
@@ -161,8 +157,13 @@ function registerSearchTools(server) {
         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 status filtering
+        if (status && status.length > 0) {
+            const statusLower = status.map(s => s.toLowerCase());
+            resultTasks = resultTasks.filter((task) => statusLower.includes(task.status.status.toLowerCase()));
+        }
+        else if (only_todo) {
+            resultTasks = resultTasks.filter((task) => task.status.type !== "done" && task.status.type !== "closed");
         }
         // Apply result limit
         resultTasks = resultTasks.slice(0, MAX_SEARCH_RESULTS);
@@ -176,8 +177,52 @@ function registerSearchTools(server) {
                 ],
             };
         }
+        // Fetch time entries for all unique list IDs
+        const uniqueListIds = [...new Set(resultTasks.map((task) => task.list?.id).filter(Boolean))];
+        const timeEntries = await fetchBulkTimeEntries(uniqueListIds);
         return {
-            content: await Promise.all(resultTasks.map((task) => (0, task_tools_1.generateTaskMetadata)(task))),
+            content: await Promise.all(resultTasks.map((task) => (0, task_tools_1.generateTaskMetadata)(task, timeEntries))),
         };
     });
 }
+/**
+ * Fetch time entries for a list of unique list IDs
+ */
+async function fetchBulkTimeEntries(listIds) {
+    try {
+        // Get all team members for assignee filter
+        const teamMembers = await (0, utils_1.getAllTeamMembers)();
+        const assigneeParam = teamMembers.length > 0 ? teamMembers.join(',') : '';
+        // Calculate 30 days ago timestamp
+        const thirtyDaysAgo = new Date();
+        thirtyDaysAgo.setDate(thirtyDaysAgo.getDate() - 30);
+        const startDate = thirtyDaysAgo.getTime();
+        // Fetch time entries for each unique list ID
+        const timeEntryPromises = listIds.map(async (listId) => {
+            const params = new URLSearchParams({
+                list_id: listId,
+                start_date: startDate.toString(),
+                include_location_names: 'true'
+            });
+            if (assigneeParam) {
+                params.append('assignee', assigneeParam);
+            }
+            const response = await fetch(`https://api.clickup.com/api/v2/team/${config_1.CONFIG.teamId}/time_entries?${params}`, {
+                headers: { Authorization: config_1.CONFIG.apiKey },
+            });
+            if (!response.ok) {
+                console.error(`Error fetching time entries for list ${listId}: ${response.status} ${response.statusText}`);
+                return [];
+            }
+            const data = await response.json();
+            return data.data || [];
+        });
+        // Wait for all requests to complete and flatten results
+        const results = await Promise.all(timeEntryPromises);
+        return results.flat();
+    }
+    catch (error) {
+        console.error('Error fetching bulk time entries:', error);
+        return [];
+    }
+}

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

@@ -1 +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;AAMpE,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,SAAS,QA+DnD"}
+{"version":3,"file":"space-tools.d.ts","sourceRoot":"","sources":["../../src/tools/space-tools.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAMpE,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,SAAS,QAqNnD"}

package/dist/tools/space-tools.js

@@ -2,56 +2,186 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.registerSpaceTools = registerSpaceTools;
 const zod_1 = require("zod");
-const config_1 = require("../shared/config");
 const utils_1 = require("../shared/utils");
 function registerSpaceTools(server) {
-    server.tool("listSpaces", [
-        "Lists all spaces in the workspace. These might also be referred to as customers or projects.",
+    server.tool("searchSpaces", [
+        "Searches spaces (sometimes called projects) by name or ID with fuzzy matching.",
+        "If 5 or fewer spaces match, automatically fetches all lists (sometimes called boards) and folders within those spaces to provide a complete tree structure.",
+        "If more than 5 spaces match, returns only space information with guidance to search more precisely.",
+        "You can search by space name (fuzzy matching) or provide an exact space ID.",
         "Always reference spaces by their URLs when discussing projects or suggesting actions."
     ].join("\n"), {
+        terms: zod_1.z
+            .array(zod_1.z.string())
+            .optional()
+            .describe("Array of search terms to match against space names or IDs. If not provided, returns all spaces."),
         archived: zod_1.z.boolean().optional().describe("Include archived spaces (default: false)")
-    }, async ({ archived = false }) => {
+    }, async ({ terms, archived = false }) => {
         try {
-            const url = `https://api.clickup.com/api/v2/team/${config_1.CONFIG.teamId}/space${archived ? '?archived=true' : ''}`;
-            const response = await fetch(url, {
-                headers: { Authorization: config_1.CONFIG.apiKey },
-            });
-            if (!response.ok) {
-                throw new Error(`Error fetching spaces: ${response.status} ${response.statusText}`);
+            const searchIndex = await (0, utils_1.getSpaceSearchIndex)();
+            if (!searchIndex) {
+                return {
+                    content: [{ type: "text", text: "Error: Could not build space search index." }],
+                };
+            }
+            let matchingSpaces = [];
+            if (!terms || terms.length === 0) {
+                // Return all spaces if no search terms
+                matchingSpaces = searchIndex._docs || [];
+            }
+            else {
+                // Search with fuzzy matching
+                const uniqueResults = new Map();
+                terms.forEach(term => {
+                    const trimmedTerm = term.trim();
+                    if (trimmedTerm.length === 0)
+                        return;
+                    // Check if it's an exact space ID first
+                    const exactMatch = searchIndex._docs.find((space) => space.id === trimmedTerm);
+                    if (exactMatch) {
+                        uniqueResults.set(exactMatch.id, { item: exactMatch, score: 0 });
+                        return;
+                    }
+                    // Fuzzy search
+                    const results = searchIndex.search(trimmedTerm);
+                    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
+                                });
+                            }
+                        }
+                    });
+                });
+                matchingSpaces = Array.from(uniqueResults.values())
+                    .sort((a, b) => a.score - b.score)
+                    .map(entry => entry.item);
             }
-            const data = await response.json();
-            if (!data.spaces || !Array.isArray(data.spaces)) {
+            // Filter by archived status
+            if (!archived) {
+                matchingSpaces = matchingSpaces.filter((space) => !space.archived);
+            }
+            if (matchingSpaces.length === 0) {
                 return {
-                    content: [{ type: "text", text: "No spaces found in the workspace." }],
+                    content: [{ type: "text", text: "No spaces found matching the search criteria." }],
                 };
             }
-            const spaceBlocks = data.spaces.map((space) => ({
-                type: "text",
-                text: [
-                    `space_id: ${space.id}`,
-                    `space_url: ${(0, utils_1.generateSpaceUrl)(space.id)}`,
-                    `name: ${space.name}`,
-                    ...(space.private ? [`private: true`] : []),
-                    ...(space.archived ? ['archived: true'] : []),
-                ].join('\n')
-            }));
+            // Conditionally fetch detailed content based on result count
+            const spaceContentPromises = matchingSpaces.map(async (space) => {
+                try {
+                    if (matchingSpaces.length <= 5) {
+                        // Detailed mode: fetch lists and folders for this space
+                        const { lists, folders } = await (0, utils_1.getSpaceContent)(space.id);
+                        return { space, lists, folders };
+                    }
+                    else {
+                        // Summary mode: just return space without content
+                        return { space, lists: [], folders: [] };
+                    }
+                }
+                catch (error) {
+                    console.error(`Error fetching content for space ${space.id}:`, error);
+                    return { space, lists: [], folders: [] };
+                }
+            });
+            const spacesWithContent = await Promise.all(spaceContentPromises);
+            const contentBlocks = [];
+            spacesWithContent.forEach(({ space, lists, folders }, index) => {
+                const spaceLines = [];
+                const totalLists = lists.length + folders.reduce((sum, f) => sum + (f.lists?.length || 0), 0);
+                // Space header
+                spaceLines.push(`🏢 SPACE: ${space.name} (space_id: ${space.id}${space.private ? ', private' : ''}${space.archived ? ', archived' : ''}) ${(0, utils_1.generateSpaceUrl)(space.id)}`, `   ${totalLists} lists, ${folders.length} folders`);
+                // Create a tree structure
+                const hasDirectLists = lists.length > 0;
+                const hasFolders = folders.length > 0;
+                // Direct lists (not in folders)
+                if (hasDirectLists) {
+                    lists.forEach((list, listIndex) => {
+                        const isLastDirectList = listIndex === lists.length - 1;
+                        const isLastOverall = !hasFolders && isLastDirectList;
+                        const treeChar = isLastOverall ? '└──' : '├──';
+                        const extraInfo = [
+                            ...(list.task_count ? [`${list.task_count} tasks`] : []),
+                            ...(list.private ? ['private'] : []),
+                            ...(list.archived ? ['archived'] : [])
+                        ].join(', ');
+                        const listLine = `${treeChar} 📝 ${list.name} (list_id: ${list.id}${extraInfo ? `, ${extraInfo}` : ''}) ${(0, utils_1.generateListUrl)(list.id)}`;
+                        spaceLines.push(listLine);
+                    });
+                }
+                // Folders and their lists
+                if (hasFolders) {
+                    folders.forEach((folder, folderIndex) => {
+                        const isLastFolder = folderIndex === folders.length - 1;
+                        const folderTreeChar = isLastFolder ? '└──' : '├──';
+                        const folderContinuation = isLastFolder ? '   ' : '│  ';
+                        const folderExtraInfo = [
+                            ...(folder.lists?.length ? [`${folder.lists.length} lists`] : []),
+                            ...(folder.private ? ['private'] : []),
+                            ...(folder.archived ? ['archived'] : [])
+                        ].join(', ');
+                        const folderLine = `${folderTreeChar} 📂 ${folder.name} (folder_id: ${folder.id}${folderExtraInfo ? `, ${folderExtraInfo}` : ''}) ${(0, utils_1.generateFolderUrl)(folder.id)}`;
+                        spaceLines.push(folderLine);
+                        // Lists within this folder
+                        if (folder.lists && folder.lists.length > 0) {
+                            folder.lists.forEach((list, listIndex) => {
+                                const isLastListInFolder = listIndex === folder.lists.length - 1;
+                                const listTreeChar = isLastListInFolder ? '└──' : '├──';
+                                const listExtraInfo = [
+                                    ...(list.task_count ? [`${list.task_count} tasks`] : []),
+                                    ...(list.private ? ['private'] : []),
+                                    ...(list.archived ? ['archived'] : [])
+                                ].join(', ');
+                                const listLine = `${folderContinuation}${listTreeChar} 📝 ${list.name} (list_id: ${list.id}${listExtraInfo ? `, ${listExtraInfo}` : ''}) ${(0, utils_1.generateListUrl)(list.id)}`;
+                                spaceLines.push(listLine);
+                            });
+                        }
+                    });
+                }
+                // Add the complete space as a single content block
+                contentBlocks.push({
+                    type: "text",
+                    text: spaceLines.join('\n')
+                });
+                // Add separator between spaces (except for the last one)
+                if (index < spacesWithContent.length - 1) {
+                    contentBlocks.push({
+                        type: "text",
+                        text: '─'.repeat(50)
+                    });
+                }
+            });
+            const totalLists = spacesWithContent.reduce((sum, { lists, folders }) => sum + lists.length + folders.reduce((folderSum, f) => folderSum + (f.lists?.length || 0), 0), 0);
+            // Add tip message for summary mode (when there are too many spaces)
+            if (matchingSpaces.length > 5) {
+                contentBlocks.push({
+                    type: "text",
+                    text: `\n💡 Tip: Use more specific search terms to get detailed list information (≤5 spaces will show complete structure)`
+                });
+            }
             return {
                 content: [
                     {
                         type: "text",
-                        text: `Found ${data.spaces.length} space(s) in the workspace:`
+                        text: matchingSpaces.length <= 5
+                            ? `Found ${matchingSpaces.length} space(s) with complete tree structure (${totalLists} total lists):`
+                            : `Found ${matchingSpaces.length} space(s) - too many to show detailed list information. Please search more precisely to get complete tree structure with lists and folders:`
                     },
-                    ...spaceBlocks
+                    ...contentBlocks
                 ],
             };
         }
         catch (error) {
-            console.error('Error fetching spaces:', error);
+            console.error('Error searching spaces:', error);
             return {
                 content: [
                     {
                         type: "text",
-                        text: `Error fetching spaces: ${error instanceof Error ? error.message : 'Unknown error'}`,
+                        text: `Error searching spaces: ${error instanceof Error ? error.message : 'Unknown error'}`,
                     },
                 ],
             };

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

@@ -1,9 +1,8 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { ContentBlock } from "../shared/types";
 export declare function registerTaskToolsRead(server: McpServer, userData: any): void;
-export declare function registerTaskToolsWrite(server: McpServer, userData: any): void;
 /**
  * Helper function to generate consistent task metadata
  */
-export declare function generateTaskMetadata(task: any): Promise<ContentBlock>;
+export declare function generateTaskMetadata(task: any, timeEntries?: any[], isDetailView?: boolean): Promise<ContentBlock>;
 //# sourceMappingURL=task-tools.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"task-tools.d.ts","sourceRoot":"","sources":["../../src/tools/task-tools.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAGpE,OAAO,EAAE,YAAY,EAAqB,MAAM,iBAAiB,CAAC;AAwIlE,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,SAAS,EAAE,QAAQ,EAAE,GAAG,QAwDrE;AAED,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,SAAS,EAAE,QAAQ,EAAE,GAAG,QA6StE;AAoLD;;GAEG;AACH,wBAAsB,oBAAoB,CAAC,IAAI,EAAE,GAAG,GAAG,OAAO,CAAC,YAAY,CAAC,CA4G3E"}
+{"version":3,"file":"task-tools.d.ts","sourceRoot":"","sources":["../../src/tools/task-tools.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAGpE,OAAO,EAAE,YAAY,EAAyC,MAAM,iBAAiB,CAAC;AAOtF,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,SAAS,EAAE,QAAQ,EAAE,GAAG,QAwDrE;AA+MD;;GAEG;AACH,wBAAsB,oBAAoB,CAAC,IAAI,EAAE,GAAG,EAAE,WAAW,CAAC,EAAE,GAAG,EAAE,EAAE,YAAY,GAAE,OAAe,GAAG,OAAO,CAAC,YAAY,CAAC,CA+G/H"}