@pripanggalih/clickup-mcp 1.6.1

package/dist/tools/search-tools.js

@@ -0,0 +1,161 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerSearchTools = registerSearchTools;
+const zod_1 = require("zod");
+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, userData) {
+    // Dynamically construct the searchTasks description
+    const searchTasksDescriptionBase = [
+        "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.",
+        "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.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())
+            .optional()
+            .describe("Array of search terms (OR logic). Can include task IDs. Optional - if not provided, returns most recent tasks."),
+        list_ids: zod_1.z
+            .array(zod_1.z.string())
+            .optional()
+            .describe("Filter tasks to specific list IDs"),
+        space_ids: zod_1.z
+            .array(zod_1.z.string())
+            .optional()
+            .describe("Filter tasks to specific space IDs"),
+        only_todo: zod_1.z
+            .boolean()
+            .optional()
+            .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 (${userData.user.username} (${userData.user.id}))`),
+    }, {
+        readOnlyHint: true
+    }, async ({ terms, list_ids, space_ids, only_todo, status, assigned_to_me }) => {
+        // Get current user ID if filtering by assigned_to_me
+        const assignees = assigned_to_me ? [userData.user.id] : [];
+        const searchIndex = await (0, utils_1.getTaskSearchIndex)(space_ids, list_ids, assignees);
+        if (!searchIndex) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: "No tasks available or index could not be built.",
+                    },
+                ],
+            };
+        }
+        // Early return for no search terms
+        if (!terms || terms.length === 0) {
+            let allTasks = searchIndex._docs || [];
+            // 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
+                .sort((a, b) => {
+                const dateA = parseInt(a.date_updated || "0");
+                const dateB = parseInt(b.date_updated || "0");
+                return dateB - dateA;
+            })
+                .slice(0, MAX_SEARCH_RESULTS);
+            if (resultTasks.length === 0) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: "No tasks found.",
+                        },
+                    ],
+                };
+            }
+            return {
+                content: await Promise.all(resultTasks.map((task) => (0, task_tools_1.generateTaskMetadata)(task))),
+            };
+        }
+        // Create a results map to track unique tasks with scores
+        const uniqueResults = new Map();
+        // 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 = 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();
+            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_1.CONFIG.apiKey } });
+                    if (response.ok) {
+                        const task = await response.json();
+                        if (task && typeof task.id === 'string') {
+                            const existing = uniqueResults.get(task.id);
+                            if (!existing || 0 < existing.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);
+        }
+        let resultTasks = Array.from(uniqueResults.values())
+            .sort((a, b) => a.score - b.score)
+            .map(entry => entry.item);
+        // 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);
+        if (resultTasks.length === 0) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: "No tasks found matching the search criteria.",
+                    },
+                ],
+            };
+        }
+        return {
+            content: await Promise.all(resultTasks.map((task) => (0, task_tools_1.generateTaskMetadata)(task))),
+        };
+    });
+}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"space-tools.d.ts","sourceRoot":"","sources":["../../src/tools/space-tools.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAKpE,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,SAAS,QA6InD"}

package/dist/tools/space-tools.js

@@ -0,0 +1,128 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerSpaceTools = registerSpaceTools;
+const zod_1 = require("zod");
+const utils_1 = require("../shared/utils");
+function registerSpaceTools(server) {
+    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)")
+    }, {
+        readOnlyHint: true
+    }, async ({ terms, archived = false }) => {
+        try {
+            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);
+            }
+            if (matchingSpaces.length === 0) {
+                return {
+                    content: [{ type: "text", text: "No spaces found matching the search criteria." }],
+                };
+            }
+            // 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 }) => {
+                    // Use shared tree formatting function
+                    const spaceTreeText = (0, utils_1.formatSpaceTree)(space, lists, folders, documents);
+                    // Add the complete space as a single content block
+                    contentBlocks.push({
+                        type: "text",
+                        text: spaceTreeText
+                    });
+                });
+            }
+            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: 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:`
+                    },
+                    ...contentBlocks
+                ],
+            };
+        }
+        catch (error) {
+            console.error('Error searching spaces:', error);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error searching spaces: ${error instanceof Error ? error.message : 'Unknown error'}`,
+                    },
+                ],
+            };
+        }
+    });
+}

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

@@ -0,0 +1,8 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { ContentBlock } from "../shared/types";
+export declare function registerTaskToolsRead(server: McpServer, userData: any): void;
+/**
+ * Helper function to generate consistent task metadata
+ */
+export declare function generateTaskMetadata(task: any, timeEntries?: any[], isDetailView?: boolean): Promise<ContentBlock>;
+//# sourceMappingURL=task-tools.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"task-tools.d.ts","sourceRoot":"","sources":["../../src/tools/task-tools.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAGpE,OAAO,EAAE,YAAY,EAAyC,MAAM,iBAAiB,CAAC;AAOtF,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,SAAS,EAAE,QAAQ,EAAE,GAAG,QA2DrE;AA+MD;;GAEG;AACH,wBAAsB,oBAAoB,CAAC,IAAI,EAAE,GAAG,EAAE,WAAW,CAAC,EAAE,GAAG,EAAE,EAAE,YAAY,GAAE,OAAe,GAAG,OAAO,CAAC,YAAY,CAAC,CAmH/H"}

package/dist/tools/task-tools.js

@@ -0,0 +1,329 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerTaskToolsRead = registerTaskToolsRead;
+exports.generateTaskMetadata = generateTaskMetadata;
+const zod_1 = require("zod");
+const clickup_text_1 = require("../clickup-text");
+const config_1 = require("../shared/config");
+const utils_1 = require("../shared/utils");
+const image_processing_1 = require("../shared/image-processing");
+// Read-specific utility functions
+function registerTaskToolsRead(server, userData) {
+    server.tool("getTaskById", [
+        "Get a ClickUp task with images and comments by ID.",
+        "Always use this URL when referencing tasks in conversations or sharing with others.",
+        "The response provides complete context including task details, comments, and status history."
+    ].join("\n"), {
+        id: zod_1.z
+            .string()
+            .min(6)
+            .max(9)
+            .refine(val => (0, utils_1.isTaskId)(val), {
+            message: "Task ID must be 6-9 alphanumeric characters only"
+        })
+            .describe(`The 6-9 character ID of the task to get without a prefix like "#", "CU-" or "https://app.clickup.com/t/"`),
+    }, {
+        readOnlyHint: true
+    }, 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. Download images with smart size limiting
+        const limitedContent = await (0, image_processing_1.downloadImages)(allContentBlocks);
+        return {
+            content: limitedContent,
+        };
+    });
+}
+/**
+ * Fetch time entries for a specific task (all time, not date-limited for detail view)
+ */
+async function fetchTaskTimeEntries(taskId) {
+    try {
+        // Get all team members for assignee filter
+        const teamMembers = await (0, utils_1.getAllTeamMembers)();
+        const params = new URLSearchParams({
+            task_id: taskId,
+            include_location_names: 'true',
+            start_date: '0', // overwrite the default 30 days
+        });
+        if (teamMembers.length > 0) {
+            params.append('assignee', teamMembers.join(','));
+        }
+        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 task ${taskId}: ${response.status} ${response.statusText}`);
+            return [];
+        }
+        const data = await response.json();
+        return data.data || [];
+    }
+    catch (error) {
+        console.error('Error fetching task time entries:', error);
+        return [];
+    }
+}
+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_1.CONFIG.apiKey } });
+    const task = await response.json();
+    const [taskMetadata, content] = await Promise.all([
+        // Create the task metadata block using the helper functions
+        (async () => {
+            const timeEntries = await fetchTaskTimeEntries(task.id);
+            return await generateTaskMetadata(task, timeEntries, true);
+        })(),
+        // process markdown and download images
+        (0, clickup_text_1.convertMarkdownToToolCallResult)(task.markdown_description || "", task.attachments || []),
+    ]);
+    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_1.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 ${timestampToIso(comment.date)}:`,
+        };
+        const commentBodyBlocks = await (0, clickup_text_1.convertClickUpTextItemsToToolCallResult)(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_1.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 ${timestampToIso(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 => {
+            const firstBlock = event.contentBlocks[0];
+            const textKey = firstBlock && 'text' in firstBlock ? firstBlock.text : 'unknown';
+            return [`${event.date}-${textKey}`, event];
+        })).values());
+        return uniqueEvents;
+    }
+    catch (error) {
+        console.error(`Exception fetching time in status for task ${taskId}:`, error);
+        return [];
+    }
+}
+/**
+ * Formats timestamp to ISO string with local timezone (not UTC)
+ */
+function timestampToIso(timestamp) {
+    const date = new Date(+timestamp);
+    const year = date.getFullYear();
+    const month = String(date.getMonth() + 1).padStart(2, '0');
+    const day = String(date.getDate()).padStart(2, '0');
+    const hours = String(date.getHours()).padStart(2, '0');
+    const minutes = String(date.getMinutes()).padStart(2, '0');
+    // Calculate timezone offset
+    const offset = date.getTimezoneOffset();
+    const offsetHours = Math.floor(Math.abs(offset) / 60);
+    const offsetMinutes = Math.abs(offset) % 60;
+    const sign = offset <= 0 ? '+' : '-';
+    const timezoneOffset = sign + String(offsetHours).padStart(2, '0') + ':' + String(offsetMinutes).padStart(2, '0');
+    return `${year}-${month}-${day}T${hours}:${minutes}${timezoneOffset}`;
+}
+/**
+ * Helper function to filter and format time entries for a specific task
+ */
+function filterTaskTimeEntries(taskId, timeEntries) {
+    if (!timeEntries || timeEntries.length === 0) {
+        return null;
+    }
+    // Filter entries for this specific task
+    const taskEntries = timeEntries.filter((entry) => entry.task?.id === taskId);
+    if (taskEntries.length === 0) {
+        return null;
+    }
+    // Group time entries by user (same logic as original getTaskTimeEntries)
+    const timeByUser = new Map();
+    taskEntries.forEach((entry) => {
+        const username = entry.user?.username || 'Unknown User';
+        const currentTime = timeByUser.get(username) || 0;
+        const entryDurationMs = parseInt(entry.duration) || 0;
+        timeByUser.set(username, currentTime + entryDurationMs);
+    });
+    // Format results (same logic as original)
+    const userTimeEntries = [];
+    for (const [username, totalMs] of timeByUser.entries()) {
+        const hours = totalMs / (1000 * 60 * 60);
+        const displayHours = Math.floor(hours);
+        const displayMinutes = Math.round((hours - displayHours) * 60);
+        const timeDisplay = displayHours > 0 ?
+            `${displayHours}h ${displayMinutes}m` :
+            `${displayMinutes}m`;
+        userTimeEntries.push(`${username}: ${timeDisplay}`);
+    }
+    return userTimeEntries.length > 0 ? userTimeEntries.join(', ') : null;
+}
+/**
+ * Helper function to generate consistent task metadata
+ */
+async function generateTaskMetadata(task, timeEntries, isDetailView = false) {
+    let spaceName = task.space?.name || 'Unknown Space';
+    let spaceIdForDisplay = task.space?.id || 'N/A';
+    if (spaceName === 'Unknown Space' && task.space?.id) {
+        try {
+            const spaceDetails = await (0, utils_1.getSpaceDetails)(task.space.id);
+            if (spaceDetails && spaceDetails.name) {
+                spaceName = spaceDetails.name;
+            }
+        }
+        catch {
+            // Space details fetch can fail (e.g. 401) - gracefully keep "Unknown Space"
+        }
+    }
+    const metadataLines = [
+        `task_id: ${task.id}`,
+        `task_url: ${task.url}`,
+        `name: ${task.name}`,
+        `status: ${task.status.status}`,
+        `date_created: ${timestampToIso(task.date_created)}`,
+        `date_updated: ${timestampToIso(task.date_updated)}`,
+        `creator: ${task.creator.username} (${task.creator.id})`,
+        `assignee: ${task.assignees.map((a) => `${a.username} (${a.id})`).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: ${timestampToIso(task.due_date)}`);
+    }
+    // Add start date if it exists
+    if (task.start_date) {
+        metadataLines.push(`start_date: ${timestampToIso(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 time booked (tracked time entries) - only if timeEntries provided
+    if (timeEntries) {
+        const timeBooked = filterTaskTimeEntries(task.id, timeEntries);
+        if (timeBooked) {
+            const disclaimer = isDetailView ? "" : " (last 30 days)";
+            metadataLines.push(`time_booked${disclaimer}: ${timeBooked}`);
+        }
+    }
+    // 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 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"),
+    };
+}

package/dist/tools/task-write-tools.d.ts

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

package/dist/tools/task-write-tools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"task-write-tools.d.ts","sourceRoot":"","sources":["../../src/tools/task-write-tools.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAcpE,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,SAAS,EAAE,QAAQ,EAAE,GAAG,QAsZtE"}