@hauptsache.net/clickup-mcp 1.7.2 → 1.8.0

package/README.md

@@ -78,7 +78,7 @@ Turn natural language into powerful ClickUp actions:
 - Filter by assignees, projects, status, and metadata
 
 ### 💬 **Complete Context**
-- Full comment histories and team discussions
+- Comment histories and team discussions (up to 250 top-level comments), including threaded comment replies
 - Task descriptions with embedded images  
 - List descriptions and project guidelines
 - Document content with page navigation
@@ -186,8 +186,8 @@ The ClickUp MCP supports three operational modes to balance functionality, secur
 
 | Tool                   | read-minimal | read | write | Description                                                                             |
 |------------------------|:------------:|:----:|:-----:|-----------------------------------------------------------------------------------------|
-| `getTaskById`          |      ✅       |  ✅   |   ✅   | Get complete task details including comments, images, and metadata                      |
-| `addComment`           |      ❌       |  ❌   |   ✅   | Add comments to tasks for collaboration                                                 |
+| `getTaskById`          |      ✅       |  ✅   |   ✅   | Get complete task details including comments (with threaded replies), images, and metadata |
+| `addComment`           |      ❌       |  ❌   |   ✅   | Add comments to tasks, or reply inside a comment thread via `parent_comment_id`         |
 | `editComment`          |      ❌       |  ❌   |   ✅   | Correct your own comment within 24h instead of posting a follow-up                      |
 | `updateTask`           |      ❌       |  ❌   |   ✅   | Update tasks (status, priority, assignees, etc.) with **SAFE APPEND-ONLY** descriptions |
 | `createTask`           |      ❌       |  ❌   |   ✅   | Create new tasks with full markdown support                                             |

package/dist/clickup-text.js

