@hauptsache.net/clickup-mcp 1.1.1 → 1.3.0

package/dist/tools/list-tools.js

@@ -6,152 +6,6 @@ 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.",
-        "Always reference lists by their URLs when suggesting actions or creating tasks."
-    ].join("\n"), {
-        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}`,
-                        `list_url: ${(0, utils_1.generateListUrl)(list.id)}`,
-                        `name: ${list.name}`,
-                        `space_id: ${list.space?.id || space_id}`,
-                        `folder_id: ${folder_id}`,
-                        `task_count: ${list.task_count || 0}`,
-                        ...(list.private ? [`private: true`] : []),
-                        ...(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}`,
-                                `folder_url: ${(0, utils_1.generateFolderUrl)(folder.id)}`,
-                                `name: ${folder.name}`,
-                                `space_id: ${space_id}`,
-                                `task_count: ${folder.task_count || 0}`,
-                                ...(folder.private ? [`private: true`] : []),
-                                ...(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}`,
-                                `list_url: ${(0, utils_1.generateListUrl)(list.id)}`,
-                                `name: ${list.name}`,
-                                `space_id: ${list.space?.id || space_id}`,
-                                `task_count: ${list.task_count || 0}`,
-                                ...(list.private ? [`private: true`] : []),
-                                ...(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.",
@@ -170,6 +24,22 @@ 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}`,
@@ -193,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: [
                     {

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,QAuMpD"}
+{"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,QAuLnE"}

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 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,41 +87,22 @@ 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))),
-            };
-        }
-        // 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.",
-                    },
-                ],
+                content: await Promise.all(resultTasks.map((task) => (0, task_tools_1.generateTaskMetadata)(task, timeEntries))),
             };
         }
+        // Create a results map to track unique tasks with scores
         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
-                        });
-                    }
-                }
-            });
+        // Perform multi-term search with aggressive boosting
+        const searchResults = await (0, utils_1.performMultiTermSearch)(searchIndex, terms);
+        searchResults.forEach(task => {
+            uniqueResults.set(task.id, { item: task, score: 0.1 }); // Give search results a good score
         });
         // Task ID Fallback Logic
-        const potentialTaskIds = validTerms.filter(utils_1.isTaskId);
+        const potentialTaskIds = terms.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();
@@ -161,8 +135,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 +155,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;AAKpE,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,SAAS,QAiNnD"}

package/dist/tools/space-tools.js

@@ -2,56 +2,182 @@
 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 {
+                // Perform multi-term search with aggressive boosting
+                matchingSpaces = await (0, utils_1.performMultiTermSearch)(searchIndex, terms
+                // No ID matcher or direct fetcher for spaces - they don't have direct API endpoints
+                );
+            }
+            // Filter by archived status
+            if (!archived) {
+                matchingSpaces = matchingSpaces.filter((space) => !space.archived);
             }
-            const data = await response.json();
-            if (!data.spaces || !Array.isArray(data.spaces)) {
+            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, documents } = await (0, utils_1.getSpaceContent)(space.id);
+                        return { space, lists, folders, documents };
+                    }
+                    else {
+                        // Summary mode: just return space without content
+                        return { space, lists: [], folders: [], documents: [] };
+                    }
+                }
+                catch (error) {
+                    console.error(`Error fetching content for space ${space.id}:`, error);
+                    return { space, lists: [], folders: [], documents: [] };
+                }
+            });
+            const spacesWithContent = await Promise.all(spaceContentPromises);
+            const contentBlocks = [];
+            const isDetailedMode = matchingSpaces.length <= 5;
+            if (isDetailedMode) {
+                // Detailed mode: create separate blocks for each space
+                spacesWithContent.forEach(({ space, lists, folders, documents }) => {
+                    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, ${documents.length} documents`);
+                    // Create a tree structure
+                    const hasDirectLists = lists.length > 0;
+                    const hasFolders = folders.length > 0;
+                    const hasDocuments = documents.length > 0;
+                    // Direct lists (not in folders)
+                    if (hasDirectLists) {
+                        lists.forEach((list, listIndex) => {
+                            const isLastDirectList = listIndex === lists.length - 1;
+                            const isLastOverall = !hasFolders && !hasDocuments && 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 isLastOverall = !hasDocuments && isLastFolder;
+                            const folderTreeChar = isLastOverall ? '└──' : '├──';
+                            const folderContinuation = isLastOverall ? '   ' : '│  ';
+                            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);
+                                });
+                            }
+                        });
+                    }
+                    // Documents attached to this space
+                    if (hasDocuments) {
+                        documents.forEach((document, docIndex) => {
+                            const isLastDocument = docIndex === documents.length - 1;
+                            const docTreeChar = isLastDocument ? '└──' : '├──';
+                            const docLine = `${docTreeChar} 📄 ${document.name} (doc_id: ${document.id}) ${(0, utils_1.generateDocumentUrl)(document.id)}`;
+                            spaceLines.push(docLine);
+                        });
+                    }
+                    // Add the complete space as a single content block
+                    contentBlocks.push({
+                        type: "text",
+                        text: spaceLines.join('\n')
+                    });
+                });
+            }
+            else {
+                // Summary mode: create a single combined block with all spaces
+                const allSpaceLines = [];
+                spacesWithContent.forEach(({ space }) => {
+                    allSpaceLines.push(`🏢 SPACE: ${space.name} (space_id: ${space.id}${space.private ? ', private' : ''}${space.archived ? ', archived' : ''})`);
+                });
+                contentBlocks.push({
+                    type: "text",
+                    text: allSpaceLines.join('\n')
+                });
+            }
+            // 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
+                            ? (() => {
+                                const totalLists = spacesWithContent.reduce((sum, { lists, folders }) => sum + lists.length + folders.reduce((folderSum, f) => folderSum + (f.lists?.length || 0), 0), 0);
+                                const totalDocuments = spacesWithContent.reduce((sum, { documents }) => sum + documents.length, 0);
+                                return `Found ${matchingSpaces.length} space(s) with complete tree structure (${totalLists} total lists, ${totalDocuments} total documents):`;
+                            })()
+                            : `Found ${matchingSpaces.length} space(s) - showing names and IDs only. Use more specific search terms to get detailed information:`
                     },
-                    ...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