@krodak/clickup-cli 1.43.0 → 1.45.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.43.0",
+  "version": "1.45.0",
   "author": {
     "name": "Krzysztof Rodak"
   },

package/README.md

@@ -188,6 +188,7 @@ Full CRUD for the core ClickUp workflow:
 | 🔗 **Webhooks**      | List, create, update, delete webhooks; scope to space, folder, list, or task                                                                                                                                  |
 | 🏢 **Workspace**     | Spaces, folders, lists (full CRUD + rename + from template; subfolder parent IDs in JSON), members, user groups, task types, templates, plan, shared hierarchy                                                |
 | 📎 **Attachments**   | Upload files to tasks, list task attachments, shown in detail views                                                                                                                                           |
+| 📦 **Export**        | Archive tasks and docs as lossless JSON + markdown: by user, space, roadmap list (initiatives grouped), or whole workspace; comment threads, subtask trees, custom fields, attachment binaries                |
 
 [Full API coverage details](docs/api-coverage.md) | [Command reference](docs/commands.md)
 

package/dist/chunk-ISEGUZ6H.js

@@ -0,0 +1,324 @@
+#!/usr/bin/env node
+
+// src/export/writer.ts
+import { createHash } from "crypto";
+import { existsSync } from "fs";
+import { mkdir, readFile, writeFile } from "fs/promises";
+import { join } from "path";
+
+// src/date.ts
+function formatDate(ms) {
+  return new Date(Number(ms)).toLocaleDateString("en-US", {
+    month: "short",
+    day: "numeric",
+    year: "numeric"
+  });
+}
+function formatTimestamp(ms) {
+  return new Date(Number(ms)).toLocaleString("en-US", {
+    month: "short",
+    day: "numeric",
+    hour: "numeric",
+    minute: "2-digit"
+  });
+}
+function formatDuration(ms) {
+  const totalMinutes = Math.round(Math.abs(ms) / 6e4);
+  const hours = Math.floor(totalMinutes / 60);
+  const minutes = totalMinutes % 60;
+  if (hours > 0 && minutes > 0) return `${hours}h ${minutes}m`;
+  if (hours > 0) return `${hours}h`;
+  return `${minutes}m`;
+}
+function formatLongDuration(ms) {
+  const totalMinutes = Math.round(Math.abs(ms) / 6e4);
+  if (totalMinutes === 0) return "< 1m";
+  const days = Math.floor(totalMinutes / 1440);
+  const hours = Math.floor(totalMinutes % 1440 / 60);
+  const minutes = totalMinutes % 60;
+  const parts = [];
+  if (days > 0) parts.push(`${days}d`);
+  if (hours > 0) parts.push(`${hours}h`);
+  if (minutes > 0) parts.push(`${minutes}m`);
+  return parts.join(" ");
+}
+function formatDateISO(ms) {
+  const d = new Date(Number(ms));
+  const year = d.getUTCFullYear();
+  const month = String(d.getUTCMonth() + 1).padStart(2, "0");
+  const day = String(d.getUTCDate()).padStart(2, "0");
+  return `${year}-${month}-${day}`;
+}
+
+// src/export/render.ts
+var TASK_URL = (id) => `https://app.clickup.com/t/${id}`;
+function taskLink(id, name, ctx) {
+  const label = name ?? id;
+  return ctx.hasTask(id) ? `[${label}](../${id}/task.md)` : `[${label}](${TASK_URL(id)}) (not exported)`;
+}
+function isoDateTime(ms) {
+  if (ms == null || ms === "") return void 0;
+  const d = new Date(Number(ms));
+  return Number.isNaN(d.getTime()) ? void 0 : d.toISOString();
+}
+function optionLabel(field, value) {
+  const options = field.type_config?.options ?? [];
+  const hit = options.find((o) => String(o.id) === String(value) || o.orderindex === value);
+  return hit ? hit.name ?? hit.label ?? String(value) : String(value);
+}
+function isEmptyFieldValue(v) {
+  if (v == null || v === "") return true;
+  if (Array.isArray(v) && v.length === 0) return true;
+  return false;
+}
+function renderFieldValue(field, ctx) {
+  const v = field.value;
+  switch (field.type) {
+    case "drop_down":
+      return optionLabel(field, v);
+    case "labels":
+      return (Array.isArray(v) ? v : [v]).map((x) => optionLabel(field, x)).join(", ");
+    case "tasks": {
+      const refs = Array.isArray(v) ? v : [];
+      return refs.map((r) => taskLink(r.id, r.name, ctx)).join(", ");
+    }
+    case "users": {
+      const users = Array.isArray(v) ? v : [];
+      return users.map((u) => u.username ?? u.email ?? "?").join(", ");
+    }
+    case "date":
+      return formatDateISO(v);
+    case "checkbox":
+      return v === true || v === "true" ? "yes" : "no";
+    case "manual_progress":
+      return typeof v === "object" && v !== null && "current" in v ? `${String(v.current)}%` : JSON.stringify(v);
+    default:
+      if (typeof v === "string") return v;
+      if (typeof v === "number" || typeof v === "boolean") return String(v);
+      return JSON.stringify(v);
+  }
+}
+function escapeCell(s) {
+  return s.replace(/\|/g, "\\|").replace(/\r?\n/g, " ");
+}
+function renderTaskMarkdown(bundle, ctx) {
+  const { task, fetchedAt } = bundle;
+  const lines = [`# ${task.name}`, ""];
+  const isInitiative = (task.custom_item_id ?? 0) !== 0;
+  const header = [
+    ["ID", task.id],
+    ["URL", task.url],
+    ["Type", isInitiative ? "initiative" : "task"],
+    ["Status", task.status.status],
+    ["Archived", task.archived ? "yes" : void 0],
+    ["List", task.list.name],
+    ["Folder", task.folder?.name],
+    ["Space", task.space?.id ? ctx.spaceName?.(task.space.id) ?? task.space.id : void 0],
+    ["Parent", task.parent ? taskLink(task.parent, void 0, ctx) : void 0],
+    ["Assignees", task.assignees.map((a) => a.username).join(", ") || void 0],
+    ["Creator", task.creator?.username],
+    ["Watchers", task.watchers?.map((w) => w.username).join(", ") || void 0],
+    ["Priority", task.priority?.priority],
+    ["Tags", task.tags?.map((t) => t.name).join(", ") || void 0],
+    ["Start Date", task.start_date ? formatDateISO(task.start_date) : void 0],
+    ["Due Date", task.due_date ? formatDateISO(task.due_date) : void 0],
+    [
+      "Time Estimate",
+      task.time_estimate != null && task.time_estimate > 0 ? formatDuration(task.time_estimate) : void 0
+    ],
+    [
+      "Time Spent",
+      task.time_spent != null && task.time_spent > 0 ? formatDuration(task.time_spent) : void 0
+    ],
+    ["Created", isoDateTime(task.date_created)],
+    ["Updated", isoDateTime(task.date_updated)],
+    ["Closed", isoDateTime(task.date_closed)],
+    ["Done", isoDateTime(task.date_done)],
+    ["Exported", fetchedAt]
+  ];
+  for (const [label, value] of header) {
+    if (value != null && value !== "") lines.push(`**${label}:** ${value}`);
+  }
+  const fields = (task.custom_fields ?? []).filter((f) => !isEmptyFieldValue(f.value));
+  if (fields.length > 0) {
+    lines.push("", "## Custom Fields", "", "| Field | Value |", "| --- | --- |");
+    for (const f of fields) {
+      lines.push(`| ${escapeCell(f.name)} | ${escapeCell(renderFieldValue(f, ctx))} |`);
+    }
+  }
+  const description = task.markdown_description ?? task.description;
+  if (description) lines.push("", "## Description", "", description);
+  if (task.checklists?.length) {
+    lines.push("", "## Checklists", "");
+    for (const cl of task.checklists) {
+      const resolved = cl.items.filter((i) => i.resolved).length;
+      lines.push(`### ${cl.name} (${resolved}/${cl.items.length})`, "");
+      for (const item of cl.items) lines.push(`- [${item.resolved ? "x" : " "}] ${item.name}`);
+      lines.push("");
+    }
+  }
+  if (task.subtasks?.length) {
+    lines.push("", "## Subtasks", "");
+    for (const s of task.subtasks) lines.push(`- ${taskLink(s.id, s.name, ctx)}`);
+  }
+  if (task.dependencies?.length) {
+    lines.push("", "## Dependencies", "");
+    for (const dep of task.dependencies) {
+      const blocks = dep.depends_on === task.id;
+      const other = blocks ? dep.task_id : dep.depends_on;
+      lines.push(`- ${blocks ? "blocks" : "depends on"} ${taskLink(other, void 0, ctx)}`);
+    }
+  }
+  if (task.linked_tasks?.length) {
+    lines.push("", "## Linked Tasks", "");
+    for (const lt of task.linked_tasks) lines.push(`- ${taskLink(lt.task_id, void 0, ctx)}`);
+  }
+  if (task.attachments?.length) {
+    lines.push("", "## Attachments", "");
+    for (const att of task.attachments) {
+      const local = ctx.attachmentPath(att.id);
+      lines.push(
+        local ? `- [${att.title}](${local})` : `- [${att.title}](${att.url}) (not downloaded)`
+      );
+    }
+  }
+  return lines.join("\n") + "\n";
+}
+function renderComment(c, quote) {
+  const prefix = quote ? "> " : "";
+  const when = isoDateTime(c.date) ?? c.date;
+  const body = c.comment_text.split(/\r?\n/).map((l) => `${prefix}${l}`);
+  return [`${prefix}**${c.user.username}** (${when})`, prefix.trimEnd(), ...body];
+}
+function renderCommentsMarkdown(bundle) {
+  const comments = bundle.comments;
+  const lines = [`# Comments (${comments.length})`, ""];
+  if (comments.length === 0) {
+    lines.push("No comments.");
+    return lines.join("\n") + "\n";
+  }
+  for (const c of comments) {
+    lines.push(...renderComment(c, false), "");
+    for (const r of c.replies) lines.push(...renderComment(r, true), "");
+    lines.push("---", "");
+  }
+  return lines.join("\n");
+}
+
+// src/export/writer.ts
+function safeAttachmentFilename(id, title) {
+  const idStem = id.replace(/\.[A-Za-z0-9]+$/, "");
+  const base = title.split(/[\\/]/).pop() ?? title;
+  const dot = base.lastIndexOf(".");
+  const stem = dot > 0 ? base.slice(0, dot) : base;
+  const ext = dot > 0 ? base.slice(dot + 1) : "";
+  const clean = (s) => s.replace(/[^A-Za-z0-9._-]+/g, "-").replace(/^[.-]+|[.-]+$/g, "").slice(0, 120);
+  const stemClean = clean(stem) || "file";
+  const extClean = clean(ext);
+  return extClean ? `${idStem}-${stemClean}.${extClean}` : `${idStem}-${stemClean}`;
+}
+async function defaultDownload(url) {
+  const res = await fetch(url, { signal: AbortSignal.timeout(12e4) });
+  if (!res.ok) throw new Error(`HTTP ${res.status} ${res.statusText}`);
+  return Buffer.from(await res.arrayBuffer());
+}
+function taskDir(root, taskId) {
+  return join(root, "tasks", taskId);
+}
+async function writeBundleData(root, bundle, opts) {
+  const dir = taskDir(root, bundle.task.id);
+  await mkdir(dir, { recursive: true });
+  const download = opts.download ?? defaultDownload;
+  const localPaths = /* @__PURE__ */ new Map();
+  const failed = [];
+  let downloaded = 0;
+  if (opts.downloadAttachments && bundle.attachments.length > 0) {
+    const attDir = join(dir, "attachments");
+    await mkdir(attDir, { recursive: true });
+    for (const att of bundle.attachments) {
+      const file = safeAttachmentFilename(att.id, att.title);
+      const target = join(attDir, file);
+      if (existsSync(target)) {
+        localPaths.set(att.id, `attachments/${file}`);
+        continue;
+      }
+      try {
+        await writeFile(target, await download(att.url));
+        localPaths.set(att.id, `attachments/${file}`);
+        downloaded++;
+      } catch (err) {
+        failed.push({ id: att.id, title: att.title, error: err.message });
+      }
+    }
+  }
+  const taskJson = JSON.stringify(bundle.task, null, 2) + "\n";
+  const contentHash = createHash("sha256").update(taskJson).digest("hex");
+  const meta = { fetchedAt: bundle.fetchedAt, subtaskIds: bundle.subtaskIds };
+  await Promise.all([
+    writeFile(join(dir, "task.json"), taskJson),
+    writeFile(join(dir, "comments.json"), JSON.stringify(bundle.comments, null, 2) + "\n"),
+    writeFile(
+      join(dir, "attachments.json"),
+      JSON.stringify(
+        bundle.attachments.map((a) => ({ ...a, local: localPaths.get(a.id) ?? null })),
+        null,
+        2
+      ) + "\n"
+    ),
+    writeFile(join(dir, "bundle.json"), JSON.stringify(meta, null, 2) + "\n")
+  ]);
+  return { dir, contentHash, attachmentsDownloaded: downloaded, attachmentsFailed: failed };
+}
+async function readBundleData(root, taskId) {
+  const dir = taskDir(root, taskId);
+  const [task, comments, attachments, meta] = await Promise.all([
+    readFile(join(dir, "task.json"), "utf8").then((s) => JSON.parse(s)),
+    readFile(join(dir, "comments.json"), "utf8").then((s) => JSON.parse(s)),
+    readFile(join(dir, "attachments.json"), "utf8").then(
+      (s) => JSON.parse(s)
+    ),
+    readFile(join(dir, "bundle.json"), "utf8").then(
+      (s) => JSON.parse(s)
+    )
+  ]);
+  return {
+    task,
+    comments,
+    attachments: attachments.map(({ local: _local, ...a }) => a),
+    subtaskIds: meta.subtaskIds,
+    fetchedAt: meta.fetchedAt
+  };
+}
+async function renderBundleMarkdown(root, bundle, hasTask, spaceName) {
+  const dir = taskDir(root, bundle.task.id);
+  const attachments = JSON.parse(await readFile(join(dir, "attachments.json"), "utf8"));
+  const localPaths = new Map(attachments.map((a) => [a.id, a.local ?? void 0]));
+  const ctx = {
+    hasTask: (id) => hasTask(id),
+    attachmentPath: (id) => localPaths.get(id),
+    ...spaceName ? { spaceName: (id) => spaceName(id) } : {}
+  };
+  await Promise.all([
+    writeFile(join(dir, "task.md"), renderTaskMarkdown(bundle, ctx)),
+    writeFile(join(dir, "comments.md"), renderCommentsMarkdown(bundle))
+  ]);
+}
+async function writeTaskBundle(root, bundle, opts) {
+  const result = await writeBundleData(root, bundle, opts);
+  await renderBundleMarkdown(root, bundle, opts.hasTask);
+  return result;
+}
+
+export {
+  formatDate,
+  formatTimestamp,
+  formatDuration,
+  formatLongDuration,
+  formatDateISO,
+  safeAttachmentFilename,
+  taskDir,
+  writeBundleData,
+  readBundleData,
+  renderBundleMarkdown,
+  writeTaskBundle
+};