@@ -476,7 +476,7 @@ function buildImageFragment(attachment, caption) {
  * fragment (e.g. ?comment=... deep links) do NOT match, because a mention would
  * either not resolve or lose the anchor - those stay ordinary links.
  */
-const CLICKUP_TASK_URL_PATTERN = /^https?:\/\/app\.clickup\.com\/t\/(?:\d+\/)?([a-z0-9]{6,12})\/?$/;
+const CLICKUP_TASK_URL_PATTERN = /^https?:\/\/app\.clickup\.com\/t\/(?:\d+\/)?([a-z0-9]{6,16})\/?$/;
 /**
  * Extract the task ID from a ClickUp task URL, or null if it is not one.
  */

package/dist/shared/comments.d.ts

@@ -0,0 +1,65 @@
+/** A task comment as returned by GET /api/v2/task/{task_id}/comment or GET /comment/{id}/reply */
+export interface ExistingComment {
+    id: string;
+    date: string;
+    comment?: any[];
+    comment_text?: string;
+    user?: {
+        id?: number | string;
+        username?: string;
+    };
+    reply_count?: number;
+}
+/** Cursor into the comment list: the date and id of the last comment of the previous page */
+export interface CommentPageCursor {
+    start: string;
+    startId: string;
+}
+/**
+ * Never page further back than this. A busy ticket would otherwise walk its
+ * entire comment history and eat the 100 calls/minute budget.
+ */
+export declare const MAX_COMMENT_PAGES = 10;
+/** One page of task comments, newest first, 25 per page */
+export declare function fetchCommentPage(taskId: string, cursor?: CommentPageCursor): Promise<ExistingComment[]>;
+/**
+ * All top-level comments of a task, newest first.
+ *
+ * The comment list endpoint returns 25 comments per page, so longer histories are
+ * paged with `start`/`start_id`. Paging is capped at MAX_COMMENT_PAGES (250 comments)
+ * to protect the API budget; hitting the cap is logged instead of failing.
+ */
+export declare function fetchAllTopLevelComments(taskId: string): Promise<ExistingComment[]>;
+/**
+ * Find a top-level comment of a task by id, paging as far as MAX_COMMENT_PAGES.
+ *
+ * Unlike editComment's lookup this does not stop at the edit window, because a
+ * thread parent can be arbitrarily old. Returns undefined when the id is not a
+ * top-level comment of this task - which also catches reply ids, since replies
+ * never appear in the task's comment list.
+ */
+export declare function findTopLevelComment(taskId: string, commentId: string): Promise<ExistingComment | undefined>;
+/**
+ * The replies inside a comment thread, oldest first.
+ *
+ * `GET /task/{id}/comment` only returns top-level comments; the replies of a
+ * thread (Threaded Comments ClickApp) live behind `GET /comment/{id}/reply`.
+ * Any failure (non-ok response, network error, malformed body) is logged and
+ * returns an empty array so one broken thread does not take down the whole
+ * task view.
+ */
+export declare function fetchCommentReplies(commentId: string): Promise<ExistingComment[]>;
+/**
+ * Never fetch more threads than this per task read, and never more than a few
+ * at once - together with MAX_COMMENT_PAGES this keeps a single getTaskById
+ * within ClickUp's 100 calls/minute budget even on a heavily threaded task.
+ */
+export declare const MAX_REPLY_FETCHES = 30;
+/**
+ * Fetch the replies of every comment with reply_count > 0, bounded in count and
+ * concurrency. Returns a map of comment id -> replies; a thread that was skipped
+ * (over the cap) or failed to load is simply absent or empty, so callers can
+ * render a "replies not loaded" hint from reply_count.
+ */
+export declare function fetchRepliesByComment(comments: ExistingComment[]): Promise<Map<string, ExistingComment[]>>;
+//# sourceMappingURL=comments.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"comments.d.ts","sourceRoot":"","sources":["../../src/shared/comments.ts"],"names":[],"mappings":"AAEA,kGAAkG;AAClG,MAAM,WAAW,eAAe;IAC9B,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,EAAE,GAAG,EAAE,CAAC;IAChB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,IAAI,CAAC,EAAE;QAAE,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IACnD,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,6FAA6F;AAC7F,MAAM,WAAW,iBAAiB;IAChC,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;CACjB;AAED;;;GAGG;AACH,eAAO,MAAM,iBAAiB,KAAK,CAAC;AAKpC,2DAA2D;AAC3D,wBAAsB,gBAAgB,CACpC,MAAM,EAAE,MAAM,EACd,MAAM,CAAC,EAAE,iBAAiB,GACzB,OAAO,CAAC,eAAe,EAAE,CAAC,CAqB5B;AAED;;;;;;GAMG;AACH,wBAAsB,wBAAwB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,EAAE,CAAC,CA+BzF;AAED;;;;;;;GAOG;AACH,wBAAsB,mBAAmB,CACvC,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,MAAM,GAChB,OAAO,CAAC,eAAe,GAAG,SAAS,CAAC,CAiBtC;AAED;;;;;;;;GAQG;AACH,wBAAsB,mBAAmB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,EAAE,CAAC,CAsBvF;AAED;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,KAAK,CAAC;AAGpC;;;;;GAKG;AACH,wBAAsB,qBAAqB,CACzC,QAAQ,EAAE,eAAe,EAAE,GAC1B,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,eAAe,EAAE,CAAC,CAAC,CAsBzC"}

package/dist/shared/comments.js

@@ -0,0 +1,143 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAX_REPLY_FETCHES = exports.MAX_COMMENT_PAGES = void 0;
+exports.fetchCommentPage = fetchCommentPage;
+exports.fetchAllTopLevelComments = fetchAllTopLevelComments;
+exports.findTopLevelComment = findTopLevelComment;
+exports.fetchCommentReplies = fetchCommentReplies;
+exports.fetchRepliesByComment = fetchRepliesByComment;
+const config_1 = require("./config");
+/**
+ * Never page further back than this. A busy ticket would otherwise walk its
+ * entire comment history and eat the 100 calls/minute budget.
+ */
+exports.MAX_COMMENT_PAGES = 10;
+/** Page size ClickUp uses for the comment list - a shorter page means the last page. */
+const COMMENTS_PER_PAGE = 25;
+/** One page of task comments, newest first, 25 per page */
+async function fetchCommentPage(taskId, cursor) {
+    // Note there is no `start_date` parameter - passing one is silently ignored.
+    // Older pages are reached with `start` + `start_id` of the previous page's last entry.
+    const query = cursor
+        ? `?${new URLSearchParams({ start: cursor.start, start_id: cursor.startId })}`
+        : "";
+    const response = await fetch(`https://api.clickup.com/api/v2/task/${taskId}/comment${query}`, { headers: { Authorization: config_1.CONFIG.apiKey } });
+    if (!response.ok) {
+        const errorData = await response.json().catch(() => ({}));
+        throw new Error(`Error loading comments of task ${taskId}: ${response.status} ${response.statusText} - ${JSON.stringify(errorData)}`);
+    }
+    const data = await response.json();
+    return Array.isArray(data.comments) ? data.comments : [];
+}
+/**
+ * All top-level comments of a task, newest first.
+ *
+ * The comment list endpoint returns 25 comments per page, so longer histories are
+ * paged with `start`/`start_id`. Paging is capped at MAX_COMMENT_PAGES (250 comments)
+ * to protect the API budget; hitting the cap is logged instead of failing.
+ */
+async function fetchAllTopLevelComments(taskId) {
+    const comments = [];
+    let cursor;
+    let pages = 0;
+    let lastPageWasFull = false;
+    while (pages < exports.MAX_COMMENT_PAGES) {
+        const page = await fetchCommentPage(taskId, cursor);
+        pages++;
+        if (page.length === 0) {
+            lastPageWasFull = false;
+            break;
+        }
+        comments.push(...page);
+        lastPageWasFull = page.length >= COMMENTS_PER_PAGE;
+        if (!lastPageWasFull) {
+            break;
+        }
+        const oldest = page[page.length - 1];
+        cursor = { start: String(oldest.date), startId: String(oldest.id) };
+    }
+    if (lastPageWasFull && pages >= exports.MAX_COMMENT_PAGES) {
+        console.error(`Task ${taskId} has more than ${comments.length} top-level comments - older comments were not loaded (capped at ${exports.MAX_COMMENT_PAGES} pages).`);
+    }
+    return comments;
+}
+/**
+ * Find a top-level comment of a task by id, paging as far as MAX_COMMENT_PAGES.
+ *
+ * Unlike editComment's lookup this does not stop at the edit window, because a
+ * thread parent can be arbitrarily old. Returns undefined when the id is not a
+ * top-level comment of this task - which also catches reply ids, since replies
+ * never appear in the task's comment list.
+ */
+async function findTopLevelComment(taskId, commentId) {
+    let cursor;
+    for (let pages = 0; pages < exports.MAX_COMMENT_PAGES; pages++) {
+        const page = await fetchCommentPage(taskId, cursor);
+        const match = page.find((entry) => String(entry.id) === String(commentId));
+        if (match) {
+            return match;
+        }
+        if (page.length < COMMENTS_PER_PAGE) {
+            return undefined;
+        }
+        const oldest = page[page.length - 1];
+        cursor = { start: String(oldest.date), startId: String(oldest.id) };
+    }
+    return undefined;
+}
+/**
+ * The replies inside a comment thread, oldest first.
+ *
+ * `GET /task/{id}/comment` only returns top-level comments; the replies of a
+ * thread (Threaded Comments ClickApp) live behind `GET /comment/{id}/reply`.
+ * Any failure (non-ok response, network error, malformed body) is logged and
+ * returns an empty array so one broken thread does not take down the whole
+ * task view.
+ */
+async function fetchCommentReplies(commentId) {
+    try {
+        const response = await fetch(`https://api.clickup.com/api/v2/comment/${commentId}/reply`, { headers: { Authorization: config_1.CONFIG.apiKey } });
+        if (!response.ok) {
+            const errorData = await response.json().catch(() => ({}));
+            console.error(`Error fetching replies for comment ${commentId}: ${response.status} ${response.statusText} - ${JSON.stringify(errorData)}`);
+            return [];
+        }
+        const data = await response.json();
+        const replies = Array.isArray(data?.comments) ? data.comments : [];
+        return replies.sort((a, b) => Number(a.date) - Number(b.date));
+    }
+    catch (error) {
+        console.error(`Error fetching replies for comment ${commentId}:`, error);
+        return [];
+    }
+}
+/**
+ * Never fetch more threads than this per task read, and never more than a few
+ * at once - together with MAX_COMMENT_PAGES this keeps a single getTaskById
+ * within ClickUp's 100 calls/minute budget even on a heavily threaded task.
+ */
+exports.MAX_REPLY_FETCHES = 30;
+const REPLY_FETCH_CONCURRENCY = 5;
+/**
+ * Fetch the replies of every comment with reply_count > 0, bounded in count and
+ * concurrency. Returns a map of comment id -> replies; a thread that was skipped
+ * (over the cap) or failed to load is simply absent or empty, so callers can
+ * render a "replies not loaded" hint from reply_count.
+ */
+async function fetchRepliesByComment(comments) {
+    const threaded = comments.filter((comment) => (comment.reply_count ?? 0) > 0);
+    const toFetch = threaded.slice(0, exports.MAX_REPLY_FETCHES);
+    if (threaded.length > toFetch.length) {
+        console.error(`Skipping replies of ${threaded.length - toFetch.length} comment thread(s) - only the ${exports.MAX_REPLY_FETCHES} newest threads are loaded to stay within the API budget.`);
+    }
+    const replies = new Map();
+    let next = 0;
+    const worker = async () => {
+        while (next < toFetch.length) {
+            const comment = toFetch[next++];
+            replies.set(String(comment.id), await fetchCommentReplies(String(comment.id)));
+        }
+    };
+    await Promise.all(Array.from({ length: Math.min(REPLY_FETCH_CONCURRENCY, toFetch.length) }, worker));
+    return replies;
+}

package/dist/shared/utils.d.ts

@@ -1,7 +1,7 @@
 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
+ * Valid task IDs are 6-16 characters long and contain only alphanumeric characters
  */
 export declare function isTaskId(str: string): boolean;
 /**

package/dist/shared/utils.js

@@ -23,11 +23,11 @@ const fuse_js_1 = __importDefault(require("fuse.js"));
 const GLOBAL_REFRESH_INTERVAL = 60000; // 60 seconds - that is the rate limit time frame
 /**
  * Checks if a string looks like a valid ClickUp task ID
- * Valid task IDs are 6-9 characters long and contain only alphanumeric characters
+ * Valid task IDs are 6-16 characters long and contain only alphanumeric characters
  */
 function isTaskId(str) {
-    // Task IDs are 6-9 characters long and contain only alphanumeric characters
-    return /^[a-z0-9]{6,9}$/i.test(str);
+    // Task IDs are 6-16 characters long and contain only alphanumeric characters
+    return /^[a-z0-9]{6,16}$/i.test(str);
 }
 // Cache for current user info to avoid repeated API calls and race conditions
 let cachedUserPromise = null;

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

@@ -1 +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"}
+{"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;AAQtF,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,SAAS,EAAE,QAAQ,EAAE,GAAG,QA2DrE;AA2OD;;GAEG;AACH,wBAAsB,oBAAoB,CAAC,IAAI,EAAE,GAAG,EAAE,WAAW,CAAC,EAAE,GAAG,EAAE,EAAE,YAAY,GAAE,OAAe,GAAG,OAAO,CAAC,YAAY,CAAC,CAgJ/H"}

package/dist/tools/task-tools.js

@@ -7,6 +7,7 @@ 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");
+const comments_1 = require("../shared/comments");
 // Read-specific utility functions
 function registerTaskToolsRead(server, userData) {
     server.tool("getTaskById", [
@@ -17,11 +18,11 @@ function registerTaskToolsRead(server, userData) {
         id: zod_1.z
             .string()
             .min(6)
-            .max(9)
+            .max(16)
             .refine(val => (0, utils_1.isTaskId)(val), {
-            message: "Task ID must be 6-9 alphanumeric characters only"
+            message: "Task ID must be 6-16 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/"`),
+            .describe(`The 6-16 character ID of the task to get without a prefix like "#", "CU-" or "https://app.clickup.com/t/"`),
     }, {
         readOnlyHint: true
     }, async ({ id }) => {
@@ -98,26 +99,52 @@ async function loadTaskContent(taskId) {
     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 [];
+    let comments;
+    try {
+        // The comment list only returns 25 top-level comments per page - page through
+        // all of them (the previous `?start_date=0` was silently ignored by ClickUp).
+        comments = await (0, comments_1.fetchAllTopLevelComments)(id);
     }
-    const commentsData = await response.json();
-    if (!commentsData.comments || !Array.isArray(commentsData.comments)) {
-        console.error(`Unexpected comment data structure for task ${id}`);
+    catch (error) {
+        console.error(`Error fetching comments for task ${id}:`, error);
         return [];
     }
-    const commentEvents = await Promise.all(commentsData.comments.map(async (comment) => {
+    // Replies live behind their own endpoint and are missing from the comment
+    // list. Only threads (reply_count > 0) cost extra requests, bounded in count
+    // and concurrency to protect the API budget.
+    const repliesByComment = await (0, comments_1.fetchRepliesByComment)(comments);
+    const formatUser = (user) => `${user?.username ?? "unknown"} (user_id: ${user?.id ?? "unknown"})`;
+    const commentEvents = await Promise.all(comments.map(async (comment) => {
+        // The comment_id makes the comment addressable for editComment and for
+        // threaded replies via addComment's parent_comment_id.
         const headerBlock = {
             type: "text",
-            text: `Comment by ${comment.user.username} on ${timestampToIso(comment.date)}:`,
+            text: `Comment by ${formatUser(comment.user)} on ${timestampToIso(comment.date)} (comment_id: ${comment.id}):`,
         };
-        const commentBodyBlocks = await (0, clickup_text_1.convertClickUpTextItemsToToolCallResult)(comment.comment);
+        const commentBodyBlocks = await (0, clickup_text_1.convertClickUpTextItemsToToolCallResult)(comment.comment ?? []);
+        const contentBlocks = [headerBlock, ...commentBodyBlocks];
+        const replyCount = comment.reply_count ?? 0;
+        if (replyCount > 0) {
+            const replies = repliesByComment.get(String(comment.id)) ?? [];
+            for (const reply of replies) {
+                contentBlocks.push({
+                    type: "text",
+                    text: `↳ Reply by ${formatUser(reply.user)} on ${timestampToIso(reply.date)} (comment_id: ${reply.id}):`,
+                });
+                contentBlocks.push(...await (0, clickup_text_1.convertClickUpTextItemsToToolCallResult)(reply.comment ?? []));
+            }
+            if (replies.length === 0) {
+                // The thread exists (reply_count says so) but its replies were skipped
+                // over the budget cap or failed to load - never pretend it is empty.
+                contentBlocks.push({
+                    type: "text",
+                    text: `↳ This comment has ${replyCount} repl${replyCount === 1 ? "y" : "ies"} that could not be loaded.`,
+                });
+            }
+        }
         return {
             date: comment.date, // String timestamp from ClickUp for sorting
-            contentBlocks: [headerBlock, ...commentBodyBlocks],
+            contentBlocks,
         };
     }));
     return commentEvents;
@@ -294,6 +321,32 @@ async function generateTaskMetadata(task, timeEntries, isDetailView = false) {
     if (task.subtasks && task.subtasks.length > 0) {
         metadataLines.push(`child_task_ids: ${task.subtasks.map((st) => st.id).join(', ')}`);
     }
+    // Add dependencies if they exist. The API returns a single flat `dependencies`
+    // array for both directions; which side of the pair this task sits on decides
+    // whether it is waiting on the other task or blocking it.
+    if (task.dependencies && task.dependencies.length > 0) {
+        const waitingOn = task.dependencies
+            .filter((dep) => dep.task_id === task.id)
+            .map((dep) => dep.depends_on);
+        const blocking = task.dependencies
+            .filter((dep) => dep.depends_on === task.id)
+            .map((dep) => dep.task_id);
+        if (waitingOn.length > 0) {
+            metadataLines.push(`waiting_on: ${waitingOn.join(', ')}`);
+        }
+        if (blocking.length > 0) {
+            metadataLines.push(`blocking: ${blocking.join(', ')}`);
+        }
+    }
+    // Add linked (related, non-blocking) tasks if they exist
+    if (task.linked_tasks && task.linked_tasks.length > 0) {
+        const linked = task.linked_tasks
+            .map((link) => (link.task_id === task.id ? link.link_id : link.task_id))
+            .filter((id) => id);
+        if (linked.length > 0) {
+            metadataLines.push(`linked_tasks: ${linked.join(', ')}`);
+        }
+    }
     // Add archived status if true
     if (task.archived) {
         metadataLines.push(`archived: true`);

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

@@ -1 +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;AA+IpE,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,SAAS,EAAE,QAAQ,EAAE,GAAG,QAumBtE"}
+{"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;AAsJpE,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,SAAS,EAAE,QAAQ,EAAE,GAAG,QAooBtE"}

package/dist/tools/task-write-tools.js

@@ -6,6 +6,7 @@ const config_1 = require("../shared/config");
 const utils_1 = require("../shared/utils");
 const clickup_text_1 = require("../clickup-text");
 const attachments_1 = require("../shared/attachments");
+const comments_1 = require("../shared/comments");
 /**
  * Shared wording for the image support of every markdown field in this file.
  * Kept in one place so the tools stay consistent about what a client may pass.
@@ -105,7 +106,7 @@ const taskTagsSchema = zod_1.z.array(zod_1.z.string()).optional().describe("Opti
 function registerTaskToolsWrite(server, userData) {
     server.tool("addComment", (() => {
         const descriptionBase = [
-            "Adds a comment to a specific task.",
+            "Adds a comment to a specific task, or a threaded reply to an existing comment when `parent_comment_id` is set.",
             "LINKING BEST PRACTICES:",
             "- Always reference related tasks using ClickUp URLs (https://app.clickup.com/t/TASK_ID)",
             "- Task URLs become live task references (chip with task name and status), so write them bare - any custom link text on a task URL is replaced by the live task name",
@@ -123,14 +124,28 @@ function registerTaskToolsWrite(server, userData) {
         }
         return descriptionBase.join("\n");
     })(), {
-        task_id: zod_1.z.string().min(6).max(9).describe("The 6-9 character task ID to comment on"),
+        task_id: zod_1.z.string().min(6).max(16).describe("The 6-16 character task ID to comment on"),
         comment: zod_1.z.string().min(1).describe("The comment text to add to the task"),
+        parent_comment_id: zod_1.z.string().min(1).optional().describe("Optional: reply inside an existing comment thread instead of posting a new top-level comment. Pass the comment_id of a TOP-LEVEL comment as returned by getTaskById or addComment - ClickUp threads are one level deep, so a reply cannot have replies of its own."),
     }, {
         readOnlyHint: false,
         destructiveHint: false,
         idempotentHint: false,
-    }, async ({ task_id, comment }) => {
+    }, async ({ task_id, comment, parent_comment_id }) => {
         try {
+            // The reply endpoint anchors the reply to the parent comment's task and
+            // ignores task_id, while images below are uploaded to task_id - so the
+            // parent must verifiably be a top-level comment of THIS task before
+            // anything is written. This also rejects reply ids (nested replies are
+            // not supported by ClickUp's one-level threads).
+            if (parent_comment_id) {
+                const parent = await (0, comments_1.findTopLevelComment)(task_id, parent_comment_id);
+                if (!parent) {
+                    throw new Error(`Comment ${parent_comment_id} is not a top-level comment of task ${task_id}, so no reply was posted. ` +
+                        `parent_comment_id must be the comment_id of a top-level comment of this task as returned by getTaskById - ` +
+                        `a reply's id or a comment of another task cannot be used.`);
+                }
+            }
             // Resolve and upload referenced images first - the fragments need the
             // attachment objects from the upload response, a bare URL renders as an
             // empty tile. Any image problem aborts BEFORE the comment is posted, so
@@ -144,7 +159,12 @@ function registerTaskToolsWrite(server, userData) {
                 comment: commentBlocks,
                 notify_all: true
             };
-            const response = await fetch(`https://api.clickup.com/api/v2/task/${task_id}/comment`, {
+            // A threaded reply goes to the parent comment's reply endpoint; the body
+            // is identical to a top-level comment.
+            const url = parent_comment_id
+                ? `https://api.clickup.com/api/v2/comment/${parent_comment_id}/reply`
+                : `https://api.clickup.com/api/v2/task/${task_id}/comment`;
+            const response = await fetch(url, {
                 method: 'POST',
                 headers: {
                     Authorization: config_1.CONFIG.apiKey,
@@ -162,8 +182,12 @@ function registerTaskToolsWrite(server, userData) {
                     {
                         type: "text",
                         text: [
-                            `Comment added successfully!`,
+                            parent_comment_id ? `Reply added successfully!` : `Comment added successfully!`,
                             `comment_id: ${commentData.id || 'N/A'}`,
+                            ...(parent_comment_id ? [
+                                `parent_comment_id: ${parent_comment_id}`,
+                                `note: ClickUp threads are one level deep - a reply's comment_id cannot be used as parent_comment_id or with editComment.`,
+                            ] : []),
                             `task_id: ${task_id}`,
                             `comment: ${summarizeMarkdownForEcho(comment)}`,
                             `date: ${timestampToIso(commentData.date || Date.now())}`,
@@ -203,8 +227,8 @@ function registerTaskToolsWrite(server, userData) {
         }
         return descriptionBase.join("\n");
     })(), {
-        task_id: zod_1.z.string().min(6).max(9).describe("The 6-9 character ID of the task the comment belongs to - needed to locate the comment and to upload images"),
-        comment_id: zod_1.z.string().min(1).describe("The ID of the comment to edit, as returned by addComment or getTaskById"),
+        task_id: zod_1.z.string().min(6).max(16).describe("The 6-16 character ID of the task the comment belongs to - needed to locate the comment and to upload images"),
+        comment_id: zod_1.z.string().min(1).describe("The ID of the comment to edit, as returned by addComment or getTaskById. Only top-level comments can be edited - replies inside a thread cannot."),
         comment: zod_1.z.string().min(1).describe("The new comment text, replacing the previous text completely"),
     }, {
         readOnlyHint: false,
@@ -287,7 +311,7 @@ function registerTaskToolsWrite(server, userData) {
         }
         return descriptionBase.join("\n");
     })(), {
-        task_id: zod_1.z.string().min(6).max(9).describe("The 6-9 character task ID to update"),
+        task_id: zod_1.z.string().min(6).max(16).describe("The 6-16 character task ID to update"),
         name: taskNameSchema.optional(),
         append_description: zod_1.z.string().optional().describe("Optional markdown content to APPEND to existing task description (preserves existing content for safety)"),
         status: zod_1.z.string().optional().describe("Optional new status name - use getListInfo to see valid options"),
@@ -636,26 +660,6 @@ function formatTimeEstimate(hours) {
     const displayMinutes = Math.round((hours - displayHours) * 60);
     return displayHours > 0 ? `${displayHours}h ${displayMinutes}m` : `${displayMinutes}m`;
 }
-/**
- * Never page further back than this. A generous edit window would otherwise walk
- * the entire comment history of a busy ticket and eat the 100 calls/minute budget.
- */
-const MAX_COMMENT_PAGES = 10;
-/** One page of task comments, newest first, 25 per page */
-async function fetchCommentPage(taskId, cursor) {
-    // Note there is no `start_date` parameter - passing one is silently ignored.
-    // Older pages are reached with `start` + `start_id` of the previous page's last entry.
-    const query = cursor
-        ? `?${new URLSearchParams({ start: cursor.start, start_id: cursor.startId })}`
-        : "";
-    const response = await fetch(`https://api.clickup.com/api/v2/task/${taskId}/comment${query}`, { headers: { Authorization: config_1.CONFIG.apiKey } });
-    if (!response.ok) {
-        const errorData = await response.json().catch(() => ({}));
-        throw new Error(`Error loading comments of task ${taskId}: ${response.status} ${response.statusText} - ${JSON.stringify(errorData)}`);
-    }
-    const data = await response.json();
-    return Array.isArray(data.comments) ? data.comments : [];
-}
 /**
  * Load a single comment of a task.
  *
@@ -677,8 +681,8 @@ async function findTaskComment(taskId, commentId) {
     let checked = 0;
     let pages = 0;
     let sawThreadedReplies = false;
-    while (pages < MAX_COMMENT_PAGES) {
-        const page = await fetchCommentPage(taskId, cursor);
+    while (pages < comments_1.MAX_COMMENT_PAGES) {
+        const page = await (0, comments_1.fetchCommentPage)(taskId, cursor);
         pages++;
         if (page.length === 0) {
             break;
@@ -780,7 +784,16 @@ async function updateTaskDependencies(taskId, taskData, dependencies) {
     // Get current dependencies
     const currentBlocking = taskData.blocking?.map((dep) => dep.id) || [];
     const currentWaitingOn = taskData.waiting_on?.map((dep) => dep.id) || [];
-    const currentLinked = taskData.linked_tasks?.map((task) => task.id) || [];
+    // `linked_tasks` entries are link records, not tasks: each has `task_id` and
+    // `link_id` (the two ends of the link) and no `id` at all. Mapping `.id` here
+    // produced `[undefined, ...]`, so every existing link looked like it was no
+    // longer requested, and the removal loop then issued
+    // `DELETE /task/{id}/link/undefined`, which the API rejects. The result was a
+    // `linked_tasks` field documented as "replace" that could never remove
+    // anything. Take whichever end of the record is not the task being updated.
+    const currentLinked = taskData.linked_tasks
+        ?.map((link) => (link.task_id === taskData.id ? link.link_id : link.task_id))
+        .filter((id) => Boolean(id)) || [];
     // Helper function to make dependency API calls
     async function modifyDependency(operation, type, fromTaskId, toTaskId, dependsOn) {
         try {

package/dist/tools/time-tools.js

@@ -52,7 +52,7 @@ function formatEntryTime(timestamp) {
 }
 function registerTimeToolsRead(server) {
     server.tool("getTimeEntries", "Gets time entries for a specific task or all user's time entries. Returns last 30 days by default if no dates specified.", {
-        task_id: zod_1.z.string().min(6).max(9).optional().describe("Optional 6-9 character task ID to filter entries. If not provided, returns all user's time entries."),
+        task_id: zod_1.z.string().min(6).max(16).optional().describe("Optional 6-16 character task ID to filter entries. If not provided, returns all user's time entries."),
         start_date: zod_1.z.string().optional().describe("Optional start date filter as ISO date string (e.g., '2024-10-06T00:00:00+02:00'). Defaults to 30 days ago."),
         end_date: zod_1.z.string().optional().describe("Optional end date filter as ISO date string (e.g., '2024-10-06T23:59:59+02:00'). Defaults to current date."),
         list_id: zod_1.z.string().optional().describe("Optional single list ID to filter time entries by a specific list"),
@@ -267,7 +267,7 @@ function registerTimeToolsWrite(server) {
         "IMPORTANT: Before booking time, check the task's status - booking time on tasks in 'backlog', 'closed', or similar inactive states usually doesn't make sense.",
         "Suggest moving the task to an active status like 'in progress' first."
     ].join("\n"), {
-        task_id: zod_1.z.string().min(6).max(9).describe("The 6-9 character task ID to book time against"),
+        task_id: zod_1.z.string().min(6).max(16).describe("The 6-16 character task ID to book time against"),
         hours: zod_1.z.number().min(0.01).max(24).describe("Hours to book (decimal format, e.g., 0.25 = 15min, 1.5 = 1h 30min)"),
         description: zod_1.z.string().optional().describe("Optional description for the time entry"),
         start_time: zod_1.z.string().optional().describe("Optional start time as ISO date string (e.g., '2024-10-06T09:00:00+02:00', defaults to current time)")

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hauptsache.net/clickup-mcp",
-  "version": "1.7.2",
+  "version": "1.8.0",
   "description": "Search, create, and retrieve tasks, add comments, and track time through natural language commands.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",