@hauptsache.net/clickup-mcp 1.1.1 → 1.2.0

package/dist/shared/utils.js

@@ -3,9 +3,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.downloadImages = void 0;
 exports.isTaskId = isTaskId;
 exports.getCurrentUser = getCurrentUser;
-exports.limitImages = limitImages;
 exports.getSpaceDetails = getSpaceDetails;
 exports.getTaskSearchIndex = getTaskSearchIndex;
 exports.generateTaskUrl = generateTaskUrl;
@@ -18,6 +18,9 @@ exports.formatSpaceLink = formatSpaceLink;
 exports.extractTaskIdFromUrl = extractTaskIdFromUrl;
 exports.isClickUpUrl = isClickUpUrl;
 exports.formatLinksSection = formatLinksSection;
+exports.getSpaceSearchIndex = getSpaceSearchIndex;
+exports.getSpaceContent = getSpaceContent;
+exports.getAllTeamMembers = getAllTeamMembers;
 const config_1 = require("./config");
 const fuse_js_1 = __importDefault(require("fuse.js"));
 const GLOBAL_REFRESH_INTERVAL = 60000; // 60 seconds - that is the rate limit time frame
@@ -29,62 +32,39 @@ function isTaskId(str) {
     // Task IDs are 6-9 characters long and contain only alphanumeric characters
     return /^[a-z0-9]{6,9}$/i.test(str);
 }
