@sebastienheyd/clickup-mcp 1.9.0 → 1.10.1

package/README.md

@@ -4,6 +4,24 @@
 
 Model Context Protocol (MCP) server enabling AI assistants to interact with ClickUp workspaces. Get complete task context with comments and images, search across projects, create and update tasks, collaborate through comments, and track time - all through natural language.
 
+## Differences From the Upstream Project
+
+This fork is published as [`@sebastienheyd/clickup-mcp`](https://www.npmjs.com/package/@sebastienheyd/clickup-mcp) and follows its own version numbers. Upstream history is merged (last sync: upstream 1.9.0, September 2026), so the two projects share their core; the fork keeps its own additions on top.
+
+| Area | Only in this fork |
+|------|-------------------|
+| Task IDs | Custom task IDs (e.g. `SOI-4422`) accepted wherever a `task_id` is expected, time tools included |
+| `searchTasks` | `include_closed` and `archived` filters |
+| `searchSpaces` | `folder_id` to resolve a single folder with its lists and statuses |
+| `createTask` / `updateTask` | Sprint `points`; `remove_assignees`; `null` clears `due_date`, `start_date`, `time_estimate` and `points` |
+| Descriptions | `description` (full replacement) on `updateListInfo` too, and both tools echo the previous description |
+| Comments | `deleteComment` (same guardrails as `editComment`) |
+| Time tracking | `updateTimeEntry` and `deleteTimeEntry`; `getTimeEntries` shows each `entry_id` |
+| Tooling | `Makefile` with the common commands; `npm run cli` understands `key=null` |
+| Runtime | Node.js 20 or newer (upstream: 16) |
+
+See [CHANGELOG.md](CHANGELOG.md) for this fork's history and the [upstream changelog](https://github.com/hauptsacheNet/clickup-mcp/blob/main/CHANGELOG.md) for theirs.
+
 ## This MCP vs Official ClickUp MCP
 
 > See also: [Official ClickUp MCP Documentation](https://developer.clickup.com/docs/connect-an-ai-assistant-to-clickups-mcp-server)
@@ -99,7 +117,7 @@ Turn natural language into powerful ClickUp actions:
 - Handle time estimates, sprint points and custom field values
 
 ### 🔒 **Safety Features**
-- **Append-First Descriptions**: `append_description` adds a dated block under the existing description and is the default for notes. `replace_description` rewrites the whole description on purpose - the previous content is echoed back so a wrong replacement can be undone
+- **Append-First Descriptions**: `append_description` adds a dated block under the existing description and is the default for notes. `description` rewrites the whole description on purpose - the previous content is echoed back so a wrong replacement can be undone
 - **Normal Field Updates**: Status, priority, assignees, tags, and dates can be updated normally (easily revertible through ClickUp's history)
 
 ## Installation
@@ -291,7 +309,7 @@ By default (`append_description`), content is appended under the existing descri
 - Performance requirement: < 2s load time
 ```
 
-This keeps existing content and a clear audit trail. To correct or restructure a description, `replace_description` rewrites it entirely; the tool answers with the previous description so nothing is silently lost. The same two parameters exist on `updateListInfo`.
+This keeps existing content and a clear audit trail. To correct or restructure a description, `description` rewrites it entirely; the tool answers with the previous description so nothing is silently lost. The same two parameters exist on `updateListInfo`.
 
 ## Writing Images Into Tickets
 

package/dist/clickup-text.d.ts

@@ -57,6 +57,7 @@ export interface ClickUpCommentBlock {
     attributes?: {
         bold?: boolean;
         italic?: boolean;
+        strike?: boolean;
         code?: boolean;
         link?: string;
         'code-block'?: {

package/dist/clickup-text.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"clickup-text.d.ts","sourceRoot":"","sources":["../src/clickup-text.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"clickup-text.d.ts","sourceRoot":"","sources":["../src/clickup-text.ts"],"names":[],"mappings":"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"}

package/dist/clickup-text.js

@@ -62,11 +62,24 @@ async function convertClickUpTextItemsToToolCallResult(textItems) {
     // Track current formatting state to avoid unnecessary close/reopen
     let activeBold = false;
     let activeItalic = false;
+    let activeStrike = false;
     let activeCode = false;
+    // ClickUp emits one '\n' fragment with a code-block attribute per code LINE;
+    // consecutive ones belong to the same fenced block when read back as markdown.
+    let inCodeBlock = false;
+    let currentFenceLang = '';
+    const closeCodeFence = () => {
+        if (inCodeBlock) {
+            currentTextBlock += '```\n';
+            inCodeBlock = false;
+            currentFenceLang = '';
+        }
+    };
     for (let i = 0; i < textItems.length; i++) {
         const item = textItems[i];
         // Handle image items
         if (item.type === "image" && item.image && item.image.url) {
+            closeCodeFence();
             const imageFileName = item.image.name || item.image.title || "image";
             const imageUrl = item.image.url;
             const altText = item.text || imageFileName;
@@ -133,6 +146,27 @@ async function convertClickUpTextItemsToToolCallResult(textItems) {
         else if (typeof item.text === "string") {
             // Check if this is a newline with block formatting (header, blockquote, list)
             if (item.text === '\n' && item.attributes) {
+                // Code block formatting: append this line to the open fence (or open one).
+                // The attribute value carries the language, either directly or nested as
+                // {'code-block': lang}; 'plain' means no language.
+                if (item.attributes['code-block']) {
+                    const rawLang = item.attributes['code-block'];
+                    const lang = typeof rawLang === 'string' ? rawLang : rawLang?.['code-block'] ?? '';
+                    const fenceLang = lang === 'plain' ? '' : lang;
+                    if (inCodeBlock && fenceLang !== currentFenceLang) {
+                        closeCodeFence();
+                    }
+                    if (!inCodeBlock) {
+                        currentTextBlock += '```' + fenceLang + '\n';
+                        inCodeBlock = true;
+                        currentFenceLang = fenceLang;
+                    }
+                    currentTextBlock += currentLine + '\n';
+                    currentLine = "";
+                    continue;
+                }
+                // Any other line terminator ends a code block
+                closeCodeFence();
                 // Header formatting
                 if (item.attributes.header) {
                     const level = item.attributes.header;
@@ -163,17 +197,8 @@ async function convertClickUpTextItemsToToolCallResult(textItems) {
                             break;
                     }
                 }
-                // Code block formatting
-                else if (item.attributes['code-block']) {
-                    // Wrap the current line in code block markers
-                    currentLine = '```\n' + currentLine + '\n```';
-                }
                 // Add formatted line to text block
-                currentTextBlock += currentLine;
-                // Add newline unless it's code block (already has newlines)
-                if (!item.attributes['code-block']) {
-                    currentTextBlock += '\n';
-                }
+                currentTextBlock += currentLine + '\n';
                 currentLine = ""; // Reset for next line
                 continue;
             }
@@ -182,15 +207,18 @@ async function convertClickUpTextItemsToToolCallResult(textItems) {
             // Determine current and next formatting state
             const hasBold = item.attributes?.bold === true;
             const hasItalic = item.attributes?.italic === true;
+            const hasStrike = item.attributes?.strike === true;
             const hasLink = item.attributes?.link;
             // Look ahead to next non-newline block
             let nextHasBold = false;
             let nextHasItalic = false;
+            let nextHasStrike = false;
             for (let j = i + 1; j < textItems.length; j++) {
                 const nextItem = textItems[j];
                 if (nextItem.text !== '\n' || !nextItem.attributes) {
                     nextHasBold = nextItem.attributes?.bold === true;
                     nextHasItalic = nextItem.attributes?.italic === true;
+                    nextHasStrike = nextItem.attributes?.strike === true;
                     break;
                 }
             }
@@ -200,14 +228,20 @@ async function convertClickUpTextItemsToToolCallResult(textItems) {
                 prefix += "**";
             if (hasItalic && !activeItalic)
                 prefix += "*";
+            if (hasStrike && !activeStrike)
+                prefix += "~~";
             // Build suffix (close formatting that won't continue)
             let suffix = "";
+            if (hasStrike && !nextHasStrike)
+                suffix += "~~";
             if (hasItalic && !nextHasItalic)
                 suffix += "*";
             if (hasBold && !nextHasBold)
                 suffix += "**";
             // Close formatting that's active but not in this block
             let closingPrefix = "";
+            if (activeStrike && !hasStrike)
+                closingPrefix += "~~";
             if (activeBold && !hasBold)
                 closingPrefix += "**";
             if (activeItalic && !hasItalic)
@@ -216,6 +250,7 @@ async function convertClickUpTextItemsToToolCallResult(textItems) {
             // Update state
             activeBold = hasBold && nextHasBold;
             activeItalic = hasItalic && nextHasItalic;
+            activeStrike = hasStrike && nextHasStrike;
             // Link formatting (wraps everything)
             if (hasLink) {
                 formattedText = `[${formattedText}](${hasLink})`;
@@ -227,6 +262,7 @@ async function convertClickUpTextItemsToToolCallResult(textItems) {
             // Add to current line (not text block yet)
             if (item.text === '\n') {
                 // Plain newline without formatting
+                closeCodeFence();
                 currentTextBlock += currentLine + '\n';
                 currentLine = "";
             }
@@ -245,6 +281,7 @@ async function convertClickUpTextItemsToToolCallResult(textItems) {
         }
     }
     // Add any remaining text
+    closeCodeFence();
     if (currentLine) {
         currentTextBlock += currentLine;
     }
@@ -439,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.
  */
@@ -558,6 +595,14 @@ function walkMdastNodes(nodes, inheritedAttrs, blocks, depth = 0, attachmentsByS
     for (let i = 0; i < nodes.length; i++) {
         const node = nodes[i];
         const currentAttrs = { ...inheritedAttrs };
+        // ClickUp has no paragraph margins: two paragraphs separated by a single '\n'
+        // render as consecutive lines. The UI stores a paragraph break as an extra
+        // empty '\n' fragment (what a user gets by pressing Enter twice), so emit one
+        // between adjacent flow blocks. Headings, code blocks and blockquotes bring
+        // their own spacing - a blank line next to them would double the gap.
+        if (i > 0 && needsBlankLineBetween(nodes[i - 1], node)) {
+            blocks.push({ text: '\n', attributes: {} });
+        }
         switch (node.type) {
             case 'heading':
                 // Process heading content with inline formatting
@@ -621,42 +666,139 @@ function walkMdastNodes(nodes, inheritedAttrs, blocks, depth = 0, attachmentsByS
                 // Code block
                 const codeNode = node;
                 if (codeNode.value) {
-                    blocks.push({ text: codeNode.value, attributes: {} });
-                    blocks.push({
-                        text: '\n',
-                        attributes: { 'code-block': { 'code-block': codeNode.lang || 'plain' } }
-                    });
+                    pushCodeBlockLines(blocks, codeNode.value, codeNode.lang || 'plain');
                 }
                 break;
             case 'thematicBreak':
                 // Horizontal rule - just add a line break
                 blocks.push({ text: '\n', attributes: {} });
                 break;
+            case 'table': {
+                // ClickUp comments cannot render tables (there is no table fragment in the
+                // comment format - unknown attributes are stored but render as plain text).
+                // Re-render the table as an aligned pipe table inside a code block so the
+                // information survives and stays readable in monospace.
+                const tableText = serializeTableAsAlignedPipes(node);
+                if (tableText) {
+                    pushCodeBlockLines(blocks, tableText, 'plain');
+                }
+                break;
+            }
             default:
                 // For any other block-level nodes, try to process children
                 if ('children' in node && Array.isArray(node.children)) {
                     walkMdastNodes(node.children, currentAttrs, blocks, depth, attachmentsBySrc);
                 }
+                else if ('value' in node && typeof node.value === 'string') {
+                    // Last-resort safety net: never drop text content silently
+                    blocks.push({ text: node.value, attributes: {} });
+                }
                 break;
         }
-        // Keep the blank line the source puts between two blocks: remark drops it, and
-        // ClickUp would otherwise glue paragraphs and lists into one dense block
-        if (hasBlankLineBefore(nodes[i + 1], node)) {
-            blocks.push({ text: '\n', attributes: {} });
+    }
+}
+/**
+ * Block types that render without their own vertical margin in ClickUp comments.
+ * Two of them in a row need an explicit empty line to read as separate blocks.
+ */
+const FLOW_BLOCK_TYPES = new Set(['paragraph', 'list']);
+/**
+ * Block types emitted as code-block lines (tables are rendered inside a code block).
+ * Quill fuses consecutive code-block lines into ONE block whatever the source looked
+ * like, so two of them in a row need an empty line in between - otherwise a command
+ * and its output, or a code block and a table, collapse into a single block, and the
+ * read side (which groups consecutive code-block lines into one fence) can no longer
+ * tell them apart.
+ */
+const CODE_BLOCK_TYPES = new Set(['code', 'table']);
+function needsBlankLineBetween(prev, next) {
+    if (FLOW_BLOCK_TYPES.has(prev.type) && FLOW_BLOCK_TYPES.has(next.type)) {
+        return true;
+    }
+    return CODE_BLOCK_TYPES.has(prev.type) && CODE_BLOCK_TYPES.has(next.type);
+}
+/**
+ * Emit a (possibly multi-line) code block the way ClickUp's Quill-based format
+ * expects it: block attributes apply per line, so EVERY line needs its own '\n'
+ * fragment carrying the code-block attribute. A single text fragment with embedded
+ * newlines renders only its last line as code - the rest degrades to plain text.
+ */
+function pushCodeBlockLines(blocks, code, lang) {
+    for (const line of code.split('\n')) {
+        if (line) {
+            blocks.push({ text: line, attributes: {} });
+        }
+        blocks.push({
+            text: '\n',
+            attributes: { 'code-block': { 'code-block': lang } }
+        });
+    }
+}
+/**
+ * Serialize phrasing content back to compact markdown for use inside a code block.
+ * Inline formatting markers are kept so nothing is lost, even though a code block
+ * renders them literally.
+ */
+function serializePhrasingToMarkdown(nodes) {
+    let out = '';
+    for (const node of nodes) {
+        switch (node.type) {
+            case 'text':
+                out += node.value;
+                break;
+            case 'strong':
+                out += `**${serializePhrasingToMarkdown(node.children)}**`;
+                break;
+            case 'emphasis':
+                out += `*${serializePhrasingToMarkdown(node.children)}*`;
+                break;
+            case 'delete':
+                out += `~~${serializePhrasingToMarkdown(node.children)}~~`;
+                break;
+            case 'inlineCode':
+                out += `\`${node.value}\``;
+                break;
+            case 'link':
+                out += `[${serializePhrasingToMarkdown(node.children)}](${node.url})`;
+                break;
+            case 'image':
+                out += node.alt || node.url;
+                break;
+            case 'break':
+                out += ' ';
+                break;
+            default:
+                if ('value' in node && typeof node.value === 'string') {
+                    out += node.value;
+                }
+                else if ('children' in node && Array.isArray(node.children)) {
+                    out += serializePhrasingToMarkdown(node.children);
+                }
+                break;
         }
     }
+    return out;
 }
 /**
- * Whether the source has at least one blank line between `previous` and `next`.
- * Several blank lines count as one, as in rendered markdown.
+ * Render an mdast table as a column-aligned pipe table string.
  */
-function hasBlankLineBefore(next, previous) {
-    const previousEnd = previous.position?.end.line;
-    const nextStart = next?.position?.start.line;
-    if (previousEnd === undefined || nextStart === undefined) {
-        return false;
+function serializeTableAsAlignedPipes(table) {
+    const rows = table.children.map((row) => row.children.map((cell) => serializePhrasingToMarkdown(cell.children).replace(/\|/g, '\\|').trim()));
+    if (rows.length === 0) {
+        return '';
+    }
+    const colCount = Math.max(...rows.map((r) => r.length));
+    const widths = [];
+    for (let col = 0; col < colCount; col++) {
+        widths[col] = Math.max(3, ...rows.map((r) => (r[col] ?? '').length));
     }
-    return nextStart - previousEnd > 1;
+    const renderRow = (cells) => '| ' + widths.map((w, col) => (cells[col] ?? '').padEnd(w)).join(' | ') + ' |';
+    const lines = [renderRow(rows[0])];
+    lines.push('| ' + widths.map((w) => '-'.repeat(w)).join(' | ') + ' |');
+    for (const row of rows.slice(1)) {
+        lines.push(renderRow(row));
+    }
+    return lines.join('\n');
 }
 /**
  * Recursively walk phrasing content (inline nodes) and build ClickUp blocks
@@ -705,6 +847,11 @@ function walkPhrasingContent(nodes, inheritedAttrs, blocks, attachmentsBySrc) {
                 currentAttrs.italic = true;
                 walkPhrasingContent(node.children, currentAttrs, blocks, attachmentsBySrc);
                 break;
+            case 'delete':
+                // GFM strikethrough (~~text~~) - ClickUp renders this via the strike attribute
+                currentAttrs.strike = true;
+                walkPhrasingContent(node.children, currentAttrs, blocks, attachmentsBySrc);
+                break;
             case 'inlineCode':
                 // Inline code
                 if (node.value) {

package/dist/shared/comments.d.ts

@@ -0,0 +1,98 @@
+/** 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;
+/** Page size ClickUp uses for the comment list - a shorter page means the last page. */
+export declare const COMMENTS_PER_PAGE = 25;
+/** One page of task comments, newest first, 25 per page */
+export declare function fetchCommentPage(taskId: string, cursor?: CommentPageCursor): Promise<ExistingComment[]>;
+/** The top-level comments of a task plus whether the history is complete. */
+export interface CommentHistory {
+    /** Top-level comments, newest first */
+    comments: ExistingComment[];
+    /**
+     * Why older comments are missing, or null when the whole list was loaded.
+     * `capped`: the task has more comments than MAX_COMMENT_PAGES pages;
+     * `error`: a page request failed (rate limit, 5xx...) - `comments` holds what was
+     * loaded before the failure, possibly nothing.
+     */
+    incomplete: {
+        reason: "capped" | "error";
+        detail: string;
+    } | null;
+}
+/**
+ * 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. Never throws: a failing page (typically a 429 close to
+ * the API limit on exactly the busy tasks that need paging) keeps the comments
+ * already loaded and is reported through `incomplete`, so the caller can show a
+ * partial history with a warning instead of silently showing none.
+ */
+export declare function fetchAllTopLevelComments(taskId: string): Promise<CommentHistory>;
+/** Result of looking a top-level comment up in a task's comment list. */
+export interface TopLevelCommentLookup {
+    /** The comment, or undefined when it was not found in the searched range */
+    comment: ExistingComment | undefined;
+    /**
+     * true when the whole comment list was searched, so "not found" is definitive;
+     * false when the search stopped at MAX_COMMENT_PAGES with older comments left
+     * unread, so the id may still be a valid but old top-level comment.
+     */
+    exhaustive: boolean;
+}
+/**
+ * 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. `comment` is 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. Callers must check `exhaustive` before
+ * telling the user the id is invalid: past the page cap the answer is only
+ * "not among the newest comments".
+ */
+export declare function findTopLevelComment(taskId: string, commentId: string): Promise<TopLevelCommentLookup>;
+/**
+ * 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;AAEpC,wFAAwF;AACxF,eAAO,MAAM,iBAAiB,KAAK,CAAC;AAEpC,2DAA2D;AAC3D,wBAAsB,gBAAgB,CACpC,MAAM,EAAE,MAAM,EACd,MAAM,CAAC,EAAE,iBAAiB,GACzB,OAAO,CAAC,eAAe,EAAE,CAAC,CAqB5B;AAED,6EAA6E;AAC7E,MAAM,WAAW,cAAc;IAC7B,uCAAuC;IACvC,QAAQ,EAAE,eAAe,EAAE,CAAC;IAC5B;;;;;OAKG;IACH,UAAU,EAAE;QAAE,MAAM,EAAE,QAAQ,GAAG,OAAO,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAC;CACnE;AAED;;;;;;;;;GASG;AACH,wBAAsB,wBAAwB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,CAAC,CAsCtF;AAED,yEAAyE;AACzE,MAAM,WAAW,qBAAqB;IACpC,4EAA4E;IAC5E,OAAO,EAAE,eAAe,GAAG,SAAS,CAAC;IACrC;;;;OAIG;IACH,UAAU,EAAE,OAAO,CAAC;CACrB;AAED;;;;;;;;;GASG;AACH,wBAAsB,mBAAmB,CACvC,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,MAAM,GAChB,OAAO,CAAC,qBAAqB,CAAC,CAiBhC;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,158 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAX_REPLY_FETCHES = exports.COMMENTS_PER_PAGE = 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. */
+exports.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. Never throws: a failing page (typically a 429 close to
+ * the API limit on exactly the busy tasks that need paging) keeps the comments
+ * already loaded and is reported through `incomplete`, so the caller can show a
+ * partial history with a warning instead of silently showing none.
+ */
+async function fetchAllTopLevelComments(taskId) {
+    const comments = [];
+    let cursor;
+    let pages = 0;
+    let lastPageWasFull = false;
+    while (pages < exports.MAX_COMMENT_PAGES) {
+        let page;
+        try {
+            page = await fetchCommentPage(taskId, cursor);
+        }
+        catch (error) {
+            const detail = error instanceof Error ? error.message : String(error);
+            console.error(`Error fetching comments of task ${taskId} (page ${pages + 1}, ${comments.length} loaded so far): ${detail}`);
+            return { comments, incomplete: { reason: "error", detail } };
+        }
+        pages++;
+        if (page.length === 0) {
+            lastPageWasFull = false;
+            break;
+        }
+        comments.push(...page);
+        lastPageWasFull = page.length >= exports.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) {
+        const detail = `the task has more than ${comments.length} top-level comments; loading stops after ${exports.MAX_COMMENT_PAGES} pages to protect the API budget`;
+        console.error(`Task ${taskId}: older comments were not loaded - ${detail}.`);
+        return { comments, incomplete: { reason: "capped", detail } };
+    }
+    return { comments, incomplete: null };
+}
+/**
+ * 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. `comment` is 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. Callers must check `exhaustive` before
+ * telling the user the id is invalid: past the page cap the answer is only
+ * "not among the newest comments".
+ */
+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 { comment: match, exhaustive: true };
+        }
+        if (page.length < exports.COMMENTS_PER_PAGE) {
+            return { comment: undefined, exhaustive: true };
+        }
+        const oldest = page[page.length - 1];
+        cursor = { start: String(oldest.date), startId: String(oldest.id) };
+    }
+    return { comment: undefined, exhaustive: false };
+}
+/**
+ * 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/config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/shared/config.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,cAAc,oBAA2D,CAAC;AAkDvF,MAAM,MAAM,OAAO,GAAG,cAAc,GAAG,MAAM,GAAG,OAAO,CAAC;AA4BxD,eAAO,MAAM,MAAM;;;;;;;;;CAelB,CAAC"}
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/shared/config.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,cAAc,oBAA2D,CAAC;AAkDvF,MAAM,MAAM,OAAO,GAAG,cAAc,GAAG,MAAM,GAAG,OAAO,CAAC;AA8CxD,eAAO,MAAM,MAAM;;;;;;;;;CAqBlB,CAAC"}