@hauptsache.net/clickup-mcp 1.0.5 → 1.1.0

package/dist/index.js

@@ -1,478 +1,64 @@
 #!/usr/bin/env node
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.server = void 0;
+exports.serverPromise = exports.server = void 0;
 const mcp_js_1 = require("@modelcontextprotocol/sdk/server/mcp.js");
 const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
-const zod_1 = require("zod");
-const clickup_text_1 = require("./clickup-text");
-const fuse_js_1 = __importDefault(require("fuse.js"));
-// --- End Simplified Event Wrapper ---
-const rawPrimaryLang = process.env.CLICKUP_PRIMARY_LANGUAGE || process.env.LANG;
-let detectedLanguageHint = undefined;
-if (rawPrimaryLang) {
-    // Extract the primary language part (e.g., 'en' from 'en_US.UTF-8' or 'en-GB')
-    // and convert to lowercase.
-    const langPart = rawPrimaryLang.match(/^[a-zA-Z]{2,3}/);
-    if (langPart) {
-        detectedLanguageHint = langPart[0].toLowerCase();
-    }
-}
-const CONFIG = {
-    apiKey: process.env.CLICKUP_API_KEY,
-    teamId: process.env.CLICKUP_TEAM_ID,
-    maxImages: process.env.MAX_IMAGES ? parseInt(process.env.MAX_IMAGES) : 4,
-    primaryLanguageHint: detectedLanguageHint, // Store the cleaned code directly
-};
-if (!CONFIG.apiKey || !CONFIG.teamId) {
-    throw new Error("Missing Clickup API key or team ID");
-}
+const config_1 = require("./shared/config");
+const utils_1 = require("./shared/utils");
+// Import tool registration functions
+const task_tools_1 = require("./tools/task-tools");
+const search_tools_1 = require("./tools/search-tools");
+const space_tools_1 = require("./tools/space-tools");
+const list_tools_1 = require("./tools/list-tools");
+const time_tools_1 = require("./tools/time-tools");
 // Create an MCP server
