@hauptsache.net/clickup-mcp 1.1.0 → 1.2.0

package/dist/tools/list-tools.js

@@ -4,150 +4,14 @@ exports.registerListToolsRead = registerListToolsRead;
 exports.registerListToolsWrite = registerListToolsWrite;
 const zod_1 = require("zod");
 const config_1 = require("../shared/config");
+const utils_1 = require("../shared/utils");
 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.",
+        "ALWAYS use the list URL (https://app.clickup.com/v/l/LIST_ID) when referencing lists.",
         "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."
+        "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.",
+        "Share the clickable list URL when suggesting list-related actions."
     ].join("\n"), {
         list_id: zod_1.z.string().min(1).describe("The list ID to get information for")
     }, async ({ list_id }) => {
@@ -160,12 +24,30 @@ function registerListToolsRead(server) {
                 throw new Error(`Error fetching list details: ${listResponse.status} ${listResponse.statusText}`);
             }
             const listData = await listResponse.json();
+            // Fetch space tags in parallel (don't let this fail the main request)
+            let spaceTags = [];
+            if (listData.space?.id) {
+                try {
+                    const spaceTagsResponse = await fetch(`https://api.clickup.com/api/v2/space/${listData.space.id}/tag`, {
+                        headers: { Authorization: config_1.CONFIG.apiKey },
+                    });
+                    if (spaceTagsResponse.ok) {
+                        const spaceTagsData = await spaceTagsResponse.json();
+                        spaceTags = spaceTagsData.tags || [];
+                    }
+                }
+                catch (error) {
+                    console.error(`Error fetching space tags for space ${listData.space.id}:`, error);
+                }
+            }
             const responseLines = [
                 `List Information:`,
                 `list_id: ${list_id}`,
+                `list_url: ${(0, utils_1.generateListUrl)(list_id)}`,
                 `name: ${listData.name}`,
                 `folder: ${listData.folder?.name || 'No folder'}`,
                 `space: ${listData.space?.name || 'Unknown'} (${listData.space?.id || 'N/A'})`,
+                `space_url: ${(0, utils_1.generateSpaceUrl)(listData.space?.id || '')}`,
                 `archived: ${listData.archived || false}`,
                 `task_count: ${listData.task_count || 0}`,
             ];
@@ -181,18 +63,25 @@ function registerListToolsRead(server) {
                     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.');
             }
+            // Add space tags information
+            if (spaceTags.length > 0) {
+                const tagNames = spaceTags.map((tag) => tag.name).filter(Boolean).sort();
+                if (tagNames.length > 0) {
+                    responseLines.push(`Available tags in space (shared across all lists): ${tagNames.join(', ')}`);
+                }
+            }
+            else if (listData.space?.id) {
+                responseLines.push('No tags found in this space.');
+            }
             return {
                 content: [
                     {
@@ -218,8 +107,10 @@ function registerListToolsRead(server) {
 function registerListToolsWrite(server) {
     server.tool("updateListInfo", [
         "Appends documentation or context to a list's description.",
+        "ALWAYS reference the list URL (https://app.clickup.com/v/l/LIST_ID) when updating or discussing lists.",
         "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.",
+        "Include links to related tasks, spaces, or external resources in the appended content.",
         "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"),

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

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

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

@@ -1 +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"}
+{"version":3,"file":"search-tools.d.ts","sourceRoot":"","sources":["../../src/tools/search-tools.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,SAAS,EAAC,MAAM,yCAAyC,CAAC;AASlE,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,SAAS,EAAE,QAAQ,EAAE,GAAG,QA8MnE"}

package/dist/tools/search-tools.js

@@ -6,18 +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
-        "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.",
+        "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())
@@ -31,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 {
@@ -72,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
@@ -93,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
@@ -160,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);
@@ -175,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;AAKpE,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,SAAS,QAiEnD"}
+{"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,57 +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}`,
-                    `name: ${space.name}`,
-                    `private: ${space.private || false}`,
-                    `avatar: ${space.avatar || 'None'}`,
-                    `color: ${space.color || 'None'}`,
-                    `access: ${space.access || 'Unknown'}`,
-                    ...(space.archived ? ['archived: true'] : []),
-                    ...(space.multiple_assignees !== undefined ? [`multiple_assignees: ${space.multiple_assignees}`] : []),
-                    ...(space.features?.due_dates?.enabled !== undefined ? [`due_dates_enabled: ${space.features.due_dates.enabled}`] : []),
-                    ...(space.features?.time_tracking?.enabled !== undefined ? [`time_tracking_enabled: ${space.features.time_tracking.enabled}`] : []),
-                ].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,QAoDrE;AAED,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,SAAS,EAAE,QAAQ,EAAE,GAAG,QAwQtE;AAoLD;;GAEG;AACH,wBAAsB,oBAAoB,CAAC,IAAI,EAAE,GAAG,GAAG,OAAO,CAAC,YAAY,CAAC,CA6G3E"}
+{"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"}