@hauptsache.net/clickup-mcp 1.2.0 → 1.3.0

package/dist/shared/utils.js

@@ -12,15 +12,12 @@ exports.generateTaskUrl = generateTaskUrl;
 exports.generateListUrl = generateListUrl;
 exports.generateSpaceUrl = generateSpaceUrl;
 exports.generateFolderUrl = generateFolderUrl;
-exports.formatTaskLink = formatTaskLink;
-exports.formatListLink = formatListLink;
-exports.formatSpaceLink = formatSpaceLink;
-exports.extractTaskIdFromUrl = extractTaskIdFromUrl;
-exports.isClickUpUrl = isClickUpUrl;
-exports.formatLinksSection = formatLinksSection;
+exports.generateDocumentUrl = generateDocumentUrl;
 exports.getSpaceSearchIndex = getSpaceSearchIndex;
 exports.getSpaceContent = getSpaceContent;
 exports.getAllTeamMembers = getAllTeamMembers;
+exports.getDocumentSearchIndex = getDocumentSearchIndex;
+exports.performMultiTermSearch = performMultiTermSearch;
 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
@@ -172,9 +169,10 @@ function createFuseIndex(tasks) {
             { name: 'folder.name', weight: 0.2 },
             { name: 'space.name', weight: 0.1 }
         ],
+        findAllMatches: true,
         includeScore: true,
-        threshold: 0.4,
         minMatchCharLength: 2,
+        threshold: 0.4,
     });
 }
 // ===== LINK UTILITIES =====
