@krodak/clickup-cli 1.44.0 → 1.45.0

package/dist/index.js

@@ -1,8 +1,18 @@
 #!/usr/bin/env node
+import {
+  formatDate,
+  formatDateISO,
+  formatDuration,
+  formatLongDuration,
+  formatTimestamp,
+  readBundleData,
+  renderBundleMarkdown,
+  writeBundleData
+} from "./chunk-ISEGUZ6H.js";
 
 // src/index.ts
 import { realpathSync as realpathSync2 } from "fs";
-import { basename, resolve } from "path";
+import { basename, resolve as resolve2 } from "path";
 import { Command } from "commander";
 import { createRequire } from "module";
 import { fileURLToPath } from "url";
@@ -81,10 +91,12 @@ function normalizeViewId(input) {
 var ClickUpClient = class {
   apiToken;
   teamId;
+  rateLimiter;
   meCache = null;
   constructor(config) {
     this.apiToken = config.apiToken;
     this.teamId = config.teamId;
+    this.rateLimiter = config.rateLimiter;
   }
   taskPath(taskId, suffix = "") {
     const normalized = normalizeTaskId(taskId);
@@ -102,7 +114,7 @@ var ClickUpClient = class {
     return "";
   }
   sleep(ms) {
-    return new Promise((resolve2) => setTimeout(resolve2, ms));
+    return new Promise((resolve3) => setTimeout(resolve3, ms));
   }
   retryDelayMs(res, attempt) {
     const retryAfter = res.headers.get("retry-after");
@@ -118,9 +130,11 @@ var ClickUpClient = class {
     const maxRetries = 3;
     let attempt = 0;
     for (; ; ) {
+      await this.rateLimiter?.acquire();
       const res = await fetch(url, { ...init, signal: AbortSignal.timeout(3e4) });
       const retryable = res.status === 429 || res.status === 502 || res.status === 503 || res.status === 504;
       if (!retryable || attempt >= maxRetries) return res;
+      if (res.status === 429) this.rateLimiter?.penalize();
       attempt++;
       const delayMs = this.retryDelayMs(res, attempt);
       process.stderr.write(
@@ -236,6 +250,7 @@ var ClickUpClient = class {
       subtasks: String(filters.subtasks ?? true)
     });
     if (filters.includeClosed) baseParams.set("include_closed", "true");
+    if (filters.archived) baseParams.set("archived", "true");
     if (!filters.all) {
       const me = await this.getMe();
       baseParams.append("assignees[]", String(me.id));
@@ -280,10 +295,40 @@ var ClickUpClient = class {
     const data = await this.request(this.taskPath(taskId, "/comment"));
     return readCollectionField(data, "comments", "task comments");
   }
+  /**
+   * Every comment on a task. ClickUp returns 25 per call and pages with
+   * `start` (the oldest returned comment's date) + `start_id`; the cursor
+   * comment is repeated on the next page, so results are deduped by id.
+   */
+  async getAllTaskComments(taskId) {
+    const PAGE_SIZE = 25;
+    const seen = /* @__PURE__ */ new Set();
+    const all = [];
+    let cursor;
+    for (; ; ) {
+      const qs = cursor ? `?start=${encodeURIComponent(cursor.start)}&start_id=${encodeURIComponent(cursor.startId)}` : "";
+      const data = await this.request(
+        this.taskPath(taskId, `/comment${qs}`)
+      );
+      const page = readCollectionField(data, "comments", "task comments");
+      let added = 0;
+      for (const c of page) {
+        if (seen.has(c.id)) continue;
+        seen.add(c.id);
+        all.push(c);
+        added++;
+      }
+      if (page.length < PAGE_SIZE || added === 0) break;
+      const last = page[page.length - 1];
+      cursor = { start: last.date, startId: last.id };
+    }
+    return all;
+  }
   async getTasksFromList(listId, params = {}, options = {}) {
     return this.paginate((page) => {
       const base = { subtasks: "true", page: String(page), ...params };
       if (options.includeClosed) base["include_closed"] = "true";
+      if (options.archived) base["archived"] = "true";
       const qs = new URLSearchParams(base).toString();
       return `/list/${listId}/task?${qs}`;
     });
@@ -291,6 +336,12 @@ var ClickUpClient = class {
   async getTask(taskId) {
     return this.request(this.taskPath(taskId, "?include_markdown_description=true"));
   }
+  /** Full task for archival: markdown description plus the direct subtask list. */
+  async getTaskForExport(taskId) {
+    return this.request(
+      this.taskPath(taskId, "?include_markdown_description=true&include_subtasks=true")
+    );
+  }
   /**
    * Resolve any accepted task-id form to a native ClickUp task id.
    * - Task URLs are reduced to their id segment.
@@ -764,6 +815,23 @@ var ClickUpClient = class {
     const data = await this.requestV3(`/workspaces/${workspaceId}/docs`);
     return readCollectionField(data, "docs", "docs");
   }
+  /** Every doc in the workspace, following v3 `next_cursor` pagination. */
+  async getAllDocs(workspaceId, options = {}) {
+    const all = [];
+    let cursor;
+    for (; ; ) {
+      const params = new URLSearchParams({ limit: "50" });
+      if (options.archived) params.set("archived", "true");
+      if (cursor) params.set("next_cursor", cursor);
+      const data = await this.requestV3(
+        `/workspaces/${workspaceId}/docs?${params.toString()}`
+      );
+      all.push(...readCollectionField(data, "docs", "docs"));
+      if (!data.next_cursor) break;
+      cursor = data.next_cursor;
+    }
+    return all;
+  }
   async getDocPage(workspaceId, docId, pageId) {
     return this.requestV3(
       `/workspaces/${workspaceId}/docs/${docId}/pages/${pageId}?content_format=text/md`
@@ -1562,50 +1630,6 @@ function writeConfig(config, profileName) {
   saveMultiProfileConfig(multi);
 }
 
-// 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/output.ts
 import chalk from "chalk";
 function isTTY() {
@@ -4280,6 +4304,42 @@ var commandMetadata = [
       }
     ]
   },
+  {
+    name: "export",
+    description: "Export tasks and docs to a local archive (lossless JSON + rendered markdown)",
+    quickReference: [
+      {
+        section: "read",
+        usage: "export user <userRef>",
+        description: "Export all tasks assigned to a user (me, id, email; incl. closed, archived)"
+      },
+      {
+        section: "read",
+        usage: "export team <spaceRef>",
+        description: "Export every list in a space (id or name), incl. archived"
+      },
+      {
+        section: "read",
+        usage: "export roadmap <listId>",
+        description: "Export a list with initiatives grouped (--item-id) and subtask trees"
+      },
+      {
+        section: "read",
+        usage: "export initiatives <listId>",
+        description: "Export only initiative-typed tasks (--item-id) plus their subtask trees"
+      },
+      {
+        section: "read",
+        usage: "export docs",
+        description: "Export every workspace doc as markdown page trees"
+      },
+      {
+        section: "read",
+        usage: "export all",
+        description: "Export the whole workspace (plans, confirms; --yes for non-interactive)"
+      }
+    ]
+  },
   {
     name: "attach-get",
     description: "Download task attachment(s) by ID or title",
@@ -6371,8 +6431,8 @@ async function installSkillInteractive() {
   const source = skillPath();
   const installed = [];
   if (isTTY()) {
-    const { checkbox: checkbox2 } = await import("@inquirer/prompts");
-    const selected = await checkbox2({
+    const { checkbox: checkbox3 } = await import("@inquirer/prompts");
+    const selected = await checkbox3({
       message: "Install skill for which agents?",
       choices: targets.map((t) => ({
         name: `${t.name}${t.detected ? chalk8.dim(" (detected)") : ""}`,
@@ -7163,7 +7223,7 @@ async function downloadAttachment(attachment, targetPath, force) {
   return { title: attachment.title, path: targetPath, size: buffer.length };
 }
 async function attachGet(config, taskId, selector, opts) {
-  const { resolve: resolve2 } = await import("path");
+  const { resolve: resolve3 } = await import("path");
   const client = new ClickUpClient(config);
   const attachments = await client.getTaskAttachments(taskId);
   const selected = selectAttachments(attachments, selector, opts.all ?? false);
@@ -7171,16 +7231,1066 @@ async function attachGet(config, taskId, selector, opts) {
   for (const att of selected) {
     let targetPath;
     if (opts.output && !opts.all) {
-      targetPath = resolve2(opts.output);
+      targetPath = resolve3(opts.output);
     } else {
       const dir = opts.dir ?? ".";
-      targetPath = resolve2(dir, sanitizeFilename(att.title));
+      targetPath = resolve3(dir, sanitizeFilename(att.title));
     }
     results.push(await downloadAttachment(att, targetPath, opts.force ?? false));
   }
   return results;
 }
 
+// src/commands/export.ts
+import { mkdirSync as mkdirSync4, writeFileSync as writeFileSync4 } from "fs";
+import { join as join6, resolve } from "path";
+
+// src/export/discover.ts
+function slug(name) {
+  return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 60) || "unnamed";
+}
+async function resolveUserRef(client, teamId, ref) {
+  if (ref === "me") {
+    const me = await client.getMe();
+    return { id: me.id, username: me.username };
+  }
+  const members = await client.getWorkspaceMembers(teamId);
+  const needle = ref.trim().toLowerCase();
+  const match = members.find(
+    (m) => String(m.id) === needle || m.username?.toLowerCase() === needle || m.email?.toLowerCase() === needle
+  );
+  if (!match) {
+    const available = members.map((m) => m.username ?? m.email ?? String(m.id)).join(", ");
+    throw new Error(`User "${ref}" not found. Available: ${available}`);
+  }
+  return { id: match.id, username: match.username ?? match.email ?? String(match.id) };
+}
+async function workspaceInfo(client, teamId) {
+  const teams = await client.getTeams();
+  const team = teams.find((t) => t.id === teamId);
+  return { id: teamId, name: team?.name ?? teamId };
+}
+function toDiscovered(task) {
+  return {
+    id: task.id,
+    listId: task.list.id,
+    initiative: (task.custom_item_id ?? 0) !== 0
+  };
+}
+function dedupe(tasks) {
+  const seen = /* @__PURE__ */ new Set();
+  return tasks.filter((t) => seen.has(t.id) ? false : (seen.add(t.id), true));
+}
+async function discoverUserTasks(client, teamId, userRef) {
+  const user = await resolveUserRef(client, teamId, userRef);
+  const base = { all: true, assignees: [user.id], includeClosed: true, subtasks: true };
+  const [active, archived] = await Promise.all([
+    client.getMyTasks(teamId, base),
+    client.getMyTasks(teamId, { ...base, archived: true })
+  ]);
+  const all = dedupe([...active, ...archived]);
+  return {
+    slice: { name: `user-${slug(user.username)}`, kind: "user", scope: String(user.id) },
+    tasks: all.map(toDiscovered),
+    workspace: await workspaceInfo(client, teamId),
+    tasksById: Object.fromEntries(all.map((t) => [t.id, t]))
+  };
+}
+async function resolveSpaceRef(client, teamId, ref) {
+  const spaces = await client.getSpaces(teamId);
+  const needle = ref.trim().toLowerCase();
+  const match = spaces.find((s) => s.id === ref.trim() || s.name.toLowerCase() === needle);
+  if (!match) {
+    throw new Error(`Space "${ref}" not found. Available: ${spaces.map((s) => s.name).join(", ")}`);
+  }
+  return { id: match.id, name: match.name };
+}
+async function listTasks(client, listId) {
+  const [active, archived] = await Promise.all([
+    client.getTasksFromList(listId, {}, { includeClosed: true }),
+    client.getTasksFromList(listId, {}, { includeClosed: true, archived: true })
+  ]);
+  return dedupe([...active, ...archived]);
+}
+async function union(active, archived) {
+  const [a, b] = await Promise.all([active, archived]);
+  const seen = /* @__PURE__ */ new Set();
+  return [...a, ...b].filter((x) => seen.has(x.id) ? false : (seen.add(x.id), true));
+}
+async function walkSpace(client, spaceId, spaceName) {
+  const [lists, folders] = await Promise.all([
+    union(client.getLists(spaceId, false), client.getLists(spaceId, true)),
+    union(client.getFolders(spaceId, false), client.getFolders(spaceId, true))
+  ]);
+  const folderEntries = await Promise.all(
+    folders.map(async (f) => ({
+      id: f.id,
+      name: f.name,
+      lists: (await union(client.getFolderLists(f.id, false), client.getFolderLists(f.id, true))).map((l) => ({ id: l.id, name: l.name }))
+    }))
+  );
+  const hierarchy = {
+    space: { id: spaceId, name: spaceName },
+    folders: folderEntries,
+    lists: lists.map((l) => ({ id: l.id, name: l.name }))
+  };
+  return hierarchy;
+}
+async function discoverTeamTasks(client, teamId, spaceRef) {
+  const space = await resolveSpaceRef(client, teamId, spaceRef);
+  const hierarchy = await walkSpace(client, space.id, space.name);
+  const listIds = [
+    ...hierarchy.lists.map((l) => l.id),
+    ...hierarchy.folders.flatMap((f) => f.lists.map((l) => l.id))
+  ];
+  const perList = await Promise.all(listIds.map((id) => listTasks(client, id)));
+  const all = dedupe(perList.flat());
+  return {
+    slice: { name: `team-${slug(space.name)}`, kind: "team", scope: space.id },
+    tasks: all.map(toDiscovered),
+    workspace: await workspaceInfo(client, teamId),
+    tasksById: Object.fromEntries(all.map((t) => [t.id, t])),
+    hierarchy
+  };
+}
+async function discoverListTasks(client, teamId, listId, opts) {
+  const list = await client.getListWithStatuses(listId);
+  let all = await listTasks(client, listId);
+  if (opts.kind === "initiatives") {
+    const itemId = opts.initiativeItemId;
+    if (itemId === void 0) throw new Error("initiatives export requires an initiative item id");
+    const matching = all.filter((t) => t.custom_item_id === itemId);
+    if (matching.length === 0) {
+      const found = [...new Set(all.map((t) => t.custom_item_id ?? 0).filter((id) => id !== 0))].sort((a, b) => a - b).join(", ");
+      throw new Error(
+        `No tasks with custom item id ${itemId} in list "${list.name}" (custom item ids found: ${found || "none"})`
+      );
+    }
+    all = matching;
+  }
+  return {
+    slice: { name: `${opts.kind}-${slug(list.name)}`, kind: opts.kind, scope: listId },
+    tasks: all.map(toDiscovered),
+    workspace: await workspaceInfo(client, teamId),
+    tasksById: Object.fromEntries(all.map((t) => [t.id, t])),
+    list: { id: list.id, name: list.name }
+  };
+}
+
+// src/util/batch.ts
+async function runInBatches(items, concurrency, fn) {
+  if (!Number.isInteger(concurrency) || concurrency < 1) {
+    throw new Error(`concurrency must be a positive integer, got ${concurrency}`);
+  }
+  const results = [];
+  for (let i = 0; i < items.length; i += concurrency) {
+    const batch = items.slice(i, i + concurrency);
+    const settled = await Promise.allSettled(batch.map(fn));
+    settled.forEach((res, idx) => {
+      const item = batch[idx];
+      if (res.status === "fulfilled") {
+        results.push({ item, ok: true, result: res.value });
+      } else {
+        const error = res.reason instanceof Error ? res.reason : new Error(String(res.reason), { cause: res.reason });
+        results.push({ item, ok: false, error });
+      }
+    });
+  }
+  return results;
+}
+
+// src/export/bundle.ts
+function replyCount(c) {
+  const n = c.reply_count;
+  return typeof n === "number" ? n : 0;
+}
+async function fetchTaskBundle(client, taskId) {
+  const [task, rawComments] = await Promise.all([
+    client.getTaskForExport(taskId),
+    client.getAllTaskComments(taskId)
+  ]);
+  const comments = await Promise.all(
+    rawComments.map(async (c) => ({
+      ...c,
+      replies: replyCount(c) > 0 ? await client.getThreadedComments(c.id) : []
+    }))
+  );
+  return {
+    task,
+    comments,
+    attachments: task.attachments ?? [],
+    subtaskIds: (task.subtasks ?? []).map((s) => s.id),
+    fetchedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+
+// src/export/manifest.ts
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync3, renameSync, writeFileSync } from "fs";
+import { join as join3 } from "path";
+var MANIFEST_VERSION = 1;
+var FILE = "manifest.json";
+function emptyManifest() {
+  return { version: MANIFEST_VERSION, workspace: void 0, tasks: {}, docs: {}, slices: {} };
+}
+function loadManifest(root) {
+  const path = join3(root, FILE);
+  if (!existsSync2(path)) return emptyManifest();
+  let parsed;
+  try {
+    parsed = JSON.parse(readFileSync3(path, "utf8"));
+  } catch (err) {
+    throw new Error(`Cannot parse ${path}: ${err.message}`, { cause: err });
+  }
+  const m = parsed;
+  if (m.version !== MANIFEST_VERSION) {
+    throw new Error(
+      `Unsupported manifest version ${String(m.version)} in ${path} (expected ${MANIFEST_VERSION})`
+    );
+  }
+  return {
+    version: MANIFEST_VERSION,
+    workspace: m.workspace ?? void 0,
+    tasks: m.tasks ?? {},
+    docs: m.docs ?? {},
+    slices: m.slices ?? {}
+  };
+}
+function saveManifest(root, manifest) {
+  mkdirSync2(root, { recursive: true });
+  const path = join3(root, FILE);
+  const tmp = `${path}.tmp`;
+  writeFileSync(tmp, JSON.stringify(manifest, null, 2) + "\n");
+  renameSync(tmp, path);
+}
+
+// src/export/engine.ts
+function addSlice(manifest, taskId, slice) {
+  const entry = manifest.tasks[taskId];
+  if (entry && !entry.slices.includes(slice)) entry.slices.push(slice);
+}
+async function runExport(client, plan, opts) {
+  const manifest = loadManifest(opts.root);
+  manifest.workspace = plan.workspace;
+  const sliceName = plan.slice.name;
+  const checkpointEvery = opts.checkpointEvery ?? 25;
+  const queue = [];
+  const queued = /* @__PURE__ */ new Set();
+  const enqueue = (id) => {
+    if (!queued.has(id)) {
+      queued.add(id);
+      queue.push(id);
+    }
+  };
+  for (const t of plan.tasks) enqueue(t.id);
+  const summary = {
+    fetched: 0,
+    skipped: 0,
+    failed: [],
+    attachmentsDownloaded: 0,
+    attachmentsFailed: 0
+  };
+  const touched = /* @__PURE__ */ new Set();
+  let sinceCheckpoint = 0;
+  while (queue.length > 0) {
+    const batch = queue.splice(0, opts.concurrency);
+    const toFetch = [];
+    for (const id of batch) {
+      touched.add(id);
+      if (!opts.refresh && manifest.tasks[id]) {
+        summary.skipped++;
+        addSlice(manifest, id, sliceName);
+        try {
+          const cached = await readBundleData(opts.root, id);
+          for (const s of cached.subtaskIds) enqueue(s);
+        } catch {
+          delete manifest.tasks[id];
+          toFetch.push(id);
+          summary.skipped--;
+        }
+        continue;
+      }
+      toFetch.push(id);
+    }
+    const outcomes = await runInBatches(toFetch, opts.concurrency, async (id) => {
+      const bundle = await fetchTaskBundle(client, id);
+      const written = await writeBundleData(opts.root, bundle, {
+        downloadAttachments: opts.downloadAttachments,
+        download: opts.download
+      });
+      return { bundle, written };
+    });
+    for (const o of outcomes) {
+      if (!o.ok) {
+        summary.failed.push({ id: o.item, error: o.error.message });
+        continue;
+      }
+      const { bundle, written } = o.result;
+      summary.fetched++;
+      summary.attachmentsDownloaded += written.attachmentsDownloaded;
+      summary.attachmentsFailed += written.attachmentsFailed.length;
+      const existing = manifest.tasks[bundle.task.id];
+      manifest.tasks[bundle.task.id] = {
+        fetchedAt: bundle.fetchedAt,
+        slices: existing?.slices.includes(sliceName) ? existing.slices : [...existing?.slices ?? [], sliceName],
+        contentHash: written.contentHash
+      };
+      for (const s of bundle.subtaskIds) enqueue(s);
+      sinceCheckpoint++;
+    }
+    const total = touched.size + queue.length;
+    const done = summary.fetched + summary.skipped + summary.failed.length;
+    opts.log(
+      `[${sliceName}] ${done}/${total} tasks (${summary.fetched} fetched, ${summary.skipped} cached, ${summary.failed.length} failed)`
+    );
+    if (sinceCheckpoint >= checkpointEvery) {
+      saveManifest(opts.root, manifest);
+      sinceCheckpoint = 0;
+    }
+  }
+  const known = new Set(Object.keys(manifest.tasks));
+  const hasTask = (id) => known.has(id);
+  const spaceNames = opts.spaceNames;
+  const spaceName = spaceNames ? (id) => spaceNames[id] : void 0;
+  const renderOutcomes = await runInBatches([...known], opts.concurrency * 2, async (id) => {
+    const bundle = await readBundleData(opts.root, id);
+    await renderBundleMarkdown(opts.root, bundle, hasTask, spaceName);
+  });
+  for (const o of renderOutcomes) {
+    if (!o.ok) opts.log(`warning: could not render ${o.item}: ${o.error.message}`);
+  }
+  manifest.slices[sliceName] = {
+    kind: plan.slice.kind,
+    scope: plan.slice.scope,
+    exportedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    taskCount: [...touched].filter((id) => manifest.tasks[id]).length
+  };
+  saveManifest(opts.root, manifest);
+  return summary;
+}
+
+// src/export/docs.ts
+import { mkdirSync as mkdirSync3, writeFileSync as writeFileSync2 } from "fs";
+import { join as join4 } from "path";
+var PARENT_TYPES = {
+  7: "workspace",
+  4: "space",
+  6: "folder",
+  5: "list",
+  1: "task"
+};
+function docDirName(doc) {
+  const s = doc.name ? slug(doc.name) : "";
+  return s && s !== "unnamed" ? `${s}-${doc.id}` : doc.id;
+}
+function pageFileName(page) {
+  const s = page.name ? slug(page.name) : "";
+  return s && s !== "unnamed" ? `${s}-${page.id}.md` : `${page.id}.md`;
+}
+function pageDirName(page) {
+  return pageFileName(page).replace(/\.md$/, "");
+}
+function yamlString(v) {
+  return JSON.stringify(v);
+}
+function renderPage(page, docId) {
+  const header = [
+    "---",
+    `id: ${page.id}`,
+    `doc: ${docId}`,
+    `title: ${page.name ? yamlString(page.name).slice(1, -1) : ""}`,
+    ...page.parent_page_id ? [`parent: ${page.parent_page_id}`] : [],
+    ...page.archived ? ["archived: true"] : [],
+    ...page.date_created ? [`created: ${new Date(page.date_created).toISOString()}`] : [],
+    ...page.date_updated ? [`updated: ${new Date(page.date_updated).toISOString()}`] : [],
+    "---"
+  ];
+  return header.join("\n") + "\n\n" + (page.content ?? "") + "\n";
+}
+function writePages(dir, docId, pages, prefix = "", depth = 0) {
+  const out = [];
+  for (const page of pages) {
+    const file = pageFileName(page);
+    const relPath = prefix ? `${prefix}/${file}` : file;
+    mkdirSync3(join4(dir, prefix), { recursive: true });
+    writeFileSync2(join4(dir, relPath), renderPage(page, docId));
+    out.push({ page, relPath, depth });
+    if (page.pages?.length) {
+      const childPrefix = prefix ? `${prefix}/${pageDirName(page)}` : pageDirName(page);
+      out.push(...writePages(dir, docId, page.pages, childPrefix, depth + 1));
+    }
+  }
+  return out;
+}
+function docTitle(doc) {
+  return doc.name || `(unnamed ${doc.id})`;
+}
+function renderDocReadme(doc, written, location) {
+  const lines = [
+    `# ${docTitle(doc)}`,
+    "",
+    `Doc id: ${doc.id} \xB7 Location: ${location} \xB7 ${written.length} pages`,
+    ...doc.date_updated ? [`Last updated: ${new Date(Number(doc.date_updated)).toISOString()}`] : [],
+    "",
+    "## Pages",
+    ""
+  ];
+  for (const w of written) {
+    const name = w.page.name || `(untitled ${w.page.id})`;
+    const flag = w.page.archived ? " (archived)" : "";
+    lines.push(`${"    ".repeat(w.depth)}- [${name}](${w.relPath})${flag}`);
+  }
+  lines.push("");
+  return lines.join("\n");
+}
+function renderDocsIndex(entries) {
+  const lines = [
+    "# Docs",
+    "",
+    `${entries.length} docs`,
+    "",
+    "| Doc | Location | Pages |",
+    "| --- | --- | --- |"
+  ];
+  for (const e of entries.sort((a, b) => docTitle(a.doc).localeCompare(docTitle(b.doc)))) {
+    lines.push(`| [${docTitle(e.doc)}](${e.dir}/README.md) | ${e.location} | ${e.pages} |`);
+  }
+  lines.push("");
+  return lines.join("\n");
+}
+function countPages(pages) {
+  return pages.reduce((n, p) => n + 1 + countPages(p.pages ?? []), 0);
+}
+async function exportDocs(client, teamId, opts) {
+  const manifest = loadManifest(opts.root);
+  const docsRoot = join4(opts.root, "docs");
+  mkdirSync3(docsRoot, { recursive: true });
+  const [docs, spaces, teams] = await Promise.all([
+    client.getAllDocs(teamId),
+    client.getSpaces(teamId),
+    client.getTeams()
+  ]);
+  const spaceNames = new Map(spaces.map((s) => [s.id, s.name]));
+  const teamName = teams.find((t) => t.id === teamId)?.name ?? teamId;
+  const locationOf = (doc) => {
+    const t = doc.parent ? PARENT_TYPES[doc.parent.type] ?? `type ${doc.parent.type}` : "unknown";
+    const id = doc.parent?.id ?? "";
+    if (t === "space") return `space ${spaceNames.get(id) ?? id}`;
+    if (t === "workspace") return `workspace ${teamName}`;
+    return `${t} ${id}`;
+  };
+  const summary = { docs: 0, pages: 0, skipped: 0, failed: [] };
+  const entries = [];
+  opts.log(`Plan [docs]: ${docs.length} docs in workspace "${teamName}"`);
+  for (const doc of docs) {
+    const dir = docDirName(doc);
+    const location = locationOf(doc);
+    const cached = manifest.docs[doc.id];
+    if (cached && !opts.refresh) {
+      summary.skipped++;
+      entries.push({ doc, dir, pages: cached.pageCount, location });
+      continue;
+    }
+    try {
+      const pages = await client.getDocPages(teamId, doc.id);
+      const dirPath = join4(docsRoot, dir);
+      mkdirSync3(dirPath, { recursive: true });
+      writeFileSync2(join4(dirPath, "doc.json"), JSON.stringify({ doc, pages }, null, 2) + "\n");
+      const written = writePages(dirPath, doc.id, pages);
+      writeFileSync2(join4(dirPath, "README.md"), renderDocReadme(doc, written, location));
+      const pageCount = countPages(pages);
+      manifest.docs[doc.id] = {
+        fetchedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        name: doc.name,
+        pageCount
+      };
+      summary.docs++;
+      summary.pages += pageCount;
+      entries.push({ doc, dir, pages: pageCount, location });
+      opts.log(
+        `[docs] ${summary.docs + summary.skipped + summary.failed.length}/${docs.length} ${docTitle(doc)} (${pageCount} pages)`
+      );
+    } catch (err) {
+      summary.failed.push({ id: doc.id, error: err.message });
+    }
+  }
+  writeFileSync2(join4(docsRoot, "README.md"), renderDocsIndex(entries));
+  manifest.slices["docs"] = {
+    kind: "docs",
+    scope: teamId,
+    exportedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    taskCount: 0
+  };
+  if (!manifest.workspace) manifest.workspace = { id: teamId, name: teamName };
+  saveManifest(opts.root, manifest);
+  return summary;
+}
+
+// src/export/index-team.ts
+function link(task) {
+  return `[${task.name.replace(/\|/g, "\\|")}](../../tasks/${task.id}/task.md)`;
+}
+function assignees(task) {
+  return task.assignees.map((a) => a.username).join(", ");
+}
+function typeOf(task, initiativeItemId) {
+  const id = task.custom_item_id ?? 0;
+  if (id === 0) return "task";
+  return initiativeItemId !== void 0 && id === initiativeItemId ? "initiative" : `type ${id}`;
+}
+function taskTable(tasks, initiativeItemId) {
+  const lines = ["| Task | Status | Assignees | Type |", "| --- | --- | --- | --- |"];
+  for (const t of tasks) {
+    lines.push(
+      `| ${link(t)} | ${t.status.status} | ${assignees(t)} | ${typeOf(t, initiativeItemId)} |`
+    );
+  }
+  return lines;
+}
+function renderTeamIndex(hierarchy, tasks, opts) {
+  const topLevel = tasks.filter((t) => !t.parent);
+  const byList = /* @__PURE__ */ new Map();
+  for (const t of topLevel) byList.set(t.list.id, [...byList.get(t.list.id) ?? [], t]);
+  const listCount = hierarchy.lists.length + hierarchy.folders.reduce((n, f) => n + f.lists.length, 0);
+  const folderWord = hierarchy.folders.length === 1 ? "folder" : "folders";
+  const lines = [
+    `# ${hierarchy.space.name} (space)`,
+    "",
+    `Exported ${opts.exportedAt.slice(0, 10)} \xB7 ${listCount} lists \xB7 ${hierarchy.folders.length} ${folderWord} \xB7 ${tasks.length} tasks`,
+    ""
+  ];
+  const renderList = (list, level) => {
+    const group = byList.get(list.id) ?? [];
+    const h = "#".repeat(level);
+    lines.push(`${h} ${list.name} \u2014 ${group.length} tasks`, "");
+    const related = opts.relatedSlices?.filter((s) => s.listId === list.id) ?? [];
+    for (const r of related) {
+      lines.push(`\u2192 see also [${r.name}](../${r.name}/README.md)`, "");
+    }
+    if (group.length > 0) lines.push(...taskTable(group, opts.initiativeItemId), "");
+  };
+  for (const list of hierarchy.lists) renderList(list, 2);
+  for (const folder of hierarchy.folders) {
+    lines.push(`## Folder: ${folder.name}`, "");
+    for (const list of folder.lists) renderList(list, 3);
+  }
+  return lines.join("\n");
+}
+function checkbox2(task) {
+  return isDoneStatus(task.status.status) ? "[x]" : "[ ]";
+}
+function renderRoadmapIndex(list, tasks, opts) {
+  const children = /* @__PURE__ */ new Map();
+  for (const t of tasks) {
+    if (t.parent) children.set(t.parent, [...children.get(t.parent) ?? [], t]);
+  }
+  const isInitiative = (t) => opts.initiativeItemId !== void 0 && t.custom_item_id === opts.initiativeItemId;
+  const initiatives = tasks.filter((t) => !t.parent && isInitiative(t));
+  const ungrouped = tasks.filter((t) => !t.parent && !isInitiative(t));
+  const lines = [
+    `# ${list.name}`,
+    "",
+    `Exported ${opts.exportedAt.slice(0, 10)} \xB7 ${initiatives.length} initiatives \xB7 ${tasks.length} tasks`,
+    ""
+  ];
+  const renderTree = (parentId, depth) => {
+    for (const c of children.get(parentId) ?? []) {
+      lines.push(`${"    ".repeat(depth)}- ${checkbox2(c)} ${link(c)}`);
+      renderTree(c.id, depth + 1);
+    }
+  };
+  if (initiatives.length > 0) {
+    lines.push("## Initiatives", "");
+    for (const init of initiatives) {
+      lines.push(`### ${link(init)} \u2014 ${init.status.status}`);
+      const meta = [];
+      if (init.assignees.length > 0) meta.push(`Owner: ${assignees(init)}`);
+      if (init.tags?.length) meta.push(`Tags: ${init.tags.map((t) => t.name).join(", ")}`);
+      if (init.start_date || init.due_date) {
+        const from = init.start_date ? formatDateISO(init.start_date) : "?";
+        const to = init.due_date ? formatDateISO(init.due_date) : "?";
+        meta.push(`${from} \u2192 ${to}`);
+      }
+      if (meta.length > 0) lines.push(meta.join(" \xB7 "));
+      lines.push("");
+      if (children.has(init.id)) {
+        renderTree(init.id, 0);
+        lines.push("");
+      }
+    }
+  }
+  lines.push(`## Ungrouped tasks (${ungrouped.length})`, "");
+  if (ungrouped.length > 0) {
+    lines.push("| Task | Status | Assignees |", "| --- | --- | --- |");
+    for (const t of ungrouped) lines.push(`| ${link(t)} | ${t.status.status} | ${assignees(t)} |`);
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+
+// src/export/index-user.ts
+function link2(task) {
+  return `[${task.name.replace(/\|/g, "\\|")}](../../tasks/${task.id}/task.md)`;
+}
+function cap(s) {
+  return s.charAt(0).toUpperCase() + s.slice(1);
+}
+function closedAt(task) {
+  return task.date_closed ?? task.date_done ?? void 0;
+}
+function monthOf(ms) {
+  return formatDateISO(ms).slice(0, 7);
+}
+function renderUserIndex(user, tasks, opts) {
+  const lines = [
+    `# ${user.username} \u2014 tasks`,
+    "",
+    `Exported ${opts.exportedAt.slice(0, 10)} \xB7 ${tasks.length} tasks assigned \xB7 user id ${user.id}`,
+    ""
+  ];
+  const open = tasks.filter((t) => !isDoneStatus(t.status.status));
+  const done = tasks.filter((t) => isDoneStatus(t.status.status));
+  const byStatus = /* @__PURE__ */ new Map();
+  for (const t of open) {
+    const key = t.status.status.toLowerCase();
+    byStatus.set(key, [...byStatus.get(key) ?? [], t]);
+  }
+  const order = (s) => /progress|review|active/.test(s) ? 0 : /to ?do|open|backlog/.test(s) ? 2 : 1;
+  for (const [status, group] of [...byStatus.entries()].sort(
+    (a, b) => order(a[0]) - order(b[0]) || a[0].localeCompare(b[0])
+  )) {
+    lines.push(
+      `## ${cap(status)} (${group.length})`,
+      "",
+      "| Task | List | Due |",
+      "| --- | --- | --- |"
+    );
+    for (const t of group) {
+      lines.push(`| ${link2(t)} | ${t.list.name} | ${t.due_date ? formatDateISO(t.due_date) : ""} |`);
+    }
+    lines.push("");
+  }
+  if (done.length > 0) {
+    lines.push(`## Done (${done.length})`, "");
+    const byMonth = /* @__PURE__ */ new Map();
+    for (const t of done) {
+      const when = closedAt(t);
+      const key = when ? monthOf(when) : "unknown";
+      byMonth.set(key, [...byMonth.get(key) ?? [], t]);
+    }
+    for (const [month, group] of [...byMonth.entries()].sort((a, b) => b[0].localeCompare(a[0]))) {
+      lines.push(`### ${month}`, "", "| Task | List | Closed |", "| --- | --- | --- |");
+      for (const t of group) {
+        const when = closedAt(t);
+        lines.push(`| ${link2(t)} | ${t.list.name} | ${when ? formatDateISO(when) : ""} |`);
+      }
+      lines.push("");
+    }
+  }
+  const where = /* @__PURE__ */ new Map();
+  for (const t of tasks) {
+    const space = t.space?.id ? opts.spaceNames[t.space.id] ?? t.space.id : "Unknown space";
+    const key = `${space} / ${t.list.name}`;
+    where.set(key, (where.get(key) ?? 0) + 1);
+  }
+  lines.push("## Where these live", "");
+  for (const [key, n] of [...where.entries()].sort((a, b) => b[1] - a[1])) {
+    lines.push(`- ${key}: ${n}`);
+  }
+  lines.push("");
+  return lines.join("\n");
+}
+
+// src/export/root-readme.ts
+import { writeFileSync as writeFileSync3 } from "fs";
+import { join as join5 } from "path";
+function renderRootReadme(manifest) {
+  const ws = manifest.workspace;
+  const taskCount = Object.keys(manifest.tasks).length;
+  const docCount = Object.keys(manifest.docs).length;
+  const lines = [
+    `# ClickUp export${ws ? `: ${ws.name}` : ""}`,
+    "",
+    `${taskCount} tasks \xB7 ${docCount} docs \xB7 generated by \`cup export\``,
+    "",
+    "## Slices",
+    "",
+    "Each slice is an index into the shared task store. Start from whichever matches what you are looking for.",
+    "",
+    "| Slice | Kind | Scope | Tasks | Exported |",
+    "| --- | --- | --- | --- | --- |"
+  ];
+  const slices = Object.entries(manifest.slices).filter(([, s]) => s.kind !== "docs").sort((a, b) => a[0].localeCompare(b[0]));
+  for (const [name, s] of slices) {
+    lines.push(
+      `| [${name}](slices/${name}/README.md) | ${s.kind} | ${s.scope} | ${s.taskCount} | ${s.exportedAt.slice(0, 10)} |`
+    );
+  }
+  if (docCount > 0) lines.push("", "Docs: [docs/](docs/README.md)");
+  lines.push(
+    "",
+    "## Layout",
+    "",
+    "- `tasks/<id>/` \u2014 one directory per task: `task.json` (lossless API payload), `task.md` (rendered), `comments.json` / `comments.md`, `attachments/`",
+    "- `slices/<name>/README.md` \u2014 navigable index for one export scope",
+    "- `manifest.json` \u2014 what has been exported and when; drives incremental re-runs",
+    "",
+    "Task ids match ClickUp URLs: `https://app.clickup.com/t/<id>` \u2192 `tasks/<id>/`.",
+    ""
+  );
+  return lines.join("\n");
+}
+function writeRootReadme(root, manifest) {
+  writeFileSync3(join5(root, "README.md"), renderRootReadme(manifest));
+}
+
+// src/util/rate-limit.ts
+function createRateLimiter(requestsPerMinute) {
+  if (!(requestsPerMinute > 0)) {
+    throw new Error(`requestsPerMinute must be a positive number, got ${requestsPerMinute}`);
+  }
+  const capacity = Math.max(5, Math.floor(requestsPerMinute / 10));
+  const refillPerMs = requestsPerMinute / 6e4;
+  let tokens = capacity;
+  let lastRefill = Date.now();
+  const queue = [];
+  let timer;
+  function refill() {
+    const now = Date.now();
+    tokens = Math.min(capacity, tokens + (now - lastRefill) * refillPerMs);
+    lastRefill = now;
+  }
+  function drain() {
+    timer = void 0;
+    refill();
+    while (queue.length > 0 && tokens >= 1) {
+      tokens -= 1;
+      queue.shift()();
+    }
+    if (queue.length > 0) {
+      const waitMs = Math.ceil((1 - tokens) / refillPerMs);
+      timer = setTimeout(drain, waitMs);
+    }
+  }
+  return {
+    acquire() {
+      return new Promise((resolve3) => {
+        queue.push(resolve3);
+        if (!timer) drain();
+      });
+    },
+    penalize() {
+      refill();
+      tokens = 0;
+    }
+  };
+}
+
+// src/commands/export.ts
+var CONCURRENCY = 4;
+function requireTeam(config) {
+  if (!config.teamId) {
+    throw new Error("Export requires a teamId in your config. Run `cup init` to set one.");
+  }
+  return config.teamId;
+}
+function makeClient(config, rpm) {
+  return new ClickUpClient({ ...config, rateLimiter: createRateLimiter(rpm) });
+}
+function emptySummary(plan, opts) {
+  return {
+    slice: plan.slice.name,
+    planned: plan.tasks.length,
+    out: resolve(opts.out),
+    dryRun: opts.dryRun,
+    fetched: 0,
+    skipped: 0,
+    failed: [],
+    attachmentsDownloaded: 0,
+    attachmentsFailed: 0
+  };
+}
+function describePlan(plan) {
+  const initiatives = plan.tasks.filter((t) => t.initiative).length;
+  return `Plan [${plan.slice.name}]: ${plan.tasks.length} tasks (${initiatives} initiatives) in workspace "${plan.workspace.name}"`;
+}
+async function execute(client, teamId, plan, opts, writeIndex) {
+  opts.log(describePlan(plan));
+  const summary = emptySummary(plan, opts);
+  if (opts.dryRun) return summary;
+  const root = resolve(opts.out);
+  const spaces = await client.getSpaces(teamId);
+  const spaceNames = Object.fromEntries(spaces.map((s) => [s.id, s.name]));
+  const run2 = await runExport(client, plan, {
+    root,
+    refresh: opts.refresh,
+    downloadAttachments: opts.attachments,
+    concurrency: CONCURRENCY,
+    log: opts.log,
+    spaceNames
+  });
+  await writeIndex(root, spaceNames);
+  writeRootReadme(root, loadManifest(root));
+  return { ...summary, ...run2 };
+}
+async function exportUser(config, userRef, opts) {
+  const teamId = requireTeam(config);
+  const client = makeClient(config, opts.rpm);
+  const user = await resolveUserRef(client, teamId, userRef);
+  const plan = await discoverUserTasks(client, teamId, userRef);
+  return execute(client, teamId, plan, opts, async (root, spaceNames) => {
+    const tasks = Object.values(plan.tasksById ?? {});
+    const dir = join6(root, "slices", plan.slice.name);
+    mkdirSync4(dir, { recursive: true });
+    writeFileSync4(
+      join6(dir, "README.md"),
+      renderUserIndex(user, tasks, { exportedAt: (/* @__PURE__ */ new Date()).toISOString(), spaceNames })
+    );
+    writeFileSync4(
+      join6(dir, "tasks.json"),
+      JSON.stringify({ user, taskIds: plan.tasks.map((t) => t.id) }, null, 2) + "\n"
+    );
+  });
+}
+function formatExportSummary(s) {
+  if (s.dryRun) return `Dry run: ${s.planned} tasks would be exported to ${s.out}`;
+  const lines = [
+    `Exported slice "${s.slice}" to ${s.out}`,
+    `  tasks: ${s.fetched} fetched, ${s.skipped} already present, ${s.failed.length} failed`,
+    `  attachments: ${s.attachmentsDownloaded} downloaded, ${s.attachmentsFailed} failed`
+  ];
+  for (const f of s.failed.slice(0, 10)) lines.push(`  failed ${f.id}: ${f.error}`);
+  if (s.failed.length > 10) lines.push(`  ... and ${s.failed.length - 10} more`);
+  return lines.join("\n");
+}
+function writeSliceFiles(root, sliceName, readme, meta) {
+  const dir = join6(root, "slices", sliceName);
+  mkdirSync4(dir, { recursive: true });
+  writeFileSync4(join6(dir, "README.md"), readme);
+  writeFileSync4(join6(dir, "tasks.json"), JSON.stringify(meta, null, 2) + "\n");
+}
+async function exportTeam(config, spaceRef, opts) {
+  const teamId = requireTeam(config);
+  const client = makeClient(config, opts.rpm);
+  const plan = await discoverTeamTasks(client, teamId, spaceRef);
+  return execute(client, teamId, plan, opts, async (root) => {
+    const manifest = loadManifest(root);
+    const relatedSlices = Object.entries(manifest.slices).filter(([, s]) => s.kind === "roadmap" || s.kind === "initiatives").map(([name, s]) => ({ name, listId: s.scope }));
+    const tasks = Object.values(plan.tasksById ?? {});
+    writeSliceFiles(
+      root,
+      plan.slice.name,
+      renderTeamIndex(plan.hierarchy, tasks, {
+        exportedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        relatedSlices,
+        initiativeItemId: opts.initiativeItemId
+      }),
+      { hierarchy: plan.hierarchy, taskIds: plan.tasks.map((t) => t.id) }
+    );
+  });
+}
+async function exportRoadmap(config, listId, opts) {
+  const teamId = requireTeam(config);
+  const client = makeClient(config, opts.rpm);
+  const plan = await discoverListTasks(client, teamId, listId, { kind: "roadmap" });
+  return execute(client, teamId, plan, opts, async (root) => {
+    const tasks = Object.values(plan.tasksById ?? {});
+    writeSliceFiles(
+      root,
+      plan.slice.name,
+      renderRoadmapIndex(plan.list, tasks, {
+        exportedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        initiativeItemId: opts.initiativeItemId
+      }),
+      {
+        list: plan.list,
+        initiativeItemId: opts.initiativeItemId ?? null,
+        taskIds: plan.tasks.map((t) => t.id)
+      }
+    );
+  });
+}
+async function exportInitiatives(config, listId, opts) {
+  const teamId = requireTeam(config);
+  if (opts.initiativeItemId === void 0) {
+    throw new Error(
+      "initiatives export needs --item-id <n>: the custom_item_id your workspace uses for initiatives (see `cup task-types`)"
+    );
+  }
+  const client = makeClient(config, opts.rpm);
+  const plan = await discoverListTasks(client, teamId, listId, {
+    kind: "initiatives",
+    initiativeItemId: opts.initiativeItemId
+  });
+  return execute(client, teamId, plan, opts, async (root) => {
+    const { readBundleData: readBundleData2 } = await import("./writer-EYKGCPNB.js");
+    const manifest = loadManifest(root);
+    const wanted = /* @__PURE__ */ new Set();
+    const queue = plan.tasks.map((t) => t.id);
+    while (queue.length > 0) {
+      const id = queue.pop();
+      if (wanted.has(id) || !manifest.tasks[id]) continue;
+      wanted.add(id);
+      const b = await readBundleData2(root, id);
+      queue.push(...b.subtaskIds);
+    }
+    const tasks = await Promise.all(
+      [...wanted].map((id) => readBundleData2(root, id).then((b) => b.task))
+    );
+    writeSliceFiles(
+      root,
+      plan.slice.name,
+      renderRoadmapIndex(plan.list, tasks, {
+        exportedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        initiativeItemId: opts.initiativeItemId
+      }),
+      {
+        list: plan.list,
+        initiativeItemId: opts.initiativeItemId,
+        taskIds: plan.tasks.map((t) => t.id)
+      }
+    );
+  });
+}
+async function exportDocs2(config, opts) {
+  const teamId = requireTeam(config);
+  const client = makeClient(config, opts.rpm);
+  const root = resolve(opts.out);
+  if (opts.dryRun) {
+    const docs = await client.getAllDocs(teamId);
+    opts.log(`Plan [docs]: ${docs.length} docs`);
+    return {
+      slice: "docs",
+      out: root,
+      dryRun: true,
+      docs: docs.length,
+      pages: 0,
+      skipped: 0,
+      failed: []
+    };
+  }
+  const summary = await exportDocs(client, teamId, {
+    root,
+    refresh: opts.refresh,
+    log: opts.log
+  });
+  writeRootReadme(root, loadManifest(root));
+  return { slice: "docs", out: root, dryRun: false, ...summary };
+}
+function formatDocsSummary(s) {
+  if (s.dryRun) return `Dry run: ${s.docs} docs would be exported to ${s.out}`;
+  const lines = [
+    `Exported docs to ${s.out}/docs`,
+    `  docs: ${s.docs} fetched (${s.pages} pages), ${s.skipped} already present, ${s.failed.length} failed`
+  ];
+  for (const f of s.failed.slice(0, 10)) lines.push(`  failed ${f.id}: ${f.error}`);
+  return lines.join("\n");
+}
+var REQUESTS_PER_TASK = 3;
+async function exportAll(config, opts) {
+  const teamId = requireTeam(config);
+  const client = makeClient(config, opts.rpm);
+  const root = resolve(opts.out);
+  const [spaces, docs, teams] = await Promise.all([
+    client.getSpaces(teamId),
+    client.getAllDocs(teamId),
+    client.getTeams()
+  ]);
+  const workspaceName = teams.find((t) => t.id === teamId)?.name ?? teamId;
+  const plans = [];
+  for (const space of spaces) plans.push(await discoverTeamTasks(client, teamId, space.id));
+  const manifest = loadManifest(root);
+  const allTaskIds = new Set(plans.flatMap((p) => p.tasks.map((t) => t.id)));
+  const alreadyExported = [...allTaskIds].filter((id) => manifest.tasks[id]).length;
+  const toFetch = allTaskIds.size - alreadyExported;
+  const listCount = plans.reduce(
+    (n, p) => n + (p.hierarchy?.lists.length ?? 0) + (p.hierarchy?.folders.reduce((m, f) => m + f.lists.length, 0) ?? 0),
+    0
+  );
+  const estRequests = toFetch * REQUESTS_PER_TASK + docs.length;
+  const estMinutes = Math.ceil(estRequests / opts.rpm);
+  opts.log(`Workspace export plan for "${workspaceName}":`);
+  opts.log(
+    `  ${spaces.length} spaces, ${listCount} lists, ${allTaskIds.size} tasks, ${docs.length} docs`
+  );
+  opts.log(`  Already exported: ${alreadyExported} tasks (will be skipped)`);
+  opts.log(`  Estimated requests: ~${estRequests}`);
+  opts.log(
+    `  Estimated time at ${opts.rpm} req/min: ~${estMinutes < 60 ? `${estMinutes}m` : `${Math.floor(estMinutes / 60)}h ${estMinutes % 60}m`}`
+  );
+  if (opts.attachments) opts.log("  Attachments: downloaded (size unknown until fetched)");
+  const empty = {
+    slice: "all",
+    out: root,
+    dryRun: opts.dryRun,
+    spaces: plans.map((p) => p.slice.name),
+    planned: allTaskIds.size,
+    fetched: 0,
+    skipped: 0,
+    failed: [],
+    attachmentsDownloaded: 0,
+    attachmentsFailed: 0,
+    docs: { docs: docs.length, pages: 0, skipped: 0, failed: [] }
+  };
+  if (opts.dryRun) return empty;
+  if (!opts.yes) {
+    if (!isTTY()) {
+      throw new Error(
+        "This is a long-running operation. Re-run with --yes to confirm in non-interactive mode."
+      );
+    }
+    const { confirm: confirm3 } = await import("@inquirer/prompts");
+    const ok = await confirm3({
+      message: `Export the whole workspace to ${root}?`,
+      default: false
+    });
+    if (!ok) throw new Error("Cancelled");
+  }
+  const spaceNames = Object.fromEntries(spaces.map((s) => [s.id, s.name]));
+  const summary = { ...empty };
+  for (const plan of plans) {
+    const run2 = await runExport(client, plan, {
+      root,
+      refresh: opts.refresh,
+      downloadAttachments: opts.attachments,
+      concurrency: CONCURRENCY,
+      log: opts.log,
+      spaceNames
+    });
+    summary.fetched += run2.fetched;
+    summary.skipped += run2.skipped;
+    summary.failed.push(...run2.failed);
+    summary.attachmentsDownloaded += run2.attachmentsDownloaded;
+    summary.attachmentsFailed += run2.attachmentsFailed;
+    const tasks = Object.values(plan.tasksById ?? {});
+    writeSliceFiles(
+      root,
+      plan.slice.name,
+      renderTeamIndex(plan.hierarchy, tasks, {
+        exportedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        initiativeItemId: opts.initiativeItemId
+      }),
+      { hierarchy: plan.hierarchy, taskIds: plan.tasks.map((t) => t.id) }
+    );
+  }
+  summary.docs = await exportDocs(client, teamId, { root, refresh: opts.refresh, log: opts.log });
+  writeRootReadme(root, loadManifest(root));
+  return summary;
+}
+function formatAllSummary(s) {
+  if (s.dryRun)
+    return `Dry run: ${s.planned} tasks across ${s.spaces.length} spaces would be exported to ${s.out}`;
+  const lines = [
+    `Exported workspace to ${s.out}`,
+    `  spaces: ${s.spaces.length} (${s.spaces.join(", ")})`,
+    `  tasks: ${s.fetched} fetched, ${s.skipped} already present, ${s.failed.length} failed`,
+    `  attachments: ${s.attachmentsDownloaded} downloaded, ${s.attachmentsFailed} failed`,
+    `  docs: ${s.docs.docs} fetched (${s.docs.pages} pages), ${s.docs.skipped} already present, ${s.docs.failed.length} failed`
+  ];
+  for (const f of s.failed.slice(0, 10)) lines.push(`  failed ${f.id}: ${f.error}`);
+  if (s.failed.length > 10) lines.push(`  ... and ${s.failed.length - 10} more`);
+  return lines.join("\n");
+}
+
 // src/commands/docs.ts
 var DOC_COLUMNS = [
   { key: "id", label: "ID", maxWidth: 15 },
@@ -7606,28 +8716,6 @@ function formatFieldsMarkdown(fields) {
   }).join("\n");
 }
 
-// src/util/batch.ts
-async function runInBatches(items, concurrency, fn) {
-  if (!Number.isInteger(concurrency) || concurrency < 1) {
-    throw new Error(`concurrency must be a positive integer, got ${concurrency}`);
-  }
-  const results = [];
-  for (let i = 0; i < items.length; i += concurrency) {
-    const batch = items.slice(i, i + concurrency);
-    const settled = await Promise.allSettled(batch.map(fn));
-    settled.forEach((res, idx) => {
-      const item = batch[idx];
-      if (res.status === "fulfilled") {
-        results.push({ item, ok: true, result: res.value });
-      } else {
-        const error = res.reason instanceof Error ? res.reason : new Error(String(res.reason), { cause: res.reason });
-        results.push({ item, ok: false, error });
-      }
-    });
-  }
-  return results;
-}
-
 // src/commands/field-create.ts
 var FIELD_CREATE_CONCURRENCY = 5;
 var VALID_FIELD_TYPES = [
@@ -8744,10 +9832,10 @@ function resolveRequiredMessage(opts) {
 }
 async function resolveMentions(client, teamId, mentions) {
   if (mentions.length === 0) return [];
-  const resolve2 = createCachedMemberResolver(client, teamId);
+  const resolve3 = createCachedMemberResolver(client, teamId);
   const ids = [];
   for (const mention of mentions) {
-    ids.push(await resolve2(mention));
+    ids.push(await resolve3(mention));
   }
   return ids;
 }
@@ -9040,6 +10128,120 @@ function buildProgram(programName = basename(process.argv[1] ?? "cup")) {
       }
     )
   );
+  const exportCmd = program.command("export").description("Export tasks and docs to a local archive (lossless JSON + rendered markdown)");
+  function withExportOptions(cmd) {
+    return cmd.option(
+      "--out <dir>",
+      "Archive directory (slices compose into the same dir)",
+      "./clickup-export"
+    ).option("--refresh", "Re-fetch tasks already present in the archive").option("--no-attachments", "Skip downloading attachment binaries (metadata still written)").option("--dry-run", "Discover and print the plan without fetching or writing").option("--rpm <n>", "Request throttle per minute (ClickUp Business limit is 100)", "90").option("--yes", "Skip confirmation prompts (required for non-interactive `export all`)").option(
+      "--item-id <n>",
+      "custom_item_id that marks an initiative in your workspace (see `cup task-types`)"
+    ).option("--json", "Force JSON output even in terminal");
+  }
+  function toExportOptions(opts) {
+    const rpm = Number(opts.rpm);
+    if (!Number.isFinite(rpm) || rpm <= 0) throw new Error("--rpm must be a positive number");
+    let initiativeItemId;
+    if (opts.itemId !== void 0) {
+      initiativeItemId = Number(opts.itemId);
+      if (!Number.isInteger(initiativeItemId) || initiativeItemId <= 0) {
+        throw new Error("--item-id must be a positive integer");
+      }
+    }
+    return {
+      out: opts.out,
+      refresh: opts.refresh ?? false,
+      attachments: opts.attachments,
+      dryRun: opts.dryRun ?? false,
+      rpm,
+      log: (line) => process.stderr.write(line + "\n"),
+      ...initiativeItemId !== void 0 ? { initiativeItemId } : {},
+      yes: opts.yes ?? false
+    };
+  }
+  function printExportSummary(summary, json) {
+    if (shouldOutputJson(json)) {
+      console.log(JSON.stringify(summary, null, 2));
+    } else {
+      console.log(formatExportSummary(summary));
+    }
+    if (summary.failed.length > 0) process.exitCode = 1;
+  }
+  withExportOptions(
+    exportCmd.command("user <userRef>").description(
+      "Export every task assigned to a user (me, id, email, or username), incl. closed and archived"
+    )
+  ).action(
+    wrapAction(async (userRef, opts) => {
+      const config = loadConfig(getProfileName());
+      const summary = await exportUser(config, userRef, toExportOptions(opts));
+      printExportSummary(summary, opts.json ?? false);
+    })
+  );
+  withExportOptions(
+    exportCmd.command("team <spaceRef>").description("Export every list in a space (by id or name), incl. archived lists and tasks")
+  ).action(
+    wrapAction(async (spaceRef, opts) => {
+      const config = loadConfig(getProfileName());
+      const summary = await exportTeam(config, spaceRef, toExportOptions(opts));
+      printExportSummary(summary, opts.json ?? false);
+    })
+  );
+  withExportOptions(
+    exportCmd.command("roadmap <listId>").description(
+      "Export a list with initiatives grouped and their subtask trees (use --item-id)"
+    )
+  ).action(
+    wrapAction(async (listId, opts) => {
+      const config = loadConfig(getProfileName());
+      const summary = await exportRoadmap(config, listId, toExportOptions(opts));
+      printExportSummary(summary, opts.json ?? false);
+    })
+  );
+  withExportOptions(
+    exportCmd.command("docs").description(
+      "Export every workspace doc as markdown page trees (ClickUp has no bulk doc export)"
+    )
+  ).action(
+    wrapAction(async (opts) => {
+      const config = loadConfig(getProfileName());
+      const summary = await exportDocs2(config, toExportOptions(opts));
+      if (shouldOutputJson(opts.json ?? false)) {
+        console.log(JSON.stringify(summary, null, 2));
+      } else {
+        console.log(formatDocsSummary(summary));
+      }
+      if (summary.failed.length > 0) process.exitCode = 1;
+    })
+  );
+  withExportOptions(
+    exportCmd.command("all").description(
+      "Export the whole workspace: every space as a team slice, plus all docs. Plans first and asks for confirmation"
+    )
+  ).action(
+    wrapAction(async (opts) => {
+      const config = loadConfig(getProfileName());
+      const summary = await exportAll(config, toExportOptions(opts));
+      if (shouldOutputJson(opts.json ?? false)) {
+        console.log(JSON.stringify(summary, null, 2));
+      } else {
+        console.log(formatAllSummary(summary));
+      }
+      if (summary.failed.length > 0 || summary.docs.failed.length > 0) process.exitCode = 1;
+    })
+  );
+  withExportOptions(
+    exportCmd.command("initiatives <listId>").description(
+      "Export only initiative-typed tasks in a list plus their subtask trees (requires --item-id)"
+    )
+  ).action(
+    wrapAction(async (listId, opts) => {
+      const config = loadConfig(getProfileName());
+      const summary = await exportInitiatives(config, listId, toExportOptions(opts));
+      printExportSummary(summary, opts.json ?? false);
+    })
+  );
   program.command("sprint").description("List my tasks in the current active sprint (auto-detected)").option("--status <status>", "Filter by status").option("--space <nameOrId>", "Narrow sprint search to a specific space (partial name or ID)").option("--folder <folderId>", "Sprint folder ID (overrides config and auto-detection)").option("--include-closed", "Include done/closed tasks").option("--json", "Force JSON output even in terminal").action(
     wrapAction(
       async (opts) => {
@@ -11216,7 +12418,7 @@ process.on("SIGINT", () => {
 });
 function checkDirectExecution() {
   try {
-    return process.argv[1] !== void 0 && fileURLToPath(import.meta.url) === realpathSync2(resolve(process.argv[1]));
+    return process.argv[1] !== void 0 && fileURLToPath(import.meta.url) === realpathSync2(resolve2(process.argv[1]));
   } catch {
     return false;
   }