-exports.server = new mcp_js_1.McpServer({
+const server = new mcp_js_1.McpServer({
     name: "Clickup MCP",
     version: "1.0.0",
 });
-/**
- * Checks if a string looks like a valid ClickUp task ID
- * Valid task IDs are 7-9 characters long and contain only alphanumeric characters
- */
-function isTaskId(str) {
-    // Task IDs are 7-9 characters long and contain only alphanumeric characters
-    return /^[a-z0-9]{7,9}$/i.test(str);
-}
-exports.server.tool("getTaskById", "Get a Clickup task with images and comments by ID", {
-    id: zod_1.z
-        .string()
-        .min(7)
-        .max(9)
-        .refine(val => isTaskId(val), {
-        message: "Task ID must be 7-9 alphanumeric characters only"
-    })
-        .describe(`The 7-9 character ID of the task to get without a prefix like "#", "CU-" or "https://app.clickup.com/t/"`),
-}, async ({ id }) => {
-    // 1. Load base task content, comment events, and status change events in parallel
-    const [taskDetailContentBlocks, commentEvents, statusChangeEvents] = await Promise.all([
-        loadTaskContent(id), // Returns Promise<ContentBlock[]>
-        loadTaskComments(id), // Returns Promise<DatedContentEvent[]>
-        loadTimeInStatusHistory(id), // Returns Promise<DatedContentEvent[]>
-    ]);
-    // 2. Combine comment and status change events
-    const allDatedEvents = [...commentEvents, ...statusChangeEvents];
-    // 3. Sort all dated events chronologically
-    allDatedEvents.sort((a, b) => {
-        const dateA = a.date ? parseInt(a.date) : 0;
-        const dateB = b.date ? parseInt(b.date) : 0;
-        return dateA - dateB;
-    });
-    // 4. Flatten sorted events into a single ContentBlock stream
-    let processedEventBlocks = [];
-    for (const event of allDatedEvents) {
-        processedEventBlocks.push(...event.contentBlocks);
-    }
-    // 5. Combine task details with processed event blocks
-    const allContentBlocks = [...taskDetailContentBlocks, ...processedEventBlocks];
-    // 6. Limit images
-    const limitedContent = limitImages(allContentBlocks, CONFIG.maxImages);
-    return {
-        content: limitedContent,
-    };
-});
-async function loadTaskContent(taskId) {
-    const response = await fetch(`https://api.clickup.com/api/v2/task/${taskId}?include_markdown_description=true&include_subtasks=true`, { headers: { Authorization: CONFIG.apiKey } });
-    const task = await response.json();
-    const content = await (0, clickup_text_1.processClickUpMarkdown)(task.markdown_description || "", task.attachments);
-    // Create the task metadata block using the helper function
-    const taskMetadata = await generateTaskMetadata(task);
-    return [taskMetadata, ...content];
-}
-async function loadTaskComments(id) {
-    const response = await fetch(`https://api.clickup.com/api/v2/task/${id}/comment?start_date=0`, // Ensure all comments are fetched
-    { headers: { Authorization: CONFIG.apiKey } });
-    if (!response.ok) {
-        console.error(`Error fetching comments for task ${id}: ${response.status} ${response.statusText}`);
-        return [];
-    }
-    const commentsData = await response.json();
-    if (!commentsData.comments || !Array.isArray(commentsData.comments)) {
-        console.error(`Unexpected comment data structure for task ${id}`);
-        return [];
-    }
-    const commentEvents = await Promise.all(commentsData.comments.map(async (comment) => {
-        const headerBlock = {
-            type: "text",
-            text: `Comment by ${comment.user.username} on ${new Date(+comment.date)}:`,
-        };
-        const commentBodyBlocks = await (0, clickup_text_1.processClickUpText)(comment.comment);
-        return {
-            date: comment.date, // String timestamp from ClickUp for sorting
-            contentBlocks: [headerBlock, ...commentBodyBlocks],
-        };
-    }));
-    return commentEvents;
-}
-async function loadTimeInStatusHistory(taskId) {
-    const url = `https://api.clickup.com/api/v2/task/${taskId}/time_in_status`;
-    try {
-        const response = await fetch(url, { headers: { Authorization: CONFIG.apiKey } });
-        if (!response.ok) {
-            console.error(`Error fetching time in status for task ${taskId}: ${response.status} ${response.statusText}`);
-            return [];
-        }
-        // Using 'any' for less strict typing as per user preference, but keeping structure for clarity
-        const data = await response.json();
-        const events = [];
-        const processStatusEntry = (entry) => {
-            if (!entry || !entry.total_time || !entry.total_time.since || !entry.status)
-                return null;
-            return {
-                date: entry.total_time.since,
-                contentBlocks: [{
-                        type: "text",
-                        text: `Status set to '${entry.status}' on ${new Date(+entry.total_time.since)}`,
-                    }],
-            };
-        };
-        if (data.status_history && Array.isArray(data.status_history)) {
-            data.status_history.forEach((historyEntry) => {
-                const event = processStatusEntry(historyEntry);
-                if (event)
-                    events.push(event);
-            });
-        }
-        if (data.current_status) {
-            const event = processStatusEntry(data.current_status);
-            // Ensure current_status is only added if it's distinct or more recent than the last history item.
-            // The deduplication logic below handles if it's the same as the last history entry.
-            if (event)
-                events.push(event);
-        }
-        // Deduplicate events based on date and status name to avoid adding current_status if it's identical to the last history entry
-        const uniqueEvents = Array.from(new Map(events.map(event => [`${event.date}-${event.contentBlocks[0]?.text}`, event] // Keying by date and text content of first block
-        )).values());
-        return uniqueEvents;
-    }
-    catch (error) {
-        console.error(`Exception fetching time in status for task ${taskId}:`, error);
-        return [];
-    }
-}
-/**
- * Helper function to generate consistent task metadata
- */
-async function generateTaskMetadata(task) {
-    let spaceName = task.space?.name || 'Unknown Space';
-    let spaceIdForDisplay = task.space?.id || 'N/A';
-    if (spaceName === 'Unknown Space' && task.space?.id) {
-        const spaceDetails = await getSpaceDetails(task.space.id);
-        if (spaceDetails && spaceDetails.name) {
-            spaceName = spaceDetails.name;
-        }
-    }
-    const metadataLines = [
-        `task_id: ${task.id}`,
-        `name: ${task.name}`,
-        `status: ${task.status.status}`,
-        `date_created: ${new Date(+task.date_created)}`,
-        `date_updated: ${new Date(+task.date_updated)}`,
-        `creator: ${task.creator.username}`,
-        `assignee: ${task.assignees.map((a) => a.username).join(', ')}`,
-        `list: ${task.list.name} (${task.list.id})`,
-        `space: ${spaceName} (${spaceIdForDisplay})`,
-    ];
-    // Add priority if it exists
-    if (task.priority !== undefined && task.priority !== null) {
-        const priorityName = task.priority.priority || 'none';
-        metadataLines.push(`priority: ${priorityName}`);
-    }
-    // Add due date if it exists
-    if (task.due_date) {
-        metadataLines.push(`due_date: ${new Date(+task.due_date)}`);
-    }
-    // Add start date if it exists
-    if (task.start_date) {
-        metadataLines.push(`start_date: ${new Date(+task.start_date)}`);
-    }
-    // Add time estimate if it exists
-    if (task.time_estimate) {
-        const hours = Math.floor(task.time_estimate / 3600000);
-        const minutes = Math.floor((task.time_estimate % 3600000) / 60000);
-        metadataLines.push(`time_estimate: ${hours}h ${minutes}m`);
-    }
-    // Add tags if they exist
-    if (task.tags && task.tags.length > 0) {
-        metadataLines.push(`tags: ${task.tags.map((t) => t.name).join(', ')}`);
-    }
-    // Add watchers if they exist
-    if (task.watchers && task.watchers.length > 0) {
-        metadataLines.push(`watchers: ${task.watchers.map((w) => w.username).join(', ')}`);
-    }
-    // Add parent task information if it exists
-    if (typeof task.parent === "string") {
-        metadataLines.push(`parent_task_id: ${task.parent}`);
-    }
-    // Add child task information if it exists
-    if (task.subtasks && task.subtasks.length > 0) {
-        metadataLines.push(`child_task_ids: ${task.subtasks.map((st) => st.id).join(', ')}`);
-    }
-    // Add task URL
-    metadataLines.push(`url: ${task.url}`);
-    // Add archived status if true
-    if (task.archived) {
-        metadataLines.push(`archived: true`);
-    }
-    // Add custom fields if they exist
-    if (task.custom_fields && task.custom_fields.length > 0) {
-        task.custom_fields.forEach((field) => {
-            if (field.value !== undefined && field.value !== null && field.value !== '') {
-                const fieldName = field.name.toLowerCase().replace(/\s+/g, '_');
-                let fieldValue = field.value;
-                // Handle different custom field types
-                if (field.type === 'drop_down' && typeof field.value === 'number') {
-                    // For dropdown fields, find the selected option
-                    const selectedOption = field.type_config?.options?.find((opt) => opt.orderindex === field.value);
-                    fieldValue = selectedOption?.name || field.value;
-                }
-                else if (Array.isArray(field.value)) {
-                    // For multi-select or array values
-                    fieldValue = field.value.map((v) => v.name || v).join(', ');
-                }
-                else if (typeof field.value === 'object') {
-                    // For object values (like users), extract meaningful data
-                    fieldValue = field.value.username || field.value.name || JSON.stringify(field.value);
-                }
-                metadataLines.push(`custom_${fieldName}: ${fieldValue}`);
-            }
-        });
-    }
-    return {
-        type: "text",
-        text: metadataLines.join("\n"),
-    };
-}
-const spaceCache = new Map(); // Global cache for space details promises
-/**
- * Function to get space details, using a cache to avoid redundant fetches
- */
-async function getSpaceDetails(spaceId) {
-    if (!spaceId) {
-        return null;
-    }
-    if (!spaceCache.has(spaceId)) {
-        const fetchPromise = fetch(`https://api.clickup.com/api/v2/space/${spaceId}`, {
-            headers: { Authorization: CONFIG.apiKey },
-        })
-            .then(res => {
-            if (!res.ok) {
-                // Don't cache failed requests, or handle errors more gracefully
-                console.error(`Error fetching space ${spaceId}: ${res.status}`);
-                spaceCache.delete(spaceId); // Allow retry on next call
-                return null;
-            }
-            return res.json();
-        })
-            .catch(error => {
-            console.error(`Network error fetching space ${spaceId}:`, error);
-            spaceCache.delete(spaceId); // Allow retry on next call
-            return null;
-        });
-        spaceCache.set(spaceId, fetchPromise);
-    }
-    return spaceCache.get(spaceId);
-}
-/**
- * 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);
-        }
-    });
-    // 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;
-    });
+exports.server = server;
+// Register tools based on mode with user data for enhanced documentation
+async function initializeServer() {
+    console.error(`Starting ClickUp MCP in ${config_1.CONFIG.mode} mode`);
+    // Fetch current user for enhanced tool documentation and API health check
+    const userData = await (0, utils_1.getCurrentUser)();
+    console.error(`Connected as: ${userData.user.username} (${userData.user.email})`);
+    if (config_1.CONFIG.mode === 'read-minimal') {
+        // Core task context tools for AI coding assistance
+        // Only getTaskById and searchTasks
+        (0, task_tools_1.registerTaskToolsRead)(server, userData);
+        (0, search_tools_1.registerSearchTools)(server);
+    }
+    else if (config_1.CONFIG.mode === 'read') {
+        // All read-only tools
+        (0, task_tools_1.registerTaskToolsRead)(server, userData);
+        (0, search_tools_1.registerSearchTools)(server);
+        (0, space_tools_1.registerSpaceTools)(server);
+        (0, list_tools_1.registerListToolsRead)(server);
+        (0, time_tools_1.registerTimeToolsRead)(server);
+    }
+    else if (config_1.CONFIG.mode === 'write') {
+        // All tools (full functionality)
+        (0, task_tools_1.registerTaskToolsRead)(server, userData);
+        (0, task_tools_1.registerTaskToolsWrite)(server, userData);
+        (0, search_tools_1.registerSearchTools)(server);
+        (0, space_tools_1.registerSpaceTools)(server);
+        (0, list_tools_1.registerListToolsRead)(server);
+        (0, list_tools_1.registerListToolsWrite)(server);
+        (0, time_tools_1.registerTimeToolsRead)(server);
+        (0, time_tools_1.registerTimeToolsWrite)(server);
+    }
+    return server;
 }
-let taskSearchIndex = null;
-let lastIndexUpdateTime = 0;
-const INDEX_REFRESH_INTERVAL = 60000; // 60 seconds
-const MAX_SEARCH_RESULTS = 50;
-// Dynamically construct the searchTask description
-const searchTaskDescriptionBase = [
-    "Searches tasks by name, content, assignees, and ID (case insensitive) with fuzzy matching and support for multiple search terms (OR logic).",
-    // 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.",
-];
-if (CONFIG.primaryLanguageHint && CONFIG.primaryLanguageHint.toLowerCase() !== 'en') {
-    searchTaskDescriptionBase.splice(1, 0, `For optimal results, as your ClickUp tasks may be primarily in '${CONFIG.primaryLanguageHint}', consider providing search terms in English and '${CONFIG.primaryLanguageHint}'.`);
-}
-exports.server.tool("searchTask", searchTaskDescriptionBase.join("\n"), {
-    terms: zod_1.z
-        .string()
-        .min(3)
-        .describe("Search terms separated by '|' for OR logic (e.g., 'term1|term2|term3') or a direct task ID"),
-}, async ({ terms }) => {
-    const now = Date.now();
-    if (!taskSearchIndex || (now - lastIndexUpdateTime > INDEX_REFRESH_INTERVAL)) {
-        console.error('Refreshing ClickUp task index...');
-        const taskListsPromises = [...Array(30)].map((_, i) => {
-            return fetch(`https://api.clickup.com/api/v2/team/${CONFIG.teamId}/task?order_by=updated&page=${i}&subtasks=true`, { headers: { Authorization: CONFIG.apiKey } }).then((res) => res.json()).catch(e => {
-                console.error(`Error fetching page ${i} for index:`, e);
-                return { tasks: [] };
-            });
-        });
-        const taskLists = await Promise.all(taskListsPromises);
-        const allFetchedTasks = taskLists.flatMap(taskList => taskList.tasks);
-        if (allFetchedTasks.length > 0) {
-            taskSearchIndex = new fuse_js_1.default(allFetchedTasks, {
-                keys: [
-                    { name: 'name', weight: 0.7 },
-                    { name: 'id', weight: 0.6 },
-                    { name: 'text_content', weight: 0.5 }, // Task description/content
-                    { name: 'tags.name', weight: 0.4 }, // Task Tags
-                    { name: 'assignees.username', weight: 0.4 }, // Task Assignees
-                    { name: 'list.name', weight: 0.3 }, // Name of the List the task is in
-                    { name: 'folder.name', weight: 0.2 }, // Name of the Folder the task is in
-                    { name: 'space.name', weight: 0.1 } // Name of the Space the task is in
-                ],
-                includeScore: true,
-                threshold: 0.4,
-                minMatchCharLength: 2,
-            });
-            lastIndexUpdateTime = now;
-            console.error(`Task index refreshed with ${allFetchedTasks.length} tasks.`);
-        }
-        else {
-            console.error('No tasks fetched to build search index.');
-            // Potentially keep the old index if fetching failed, or clear it
-            // For now, if fetching fails to get any tasks, the index won't update.
-        }
-    }
-    const searchTermsArray = terms
-        .split("|")
-        .map((term) => term.trim())
-        .filter(term => term.length > 0);
-    if (searchTermsArray.length === 0) {
-        return { content: [{ type: "text", text: "No search terms provided." }] };
-    }
-    const uniqueResults = new Map();
-    if (taskSearchIndex) {
-        searchTermsArray.forEach(term => {
-            const results = taskSearchIndex.search(term.toLowerCase());
-            results.forEach(result => {
-                if (result.item && typeof result.item.id === 'string') {
-                    const currentScore = result.score ?? 1; // Default to 1 if undefined
-                    const existing = uniqueResults.get(result.item.id);
-                    if (!existing || currentScore < existing.score) {
-                        uniqueResults.set(result.item.id, { item: result.item, score: currentScore });
-                    }
-                }
-            });
-        });
-    }
-    // Task ID Fallback Logic
-    const potentialTaskIds = searchTermsArray.filter(isTaskId);
-    const foundTaskIdsByFuse = new Set(Array.from(uniqueResults.keys()).map(id => id.toLowerCase())); // Store lowercase for comparison
-    // Filter task IDs that were not found by Fuse, comparing case-insensitively
-    const taskIdsToFetchDirectly = potentialTaskIds.filter(id => {
-        const lowerId = id.toLowerCase();
-        return !foundTaskIdsByFuse.has(lowerId);
-    });
-    if (taskIdsToFetchDirectly.length > 0) {
-        console.error(`Attempting direct fetch for task IDs: ${taskIdsToFetchDirectly.join(', ')}`);
-        const directFetchPromises = taskIdsToFetchDirectly.map(async (id) => {
-            try {
-                const response = await fetch(`https://api.clickup.com/api/v2/task/${id}`, { headers: { Authorization: CONFIG.apiKey } });
-                if (response.ok) {
-                    const task = await response.json();
-                    if (task && typeof task.id === 'string') {
-                        // Add/update with a perfect score if fetched directly, unless a better Fuse score already exists
-                        const existing = uniqueResults.get(task.id);
-                        if (!existing || 0 < existing.score) { // 0 is a perfect score
-                            uniqueResults.set(task.id, { item: task, score: 0 });
-                        }
-                    }
-                    return task;
-                }
-                return null;
-            }
-            catch (error) {
-                console.error(`Error directly fetching task ${id}:`, error);
-                return null;
-            }
-        });
-        await Promise.all(directFetchPromises);
-    }
-    const sortedResults = Array.from(uniqueResults.values())
-        .sort((a, b) => a.score - b.score) // Sort by score, ascending (lower is better)
-        .map(entry => entry.item)
-        .slice(0, MAX_SEARCH_RESULTS); // Limit the number of results
-    if (sortedResults.length === 0) {
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: "No tasks found matching the search terms.",
-                },
-            ],
-        };
-    }
-    return {
-        content: await Promise.all(sortedResults.map((task) => generateTaskMetadata(task))),
-    };
-});
-exports.server.tool("listTodo", "Lists all open tasks for the current user.", async () => {
-    // fetch current user ID
-    const userResp = await fetch("https://api.clickup.com/api/v2/user", {
-        headers: { Authorization: CONFIG.apiKey },
-    }).then((res) => res.json());
-    const userId = userResp.user.id;
-    // page through team tasks assigned to this user
-    const taskLists = await Promise.all([...Array(10)].map((_, i) => fetch(`https://api.clickup.com/api/v2/team/${CONFIG.teamId}/task?order_by=updated&page=${i}&assignees[]=${userId}`, { headers: { Authorization: CONFIG.apiKey } }).then((res) => res.json())));
-    const tasks = taskLists.flatMap((tl) => tl.tasks);
-    // filter out closed tasks
-    const openTasks = tasks
-        .filter((task) => task.status.type !== "done") // done is not closed but also not a todo
-        .slice(0, 50);
-    if (openTasks.length === 0) {
-        return {
-            content: [
-                { type: "text", text: "No open tasks found for the current user." },
-            ],
-        };
-    }
-    return {
-        content: await Promise.all(openTasks.map((task) => generateTaskMetadata(task))),
-    };
-});
+// Initialize server with enhanced documentation and export
+const serverPromise = initializeServer();
+exports.serverPromise = serverPromise;
 // Only connect to the transport if this file is being run directly (not imported)
 if (require.main === module) {
-    // Start receiving messages on stdin and sending messages on stdout
-    const transport = new stdio_js_1.StdioServerTransport();
-    exports.server.connect(transport);
+    // Start receiving messages on stdin and sending messages on stdout after initialization
+    serverPromise.then(() => {
+        const transport = new stdio_js_1.StdioServerTransport();
+        server.connect(transport);
+    }).catch(console.error);
 }

package/dist/shared/config.d.ts

@@ -0,0 +1,10 @@
+export declare const rawPrimaryLang: string | undefined;
+export type McpMode = 'read-minimal' | 'read' | 'write';
+export declare const CONFIG: {
+    apiKey: string;
+    teamId: string;
+    maxImages: number;
+    primaryLanguageHint: string | undefined;
+    mode: McpMode;
+};
+//# sourceMappingURL=config.d.ts.map

package/dist/shared/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/shared/config.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,cAAc,oBAA2D,CAAC;AAavF,MAAM,MAAM,OAAO,GAAG,cAAc,GAAG,MAAM,GAAG,OAAO,CAAC;AAUxD,eAAO,MAAM,MAAM;;;;;;CAMlB,CAAC"}

package/dist/shared/config.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CONFIG = exports.rawPrimaryLang = void 0;
+exports.rawPrimaryLang = process.env.CLICKUP_PRIMARY_LANGUAGE || process.env.LANG;
+let detectedLanguageHint = undefined;
+if (exports.rawPrimaryLang) {
+    // Extract the primary language part (e.g., 'en' from 'en_US.UTF-8' or 'en-GB')
+    // and convert to lowercase.
+    const langPart = exports.rawPrimaryLang.match(/^[a-zA-Z]{2,3}/);
+    if (langPart) {
+        detectedLanguageHint = langPart[0].toLowerCase();
+    }
+}
+const rawMode = process.env.CLICKUP_MCP_MODE?.toLowerCase();
+let mcpMode = 'write'; // Default to write (full functionality)
+if (rawMode === 'read-minimal' || rawMode === 'read') {
+    mcpMode = rawMode;
+}
+else if (rawMode && rawMode !== 'write') {
+    console.error(`Invalid CLICKUP_MCP_MODE "${rawMode}". Using default "write". Valid options: read-minimal, read, write`);
+}
+exports.CONFIG = {
+    apiKey: process.env.CLICKUP_API_KEY,
+    teamId: process.env.CLICKUP_TEAM_ID,
+    maxImages: process.env.MAX_IMAGES ? parseInt(process.env.MAX_IMAGES) : 4,
+    primaryLanguageHint: detectedLanguageHint, // Store the cleaned code directly
+    mode: mcpMode,
+};
+if (!exports.CONFIG.apiKey || !exports.CONFIG.teamId) {
+    throw new Error("Missing Clickup API key or team ID");
+}

package/dist/shared/types.d.ts

@@ -0,0 +1,13 @@
+import { CallToolResult } from "@modelcontextprotocol/sdk/types";
+export type ContentBlock = CallToolResult['content'][number];
+export interface DatedContentEvent {
+    date: string;
+    contentBlocks: ContentBlock[];
+}
+export interface Config {
+    apiKey: string;
+    teamId: string;
+    maxImages: number;
+    primaryLanguageHint: string | undefined;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/shared/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/shared/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,iCAAiC,CAAC;AAGjE,MAAM,MAAM,YAAY,GAAG,cAAc,CAAC,SAAS,CAAC,CAAC,MAAM,CAAC,CAAC;AAG7D,MAAM,WAAW,iBAAiB;IAChC,IAAI,EAAE,MAAM,CAAC;IACb,aAAa,EAAE,YAAY,EAAE,CAAC;CAC/B;AAGD,MAAM,WAAW,MAAM;IACrB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,mBAAmB,EAAE,MAAM,GAAG,SAAS,CAAC;CACzC"}

package/dist/shared/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/shared/utils.d.ts

@@ -0,0 +1,30 @@
+import { ContentBlock } from "./types";
+import Fuse from 'fuse.js';
+/**
+ * Checks if a string looks like a valid ClickUp task ID
+ * Valid task IDs are 6-9 characters long and contain only alphanumeric characters
+ */
+export declare function isTaskId(str: string): boolean;
+/**
+ * Get current authenticated user information from ClickUp API
+ * Caches the result after first successful fetch to avoid repeated API calls during the session
+ */
+export declare function getCurrentUser(): Promise<any>;
+/**
+ * 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
+ */
+export declare function limitImages(content: ContentBlock[], maxImages: number): ContentBlock[];
+/**
+ * Function to get space details, using a cache to avoid redundant fetches
+ */
+export declare function getSpaceDetails(spaceId: string): Promise<any>;
+/**
+ * Get or create a task search index with specified filters
+ */
+export declare function getTaskSearchIndex(space_ids?: string[], list_ids?: string[], assignees?: string[]): Promise<Fuse<any> | null>;
+//# sourceMappingURL=utils.d.ts.map

package/dist/shared/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/shared/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,YAAY,EAAC,MAAM,SAAS,CAAC;AAErC,OAAO,IAAI,MAAM,SAAS,CAAC;AAI3B;;;GAGG;AACH,wBAAgB,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAG7C;AAKD;;;GAGG;AACH,wBAAsB,cAAc,iBAiBnC;AAED;;;;;;;GAOG;AACH,wBAAgB,WAAW,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,SAAS,EAAE,MAAM,GAAG,YAAY,EAAE,CA8BtF;AAID;;GAEG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,GAAG,CAAC,CA0B7D;AAKD;;GAEG;AACH,wBAAsB,kBAAkB,CACtC,SAAS,CAAC,EAAE,MAAM,EAAE,EACpB,QAAQ,CAAC,EAAE,MAAM,EAAE,EACnB,SAAS,CAAC,EAAE,MAAM,EAAE,GACnB,OAAO,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,IAAI,CAAC,CA4B3B"}