@krodak/clickup-cli 1.24.0 → 1.25.0

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "clickup-cli",
   "description": "ClickUp CLI skills for managing tasks, sprints, comments, checklists, custom fields, tags, and time tracking via the cup command",
-  "version": "1.24.0",
+  "version": "1.25.0",
   "author": {
     "name": "Krzysztof Rodak"
   },

package/dist/index.js

@@ -236,8 +236,8 @@ var ClickUpClient = class {
       body: JSON.stringify(options)
     });
   }
-  async postComment(taskId, commentText, notifyAll) {
-    const body = { comment_text: commentText };
+  async postComment(taskId, commentText, notifyAll, richBlocks) {
+    const body = richBlocks ? { comment: richBlocks } : { comment_text: commentText };
     if (notifyAll) body.notify_all = true;
     return this.request(this.taskPath(taskId, "/comment"), {
       method: "POST",
@@ -492,8 +492,8 @@ var ClickUpClient = class {
       method: "DELETE"
     });
   }
-  async updateComment(commentId, text, resolved) {
-    const body = { comment_text: text };
+  async updateComment(commentId, text, resolved, richBlocks) {
+    const body = richBlocks ? { comment: richBlocks } : { comment_text: text };
     if (resolved !== void 0) body.resolved = resolved;
     await this.request(`/comment/${commentId}`, {
       method: "PUT",
@@ -511,8 +511,8 @@ var ClickUpClient = class {
       "threaded comments"
     );
   }
-  async createThreadedComment(commentId, text, notifyAll) {
-    const body = { comment_text: text };
+  async createThreadedComment(commentId, text, notifyAll, richBlocks) {
+    const body = richBlocks ? { comment: richBlocks } : { comment_text: text };
     if (notifyAll) body.notify_all = true;
     await this.request(`/comment/${commentId}/reply`, {
       method: "POST",
@@ -2575,11 +2575,182 @@ async function fetchSubtasks(config, taskId, options = {}) {
   return tasks.map((t) => summarize(t, typeMap));
 }
 
+// src/commands/comment-format.ts
+var HEADER_RE = /^(#{1,6})\s+(.+)$/;
+var BULLET_RE = /^[-*]\s+(.+)$/;
+var ORDERED_RE = /^\d+\.\s+(.+)$/;
+var BLOCKQUOTE_RE = /^>\s+(.+)$/;
+var HR_RE = /^(---+|\*\*\*+|___+)\s*$/;
+var FENCED_OPEN_RE = /^```(\w*)$/;
+var FENCED_CLOSE_RE = /^```\s*$/;
+function processInlineFormatting(text, lineAttrs) {
+  const blocks = [];
+  let remaining = text;
+  while (remaining.length > 0) {
+    let earliestIndex = remaining.length;
+    let matchType = "";
+    let matchResult = null;
+    const patterns = [
+      { type: "code", re: /`([^`]+)`/ },
+      { type: "bolditalic", re: /\*{3}([^*]+)\*{3}/ },
+      { type: "bold", re: /\*{2}([^*]+)\*{2}/ },
+      { type: "italic", re: /(?<!\*)\*(?!\*)([^*]+)(?<!\*)\*(?!\*)/ },
+      { type: "strike", re: /~~([^~]+)~~/ },
+      { type: "link", re: /\[([^\]]+)\]\(([^)]+)\)/ }
+    ];
+    for (const { type, re } of patterns) {
+      const m = re.exec(remaining);
+      if (m && m.index < earliestIndex) {
+        earliestIndex = m.index;
+        matchType = type;
+        matchResult = m;
+      }
+    }
+    if (!matchResult) {
+      if (remaining.length > 0) {
+        blocks.push({
+          text: remaining,
+          ...Object.keys(lineAttrs).length > 0 ? { attributes: { ...lineAttrs } } : {}
+        });
+      }
+      break;
+    }
+    if (earliestIndex > 0) {
+      blocks.push({
+        text: remaining.slice(0, earliestIndex),
+        ...Object.keys(lineAttrs).length > 0 ? { attributes: { ...lineAttrs } } : {}
+      });
+    }
+    const innerText = matchResult[1];
+    switch (matchType) {
+      case "code":
+        blocks.push({ text: innerText, attributes: { ...lineAttrs, code: true } });
+        break;
+      case "bolditalic":
+        blocks.push({ text: innerText, attributes: { ...lineAttrs, bold: true, italic: true } });
+        break;
+      case "bold":
+        blocks.push({ text: innerText, attributes: { ...lineAttrs, bold: true } });
+        break;
+      case "italic":
+        blocks.push({ text: innerText, attributes: { ...lineAttrs, italic: true } });
+        break;
+      case "strike":
+        blocks.push({ text: innerText, attributes: { ...lineAttrs, strike: true } });
+        break;
+      case "link":
+        blocks.push({
+          text: innerText,
+          attributes: { ...lineAttrs, link: matchResult[2] }
+        });
+        break;
+    }
+    remaining = remaining.slice(earliestIndex + matchResult[0].length);
+  }
+  return blocks;
+}
+function markdownToCommentBlocks(markdown) {
+  if (!markdown) return [{ text: "" }];
+  const lines = markdown.split("\n");
+  const blocks = [];
+  let inCodeBlock = false;
+  let codeBlockLang = "";
+  let codeBlockContent = "";
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (inCodeBlock) {
+      if (FENCED_CLOSE_RE.test(line)) {
+        const lang = codeBlockLang || true;
+        blocks.push({
+          text: codeBlockContent,
+          attributes: { "code-block": lang }
+        });
+        inCodeBlock = false;
+        codeBlockLang = "";
+        codeBlockContent = "";
+      } else {
+        codeBlockContent += (codeBlockContent.length > 0 ? "\n" : "") + line;
+      }
+      continue;
+    }
+    const fencedOpen = FENCED_OPEN_RE.exec(line);
+    if (fencedOpen) {
+      inCodeBlock = true;
+      codeBlockLang = fencedOpen[1] ?? "";
+      codeBlockContent = "";
+      continue;
+    }
+    if (HR_RE.test(line)) {
+      blocks.push({ text: "\n", attributes: { divider: true } });
+      continue;
+    }
+    const headerMatch = HEADER_RE.exec(line);
+    if (headerMatch) {
+      const level = headerMatch[1].length;
+      const content = headerMatch[2];
+      const inlineBlocks2 = processInlineFormatting(content, {});
+      for (const b of inlineBlocks2) {
+        blocks.push(b);
+      }
+      blocks.push({ text: "\n", attributes: { header: level } });
+      continue;
+    }
+    const bulletMatch = BULLET_RE.exec(line);
+    if (bulletMatch) {
+      const content = bulletMatch[1];
+      const inlineBlocks2 = processInlineFormatting(content, {});
+      for (const b of inlineBlocks2) {
+        blocks.push(b);
+      }
+      blocks.push({ text: "\n", attributes: { list: "bullet" } });
+      continue;
+    }
+    const orderedMatch = ORDERED_RE.exec(line);
+    if (orderedMatch) {
+      const content = orderedMatch[1];
+      const inlineBlocks2 = processInlineFormatting(content, {});
+      for (const b of inlineBlocks2) {
+        blocks.push(b);
+      }
+      blocks.push({ text: "\n", attributes: { list: "ordered" } });
+      continue;
+    }
+    const blockquoteMatch = BLOCKQUOTE_RE.exec(line);
+    if (blockquoteMatch) {
+      const content = blockquoteMatch[1];
+      const inlineBlocks2 = processInlineFormatting(content, {});
+      for (const b of inlineBlocks2) {
+        blocks.push(b);
+      }
+      blocks.push({ text: "\n", attributes: { blockquote: true } });
+      continue;
+    }
+    if (line === "") {
+      blocks.push({ text: "\n" });
+      continue;
+    }
+    const inlineBlocks = processInlineFormatting(line, {});
+    for (const b of inlineBlocks) {
+      blocks.push(b);
+    }
+    blocks.push({ text: "\n" });
+  }
+  if (inCodeBlock && codeBlockContent.length > 0) {
+    const lang = codeBlockLang || true;
+    blocks.push({
+      text: codeBlockContent,
+      attributes: { "code-block": lang }
+    });
+  }
+  return blocks;
+}
+
 // src/commands/comment.ts
 async function postComment(config, taskId, text, notifyAll) {
   if (!text.trim()) throw new Error("Comment text cannot be empty");
   const client = new ClickUpClient(config);
-  return client.postComment(taskId, text, notifyAll);
+  const blocks = markdownToCommentBlocks(text);
+  return client.postComment(taskId, text, notifyAll, blocks);
 }
 
 // src/commands/comments.ts
@@ -5717,7 +5888,8 @@ async function editComment(config, commentId, text, resolved) {
   }
   if (text !== void 0 && !text.trim()) throw new Error("Comment text cannot be empty");
   const client = new ClickUpClient(config);
-  await client.updateComment(commentId, text ?? "", resolved);
+  const blocks = text !== void 0 ? markdownToCommentBlocks(text) : void 0;
+  await client.updateComment(commentId, text ?? "", resolved, blocks);
 }
 
 // src/commands/comment-delete.ts
@@ -5760,7 +5932,8 @@ async function getReplies(config, commentId) {
 async function createReply(config, commentId, text, notifyAll) {
   if (!text.trim()) throw new Error("Reply text cannot be empty");
   const client = new ClickUpClient(config);
-  await client.createThreadedComment(commentId, text, notifyAll);
+  const blocks = markdownToCommentBlocks(text);
+  await client.createThreadedComment(commentId, text, notifyAll, blocks);
 }
 function formatReplies(replies) {
   if (replies.length === 0) return "No replies";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@krodak/clickup-cli",
-  "version": "1.24.0",
+  "version": "1.25.0",
   "description": "ClickUp CLI for AI agents and humans",
   "type": "module",
   "license": "MIT",

package/skills/clickup-cli/SKILL.md

@@ -3,11 +3,11 @@ name: clickup
 description: 'Use when managing ClickUp tasks, sprints, or comments via the `cup` CLI tool. Triggers: task queries, status updates, sprint tracking, creating subtasks, posting comments, threaded replies, standup summaries, searching tasks, checking overdue items, assigning tasks, listing spaces and lists, opening tasks in browser, checking auth or config, setting custom fields, deleting tasks, managing tags, managing checklists, editing comments, task links, time tracking, attachments, file uploads, listing members, listing fields, duplicating tasks, bulk operations, goals, key results, saved filters, favorites.'
 ---
 
-# ClickUp CLI (`cup`) - skill version 1.24.0
+# ClickUp CLI (`cup`) - skill version 1.25.0
 
 Reference for AI agents using the `cup` CLI tool. Covers task management, sprint tracking, comments, time tracking, custom fields, goals, docs, and project workflows.
 
-> **Version check:** Run `cup --version`. If your installed version is older than 1.24.0, update with `npm install -g @krodak/clickup-cli` and refresh this skill with `cup skill`.
+> **Version check:** Run `cup --version`. If your installed version is older than 1.25.0, update with `npm install -g @krodak/clickup-cli` and refresh this skill with `cup skill`.
 
 ## Install & Configure
 
@@ -148,11 +148,11 @@ All commands support `--help` for full flag details. All commands support `--jso
 | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------ |
 | `cup create -n name [-l listId\|sprint:current] [-p parentId] [-d desc] [-s status] [--priority p] [--due-date d] [--start-date d] [--time-estimate t] [--assignee id\|me] [--tags t] [--custom-item-id n] [--template id] [--field "Name" val]`                | Create task (`--list` accepts `sprint:current`, `--field` sets custom fields inline) |
 | `cup update <id> [-n name] [-d desc] [-s status] [--priority p] [--due-date d\|none] [--start-date d] [--time-estimate t] [--assignee id\|me] [--remove-assignee id\|me] [--parent id] [--detach] [--archive] [--unarchive] [--type type] [--field "Name" val]` | Update task fields (including custom fields)                                         |
-| `cup comment <id> -m text [--notify-all]`                                                                                                                                                                                                                       | Post comment on task                                                                 |
-| `cup comment-edit <commentId> -m text [--resolved] [--unresolved]`                                                                                                                                                                                              | Edit a comment                                                                       |
+| `cup comment <id> -m text [--notify-all]`                                                                                                                                                                                                                       | Post comment (markdown auto-converted to rich text)                                  |
+| `cup comment-edit <commentId> -m text [--resolved] [--unresolved]`                                                                                                                                                                                              | Edit a comment (markdown auto-converted to rich text)                                |
 | `cup comment-delete <commentId>` or `cup comment-delete --task <taskId> --mine [--match text]`                                                                                                                                                                  | Delete a comment by ID or delete one of your task comments                           |
 | `cup replies <commentId>`                                                                                                                                                                                                                                       | List threaded replies                                                                |
-| `cup reply <commentId> -m text [--notify-all]`                                                                                                                                                                                                                  | Reply to a comment                                                                   |
+| `cup reply <commentId> -m text [--notify-all]`                                                                                                                                                                                                                  | Reply to a comment (markdown auto-converted to rich text)                            |
 | `cup assign <id> [--to ids\|me] [--remove ids\|me]`                                                                                                                                                                                                             | Assign/unassign users (`--to`/`--remove` accept comma-separated IDs)                 |
 | `cup depend <id> [--on taskId] [--blocks taskId] [--remove]`                                                                                                                                                                                                    | Add/remove dependencies                                                              |
 | `cup move <id> [--to listId\|sprint:current] [--remove listId]`                                                                                                                                                                                                 | Add/remove task from lists (`--to` accepts `sprint:current`)                         |
@@ -296,6 +296,7 @@ cup create -n "Bug fix" -l sprint:current         # create in active sprint
 cup create -n "Q3 Roadmap" -l <listId> --custom-item-id 1
 cup create -n "New story" -l <listId> --field "Story Points" 5 --field "Stage" "In Review"
 cup comment abc123def -m "Completed in PR #42"
+cup comment abc123def -m "## Results\n\n**Passed**: 15/15\n- Unit tests\n- Integration"
 cup assign abc123def --to me
 cup assign abc123def --to 12345,67890        # assign multiple users at once
 cup depend task3 --on task2            # task3 waits for task2