@@ -188,65 +186,28 @@ function generateTaskUrl(taskId) {
  * Generate a ClickUp list URL from a list ID
  */
 function generateListUrl(listId) {
-    return `https://app.clickup.com/v/l/${listId}`;
+    return `https://app.clickup.com/${config_1.CONFIG.teamId}/v/li/${listId}`;
 }
 /**
  * Generate a ClickUp space URL from a space ID
  */
 function generateSpaceUrl(spaceId) {
-    return `https://app.clickup.com/v/s/${spaceId}`;
+    return `https://app.clickup.com/${config_1.CONFIG.teamId}/v/s/${spaceId}`;
 }
 /**
  * Generate a ClickUp folder URL from a folder ID
  */
 function generateFolderUrl(folderId) {
-    return `https://app.clickup.com/v/f/${folderId}`;
-}
-/**
- * Format a ClickUp task link as markdown
- */
-function formatTaskLink(taskId, taskName) {
-    const url = generateTaskUrl(taskId);
-    const displayText = taskName ? `${taskName} (${taskId})` : taskId;
-    return `[${displayText}](${url})`;
-}
-/**
- * Format a ClickUp list link as markdown
- */
-function formatListLink(listId, listName) {
-    const url = generateListUrl(listId);
-    const displayText = listName ? `${listName} (${listId})` : listId;
-    return `[${displayText}](${url})`;
-}
-/**
- * Format a ClickUp space link as markdown
- */
-function formatSpaceLink(spaceId, spaceName) {
-    const url = generateSpaceUrl(spaceId);
-    const displayText = spaceName ? `${spaceName} (${spaceId})` : spaceId;
-    return `[${displayText}](${url})`;
-}
-/**
- * Extract task ID from a ClickUp URL
- */
-function extractTaskIdFromUrl(url) {
-    const match = url.match(/https?:\/\/app\.clickup\.com\/t\/([a-z0-9]{6,9})/i);
-    return match ? match[1] : null;
-}
-/**
- * Validate if a string is a valid ClickUp URL
- */
-function isClickUpUrl(url) {
-    return /^https?:\/\/app\.clickup\.com\//.test(url);
+    return `https://app.clickup.com/${config_1.CONFIG.teamId}/v/f/${folderId}`;
 }
 /**
- * Format a prominent link section for responses
+ * Generate a ClickUp document URL from a document ID and optional page ID
  */
-function formatLinksSection(links) {
-    if (links.length === 0)
-        return '';
-    const linkLines = links.map(link => `🔗 [${link.text}](${link.url})`);
-    return `\n\n**📌 Quick Links:**\n${linkLines.join('\n')}`;
+function generateDocumentUrl(docId, pageId) {
+    if (pageId) {
+        return `https://app.clickup.com/${config_1.CONFIG.teamId}/v/dc/${docId}/${pageId}`;
+    }
+    return `https://app.clickup.com/${config_1.CONFIG.teamId}/v/dc/${docId}`;
 }
 // Space search index cache - cache promise to prevent race conditions
 let spaceSearchIndexPromise = null;
@@ -298,7 +259,7 @@ async function getSpaceSearchIndex() {
 }
 const listCache = new Map(); // Cache for space lists/folders
 /**
- * Get lists and folders for a specific space with caching
+ * Get lists, folders, and documents for a specific space with caching
  */
 async function getSpaceContent(spaceId) {
     const cacheKey = `space-content-${spaceId}`;
@@ -310,18 +271,35 @@ async function getSpaceContent(spaceId) {
     // Fetch content with parallel requests
     const fetchPromise = (async () => {
         try {
-            const [foldersResponse, listsResponse] = await Promise.all([
+            const [folders, lists, documents] = await Promise.all([
                 fetch(`https://api.clickup.com/api/v2/space/${spaceId}/folder`, {
                     headers: { Authorization: config_1.CONFIG.apiKey },
+                })
+                    .then(response => response.json())
+                    .then(json => json.folders || [])
+                    .catch(e => {
+                    console.error(e);
+                    return [];
                 }),
                 fetch(`https://api.clickup.com/api/v2/space/${spaceId}/list`, {
                     headers: { Authorization: config_1.CONFIG.apiKey },
                 })
+                    .then(response => response.json())
+                    .then(json => json.lists || [])
+                    .catch(e => {
+                    console.error(e);
+                    return [];
+                }),
+                fetch(`https://api.clickup.com/api/v3/workspaces/${config_1.CONFIG.teamId}/docs?parent_id=${spaceId}`, {
+                    headers: { Authorization: config_1.CONFIG.apiKey },
+                })
+                    .then(response => response.json())
+                    .then(json => json.docs || [])
+                    .catch(e => {
+                    console.error(e);
+                    return [];
+                })
             ]);
-            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 {
@@ -339,11 +317,11 @@ async function getSpaceContent(spaceId) {
                 }
             });
             const foldersWithLists = await Promise.all(folderListPromises);
-            return { lists, folders: foldersWithLists };
+            return { lists, folders: foldersWithLists, documents };
         }
         catch (error) {
             console.error(`Error fetching space content for ${spaceId}:`, error);
-            return { lists: [], folders: [] };
+            return { lists: [], folders: [], documents: [] };
         }
     })();
     // Cache the promise
@@ -401,3 +379,211 @@ async function getAllTeamMembers() {
     }, GLOBAL_REFRESH_INTERVAL);
     return fetchPromise;
 }
+// Document search index management - cache promises to prevent race conditions
+const documentIndices = new Map();
+/**
+ * Get or create a document search index with space name resolution
+ * Caches promises to prevent race conditions on concurrent calls
+ */
+async function getDocumentSearchIndex(space_ids) {
+    // Create cache key from sorted filter arrays
+    const key = JSON.stringify({
+        space_ids: space_ids?.sort()
+    });
+    // Check for existing valid index promise
+    const cachedPromise = documentIndices.get(key);
+    if (cachedPromise) {
+        return cachedPromise;
+    }
+    // Create the fetch promise
+    const fetchPromise = (async () => {
+        console.error(`Refreshing document index for filters: ${key}`);
+        const documents = await fetchDocuments(space_ids);
+        const index = createDocumentFuseIndex(documents);
+        console.error(`Document index created with ${documents.length} documents`);
+        return index;
+    })();
+    // Store promise with auto-cleanup
+    documentIndices.set(key, fetchPromise);
+    setTimeout(() => {
+        documentIndices.delete(key);
+        console.error(`Auto-cleaned document index for filters: ${key}`);
+    }, GLOBAL_REFRESH_INTERVAL);
+    return fetchPromise;
+}
+/**
+ * Fetch documents and resolve space names
+ */
+async function fetchDocuments(space_ids) {
+    try {
+        // Fetch spaces first
+        const spacesResponse = await fetch(`https://api.clickup.com/api/v2/team/${config_1.CONFIG.teamId}/space`, {
+            headers: { Authorization: config_1.CONFIG.apiKey }
+        });
+        if (!spacesResponse.ok) {
+            console.error('Error fetching spaces:', spacesResponse.status);
+            return [];
+        }
+        const spacesData = await spacesResponse.json();
+        // Fetch documents with pagination
+        const allDocuments = [];
+        let nextCursor = null;
+        let pageCount = 0;
+        const maxPages = 10; // Limit to 10 pages to avoid excessive API calls
+        do {
+            const url = new URL(`https://api.clickup.com/api/v3/workspaces/${config_1.CONFIG.teamId}/docs`);
+            url.searchParams.set('limit', '100');
+            if (nextCursor) {
+                url.searchParams.set('next_cursor', nextCursor);
+            }
+            const documentsResponse = await fetch(url.toString(), {
+                headers: { Authorization: config_1.CONFIG.apiKey }
+            });
+            if (!documentsResponse.ok) {
+                console.error('Error fetching documents:', documentsResponse.status);
+                break;
+            }
+            const documentsData = await documentsResponse.json();
+            const pageDocs = documentsData.docs || [];
+            allDocuments.push(...pageDocs);
+            nextCursor = documentsData.next_cursor || null;
+            pageCount++;
+            console.error(`Fetched page ${pageCount} with ${pageDocs.length} documents (total: ${allDocuments.length})`);
+        } while (nextCursor && pageCount < maxPages);
+        const documents = allDocuments;
+        const spaces = spacesData.spaces || [];
+        // Create space lookup map
+        const spaceMap = new Map(spaces.map((space) => [space.id, space]));
+        // Enhance documents with parent information
+        const enhancedDocuments = documents.map((doc) => {
+            // Parent types: 4=Space, 5=Folder, 6=List, 7=Workspace
+            if (doc.parent?.type === 4) {
+                // Space parent - we can resolve the name
+                const space = spaceMap.get(doc.parent.id);
+                return {
+                    ...doc,
+                    space_name: space?.name || 'Unknown',
+                    space_id: doc.parent.id,
+                    parent_info: space?.name ? `Space: ${space.name} (${doc.parent.id})` : `Space: ${doc.parent.id}`
+                };
+            }
+            else if (doc.parent?.type === 6) {
+                // List parent - just show ID
+                return {
+                    ...doc,
+                    space_name: 'N/A',
+                    space_id: null,
+                    parent_info: `List: ${doc.parent.id}`
+                };
+            }
+            else if (doc.parent?.type === 5) {
+                // Folder parent - just show ID
+                return {
+                    ...doc,
+                    space_name: 'N/A',
+                    space_id: null,
+                    parent_info: `Folder: ${doc.parent.id}`
+                };
+            }
+            else if (doc.parent?.type === 7) {
+                // Workspace parent
+                return {
+                    ...doc,
+                    space_name: 'N/A',
+                    space_id: null,
+                    parent_info: `Workspace`
+                };
+            }
+            // Unknown parent type
+            return {
+                ...doc,
+                space_name: 'Unknown',
+                space_id: doc.parent?.id,
+                parent_info: doc.parent ? `Unknown (type ${doc.parent.type})` : 'Unknown'
+            };
+        });
+        // Filter by space_ids if provided
+        if (space_ids?.length) {
+            return enhancedDocuments.filter((doc) => space_ids.includes(doc.space_id));
+        }
+        return enhancedDocuments;
+    }
+    catch (error) {
+        console.error('Error fetching documents:', error);
+        return [];
+    }
+}
+/**
+ * Create a Fuse index from documents array
+ */
+function createDocumentFuseIndex(documents) {
+    return new fuse_js_1.default(documents, {
+        keys: [
+            { name: 'name', weight: 0.8 },
+            { name: 'space_name', weight: 0.6 },
+            { name: 'id', weight: 0.4 }
+        ],
+        findAllMatches: true,
+        includeScore: true,
+        minMatchCharLength: 2,
+        threshold: 0.4,
+    });
+}
+/**
+ * Performs multi-term search with aggressive boosting for items matching multiple terms
+ * @param searchIndex Fuse search index to search within
+ * @param terms Array of search terms
+ * @returns Array of items sorted by relevance (multi-term matches ranked higher)
+ */
+async function performMultiTermSearch(searchIndex, terms) {
+    // Filter valid search terms
+    const validTerms = terms.filter(term => term && term.trim().length > 0);
+    if (validTerms.length === 0) {
+        return [];
+    }
+    // Track multiple matches per item for aggressive boosting
+    const itemMatches = new Map();
+    // Collect all matches for each term
+    validTerms.forEach(term => {
+        const results = searchIndex.search(term);
+        results.forEach(result => {
+            if (result.item && typeof result.item.id === 'string') {
+                const itemId = result.item.id;
+                const currentScore = result.score ?? 1;
+                const existing = itemMatches.get(itemId);
+                if (!existing) {
+                    itemMatches.set(itemId, {
+                        item: result.item,
+                        scores: [currentScore],
+                        matchedTerms: [term]
+                    });
+                }
+                else {
+                    existing.scores.push(currentScore);
+                    existing.matchedTerms.push(term);
+                }
+            }
+        });
+    });
+    // Calculate aggressively boosted scores for multi-term matches
+    const uniqueResults = new Map();
+    itemMatches.forEach((match, itemId) => {
+        const bestScore = Math.min(...match.scores);
+        const matchCount = match.scores.length;
+        const totalTerms = validTerms.length;
+        // Aggressive multi-term boost: exponential improvement for multiple matches
+        // 1 match: base score
+        // 2+ matches: exponentially better score based on match ratio
+        const matchRatio = matchCount / totalTerms;
+        const boostFactor = Math.pow(0.1, matchRatio * 4); // Very aggressive boost
+        const finalScore = bestScore * boostFactor;
+        uniqueResults.set(itemId, {
+            item: match.item,
+            score: finalScore
+        });
+    });
+    // Return sorted results (best scores first)
+    return Array.from(uniqueResults.values())
+        .sort((a, b) => a.score - b.score)
+        .map(entry => entry.item);
+}

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

@@ -0,0 +1,4 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerDocumentToolsRead(server: McpServer): void;
+export declare function registerDocumentToolsWrite(server: McpServer): void;
+//# sourceMappingURL=doc-tools.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"doc-tools.d.ts","sourceRoot":"","sources":["../../src/tools/doc-tools.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAoDpE,wBAAgB,yBAAyB,CAAC,MAAM,EAAE,SAAS,QAiR1D;AAED,wBAAgB,0BAA0B,CAAC,MAAM,EAAE,SAAS,QA8O3D"}