-// Cache for current user info to avoid repeated API calls
-let cachedUserData = null;
+// Cache for current user info to avoid repeated API calls and race conditions
+let cachedUserPromise = null;
 /**
  * Get current authenticated user information from ClickUp API
- * Caches the result after first successful fetch to avoid repeated API calls during the session
+ * Caches the promise to prevent race conditions on concurrent calls
  */
 async function getCurrentUser() {
-    // Return cached data if available
-    if (cachedUserData) {
-        return cachedUserData;
+    // Return cached promise if available
+    if (cachedUserPromise) {
+        return cachedUserPromise;
     }
-    const userResponse = await fetch("https://api.clickup.com/api/v2/user", {
-        headers: { Authorization: config_1.CONFIG.apiKey },
-    });
-    if (!userResponse.ok) {
-        throw new Error(`Error fetching user info: ${userResponse.status} ${userResponse.statusText}`);
-    }
-    // Cache the result for future calls
-    cachedUserData = await userResponse.json();
-    return cachedUserData;
-}
-/**
- * Limits the number of images in the content array, replacing excess images with text placeholders
- * Prioritizes keeping the most recent images (assumes content is ordered with newest items last)
- *
- * @param content Array of content blocks that may contain images
- * @param maxImages Maximum number of images to keep
- * @returns Modified content array with limited images
- */
-function limitImages(content, maxImages) {
-    // Count how many images we have
-    const imageIndices = [];
-    // Find all image blocks
-    content.forEach((block, index) => {
-        if (block.type === "image") {
-            imageIndices.push(index);
+    // Create the fetch promise
+    const fetchPromise = (async () => {
+        const userResponse = await fetch("https://api.clickup.com/api/v2/user", {
+            headers: { Authorization: config_1.CONFIG.apiKey },
+        });
+        if (!userResponse.ok) {
+            throw new Error(`Error fetching user info: ${userResponse.status} ${userResponse.statusText}`);
         }
-    });
-    // If we have fewer images than the limit, return the original content
-    if (imageIndices.length <= maxImages) {
-        return content;
-    }
-    // Determine which images to keep (the most recent ones)
-    // We want to keep the last 'maxImages' images
-    const imagesToRemove = imageIndices.slice(0, imageIndices.length - maxImages);
-    // Create a new content array with excess images replaced by text
-    return content.map((block, index) => {
-        if (block.type === "image" && imagesToRemove.includes(index)) {
-            return {
-                type: "text",
-                text: "[Image removed due to size limitations. Only the most recent images are shown.]",
-            };
-        }
-        return block;
-    });
+        return await userResponse.json();
+    })();
+    // Cache the promise
+    cachedUserPromise = fetchPromise;
+    // Auto-cleanup after 60 seconds
+    setTimeout(() => {
+        cachedUserPromise = null;
+        console.error(`Auto-cleaned user data cache`);
+    }, GLOBAL_REFRESH_INTERVAL);
+    return fetchPromise;
 }
+// Re-export image processing functions for backward compatibility
+var image_processing_1 = require("./image-processing");
+Object.defineProperty(exports, "downloadImages", { enumerable: true, get: function () { return image_processing_1.downloadImages; } });
 const spaceCache = new Map(); // Global cache for space details promises
 /**
  * Function to get space details, using a cache to avoid redundant fetches
@@ -111,10 +91,11 @@ function getSpaceDetails(spaceId) {
     spaceCache.set(spaceId, fetchPromise);
     return fetchPromise;
 }
-// Task search index management
+// Task search index management - cache promises to prevent race conditions
 const taskIndices = new Map();
 /**
  * Get or create a task search index with specified filters
+ * Caches promises to prevent race conditions on concurrent calls
  */
 async function getTaskSearchIndex(space_ids, list_ids, assignees) {
     // Create cache key from sorted filter arrays
@@ -123,23 +104,26 @@ async function getTaskSearchIndex(space_ids, list_ids, assignees) {
         list_ids: list_ids?.sort(),
         assignees: assignees?.sort()
     });
-    // Check for existing valid index
-    const cachedIndex = taskIndices.get(key);
-    if (cachedIndex) {
-        return cachedIndex;
+    // Check for existing valid index promise
+    const cachedPromise = taskIndices.get(key);
+    if (cachedPromise) {
+        return cachedPromise;
     }
-    // Fetch tasks with specified filters
-    console.error(`Refreshing task index for filters: ${key}`);
-    const tasks = await fetchTasks(space_ids, list_ids, assignees);
-    const index = createFuseIndex(tasks);
-    // Store with auto-cleanup
-    taskIndices.set(key, index);
+    // Create the fetch promise
+    const fetchPromise = (async () => {
+        console.error(`Refreshing task index for filters: ${key}`);
+        const tasks = await fetchTasks(space_ids, list_ids, assignees);
+        const index = createFuseIndex(tasks);
+        console.error(`Task index created with ${tasks.length} tasks`);
+        return index;
+    })();
+    // Store promise with auto-cleanup
+    taskIndices.set(key, fetchPromise);
     setTimeout(() => {
         taskIndices.delete(key);
         console.error(`Auto-cleaned index for filters: ${key}`);
     }, GLOBAL_REFRESH_INTERVAL);
-    console.error(`Task index created with ${tasks.length} tasks`);
-    return index;
+    return fetchPromise;
 }
 /**
  * Fetch tasks using team endpoint with dynamic filters
@@ -264,3 +248,156 @@ function formatLinksSection(links) {
     const linkLines = links.map(link => `🔗 [${link.text}](${link.url})`);
     return `\n\n**📌 Quick Links:**\n${linkLines.join('\n')}`;
 }
+// Space search index cache - cache promise to prevent race conditions
+let spaceSearchIndexPromise = null;
+/**
+ * Get or refresh the space search index
+ * Caches promise to prevent race conditions on concurrent calls
+ */
+async function getSpaceSearchIndex() {
+    // Return cached promise if available
+    if (spaceSearchIndexPromise) {
+        return spaceSearchIndexPromise;
+    }
+    // Create the fetch promise
+    const fetchPromise = (async () => {
+        try {
+            const url = `https://api.clickup.com/api/v2/team/${config_1.CONFIG.teamId}/space`;
+            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 data = await response.json();
+            const spacesData = data.spaces || [];
+            // Create Fuse search index
+            return new fuse_js_1.default(spacesData, {
+                keys: [
+                    { name: 'name', weight: 0.7 },
+                    { name: 'id', weight: 0.6 }
+                ],
+                includeScore: true,
+                threshold: 0.4,
+                minMatchCharLength: 1,
+            });
+        }
+        catch (error) {
+            console.error('Error creating space search index:', error);
+            return null;
+        }
+    })();
+    // Cache the promise
+    spaceSearchIndexPromise = fetchPromise;
+    // Auto-cleanup after 60 seconds
+    setTimeout(() => {
+        spaceSearchIndexPromise = null;
+        console.error('Auto-cleaned space search index');
+    }, GLOBAL_REFRESH_INTERVAL);
+    return fetchPromise;
+}
+const listCache = new Map(); // Cache for space lists/folders
+/**
+ * Get lists and folders for a specific space with caching
+ */
+async function getSpaceContent(spaceId) {
+    const cacheKey = `space-content-${spaceId}`;
+    // Check cache first
+    const cachedContent = listCache.get(cacheKey);
+    if (cachedContent) {
+        return cachedContent;
+    }
+    // Fetch content with parallel requests
+    const fetchPromise = (async () => {
+        try {
+            const [foldersResponse, listsResponse] = await Promise.all([
+                fetch(`https://api.clickup.com/api/v2/space/${spaceId}/folder`, {
+                    headers: { Authorization: config_1.CONFIG.apiKey },
+                }),
+                fetch(`https://api.clickup.com/api/v2/space/${spaceId}/list`, {
+                    headers: { Authorization: config_1.CONFIG.apiKey },
+                })
+            ]);
+            const folders = foldersResponse.ok ?
+                (await foldersResponse.json()).folders || [] : [];
+            const lists = listsResponse.ok ?
+                (await listsResponse.json()).lists || [] : [];
+            // For each folder, also fetch its lists
+            const folderListPromises = folders.map(async (folder) => {
+                try {
+                    const folderListResponse = await fetch(`https://api.clickup.com/api/v2/folder/${folder.id}/list`, { headers: { Authorization: config_1.CONFIG.apiKey } });
+                    if (folderListResponse.ok) {
+                        const folderListData = await folderListResponse.json();
+                        folder.lists = folderListData.lists || [];
+                    }
+                    return folder;
+                }
+                catch (error) {
+                    console.error(`Error fetching lists for folder ${folder.id}:`, error);
+                    folder.lists = [];
+                    return folder;
+                }
+            });
+            const foldersWithLists = await Promise.all(folderListPromises);
+            return { lists, folders: foldersWithLists };
+        }
+        catch (error) {
+            console.error(`Error fetching space content for ${spaceId}:`, error);
+            return { lists: [], folders: [] };
+        }
+    })();
+    // Cache the promise
+    listCache.set(cacheKey, fetchPromise);
+    // Auto-cleanup after 60 seconds
+    setTimeout(() => {
+        listCache.delete(cacheKey);
+        console.error(`Auto-cleaned space content cache for ${spaceId}`);
+    }, GLOBAL_REFRESH_INTERVAL);
+    return fetchPromise;
+}
+// Cache for team members to avoid repeated API calls and race conditions
+let cachedTeamMembersPromise = null;
+/**
+ * Gets all team members from ClickUp API with caching
+ */
+async function getAllTeamMembers() {
+    // Return cached promise if available
+    if (cachedTeamMembersPromise) {
+        return cachedTeamMembersPromise;
+    }
+    // Create the fetch promise
+    const fetchPromise = (async () => {
+        try {
+            const response = await fetch(`https://api.clickup.com/api/v2/team`, {
+                headers: { Authorization: config_1.CONFIG.apiKey },
+            });
+            if (!response.ok) {
+                console.error(`Error fetching teams: ${response.status} ${response.statusText}`);
+                return [];
+            }
+            const data = await response.json();
+            if (!data.teams || !Array.isArray(data.teams)) {
+                return [];
+            }
+            // Find the team that matches our configured team ID and extract all user IDs
+            const currentTeam = data.teams.find((team) => team.id === config_1.CONFIG.teamId);
+            if (!currentTeam || !currentTeam.members || !Array.isArray(currentTeam.members)) {
+                console.error(`Team ${config_1.CONFIG.teamId} not found or has no members`);
+                return [];
+            }
+            return currentTeam.members.map((member) => member.user?.id).filter(Boolean);
+        }
+        catch (error) {
+            console.error('Error fetching team members:', error);
+            return [];
+        }
+    })();
+    // Cache the promise
+    cachedTeamMembersPromise = fetchPromise;
+    // Auto-cleanup after 60 seconds
+    setTimeout(() => {
+        cachedTeamMembersPromise = null;
+        console.error(`Auto-cleaned team members cache`);
+    }, GLOBAL_REFRESH_INTERVAL);
+    return fetchPromise;
+}

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

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

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,QA8MnE"}