@krodak/clickup-cli 0.6.0

package/dist/index.js

@@ -0,0 +1,1772 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command } from "commander";
+import { createRequire } from "module";
+
+// src/config.ts
+import fs from "fs";
+import { homedir } from "os";
+import { join } from "path";
+function configDir() {
+  const xdg = process.env.XDG_CONFIG_HOME;
+  if (xdg) return join(xdg, "cu");
+  return join(homedir(), ".config", "cu");
+}
+function configPath() {
+  return join(configDir(), "config.json");
+}
+function loadConfig() {
+  const envToken = process.env.CU_API_TOKEN?.trim();
+  const envTeamId = process.env.CU_TEAM_ID?.trim();
+  let fileToken;
+  let fileTeamId;
+  const path = configPath();
+  if (fs.existsSync(path)) {
+    const raw = fs.readFileSync(path, "utf-8");
+    let parsed;
+    try {
+      parsed = JSON.parse(raw);
+    } catch {
+      throw new Error(`Config file at ${path} contains invalid JSON. Please check the file syntax.`);
+    }
+    fileToken = parsed.apiToken?.trim();
+    fileTeamId = parsed.teamId?.trim();
+  }
+  const apiToken = envToken || fileToken;
+  if (!apiToken) {
+    throw new Error("Config missing required field: apiToken.\nSet CU_API_TOKEN or run: cu init");
+  }
+  if (!apiToken.startsWith("pk_")) {
+    throw new Error("Config apiToken must start with pk_. The configured token does not.");
+  }
+  const teamId = envTeamId || fileTeamId;
+  if (!teamId) {
+    throw new Error("Config missing required field: teamId.\nSet CU_TEAM_ID or run: cu init");
+  }
+  return { apiToken, teamId };
+}
+function loadRawConfig() {
+  const path = configPath();
+  if (!fs.existsSync(path)) return {};
+  try {
+    return JSON.parse(fs.readFileSync(path, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+function getConfigPath() {
+  return configPath();
+}
+function writeConfig(config) {
+  const dir = configDir();
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+  fs.writeFileSync(join(dir, "config.json"), JSON.stringify(config, null, 2) + "\n", "utf-8");
+}
+
+// src/api.ts
+var BASE_URL = "https://api.clickup.com/api/v2";
+var MAX_PAGES = 100;
+var ClickUpClient = class {
+  apiToken;
+  meCache = null;
+  constructor(config) {
+    this.apiToken = config.apiToken;
+  }
+  async request(path, options = {}) {
+    const res = await fetch(`${BASE_URL}${path}`, {
+      ...options,
+      signal: AbortSignal.timeout(3e4),
+      headers: {
+        Authorization: this.apiToken,
+        ...options.body ? { "Content-Type": "application/json" } : {},
+        ...options.headers
+      }
+    });
+    let data;
+    try {
+      data = await res.json();
+    } catch {
+      throw new Error(`ClickUp API error ${res.status}: response was not valid JSON`);
+    }
+    if (!res.ok) {
+      const raw = data.err ?? data.error ?? data.ECODE ?? res.statusText;
+      const errMsg = typeof raw === "string" ? raw : JSON.stringify(raw);
+      throw new Error(`ClickUp API error ${res.status}: ${errMsg}`);
+    }
+    return data;
+  }
+  async getMe() {
+    if (this.meCache) return this.meCache;
+    const data = await this.request("/user");
+    this.meCache = data.user;
+    return data.user;
+  }
+  async paginate(buildPath) {
+    const allTasks = [];
+    let page = 0;
+    let lastPage = false;
+    while (!lastPage && page < MAX_PAGES) {
+      const data = await this.request(buildPath(page));
+      const tasks = data.tasks;
+      if (!Array.isArray(tasks)) {
+        throw new Error(`Unexpected API response: expected tasks array, got ${typeof tasks}`);
+      }
+      allTasks.push(...tasks);
+      lastPage = data.last_page ?? true;
+      page++;
+    }
+    if (page >= MAX_PAGES && !lastPage) {
+      process.stderr.write(
+        `Warning: reached maximum page limit (${MAX_PAGES}), results may be incomplete
+`
+      );
+    }
+    return allTasks;
+  }
+  async getMyTasks(teamId, filters = {}) {
+    const me = await this.getMe();
+    const baseParams = new URLSearchParams({
+      subtasks: String(filters.subtasks ?? true)
+    });
+    baseParams.append("assignees[]", String(me.id));
+    for (const s of filters.statuses ?? []) baseParams.append("statuses[]", s);
+    for (const id of filters.listIds ?? []) baseParams.append("list_ids[]", id);
+    for (const id of filters.spaceIds ?? []) baseParams.append("space_ids[]", id);
+    return this.paginate((page) => {
+      const params = new URLSearchParams(baseParams);
+      params.set("page", String(page));
+      return `/team/${teamId}/task?${params.toString()}`;
+    });
+  }
+  async updateTask(taskId, options) {
+    return this.request(`/task/${taskId}`, {
+      method: "PUT",
+      body: JSON.stringify(options)
+    });
+  }
+  async postComment(taskId, commentText) {
+    return this.request(`/task/${taskId}/comment`, {
+      method: "POST",
+      body: JSON.stringify({ comment_text: commentText })
+    });
+  }
+  async getTaskComments(taskId) {
+    const data = await this.request(`/task/${taskId}/comment`);
+    return data.comments ?? [];
+  }
+  async getTasksFromList(listId, params = {}) {
+    return this.paginate((page) => {
+      const qs = new URLSearchParams({ subtasks: "true", page: String(page), ...params }).toString();
+      return `/list/${listId}/task?${qs}`;
+    });
+  }
+  async getMyTasksFromList(listId) {
+    const me = await this.getMe();
+    return this.getTasksFromList(listId, { "assignees[]": String(me.id) });
+  }
+  async getTask(taskId) {
+    return this.request(`/task/${taskId}`);
+  }
+  async updateTaskDescription(taskId, description) {
+    return this.updateTask(taskId, { description });
+  }
+  async createTask(listId, options) {
+    return this.request(`/list/${listId}/task`, {
+      method: "POST",
+      body: JSON.stringify(options)
+    });
+  }
+  async getAssignedListIds(teamId) {
+    const tasks = await this.getMyTasks(teamId);
+    return new Set(tasks.map((t) => t.list.id));
+  }
+  async getTeams() {
+    const data = await this.request("/team");
+    return data.teams ?? [];
+  }
+  async getSpaces(teamId) {
+    const data = await this.request(`/team/${teamId}/space?archived=false`);
+    return data.spaces ?? [];
+  }
+  async getLists(spaceId) {
+    const data = await this.request(`/space/${spaceId}/list?archived=false`);
+    return data.lists ?? [];
+  }
+  async getFolders(spaceId) {
+    const data = await this.request(
+      `/space/${spaceId}/folder?archived=false`
+    );
+    return data.folders ?? [];
+  }
+  async getFolderLists(folderId) {
+    const data = await this.request(`/folder/${folderId}/list?archived=false`);
+    return data.lists ?? [];
+  }
+  async getListViews(listId) {
+    return this.request(
+      `/list/${listId}/view`
+    );
+  }
+  async getViewTasks(viewId) {
+    return this.paginate((page) => `/view/${viewId}/task?page=${page}`);
+  }
+};
+
+// src/output.ts
+import chalk from "chalk";
+function isTTY() {
+  return Boolean(process.stdout.isTTY);
+}
+function cell(value, width) {
+  if (value.length > width) return value.slice(0, width - 1) + "\u2026";
+  return value.padEnd(width);
+}
+function computeWidths(rows, columns) {
+  return columns.map((col) => {
+    const headerLen = col.label.length;
+    const maxDataLen = rows.reduce((max, row) => {
+      const val = String(row[col.key] ?? "");
+      return Math.max(max, val.length);
+    }, 0);
+    const natural = Math.max(headerLen, maxDataLen);
+    return col.maxWidth ? Math.min(natural, col.maxWidth) : natural;
+  });
+}
+function formatTable(rows, columns) {
+  const widths = computeWidths(rows, columns);
+  const header = columns.map((c, i) => cell(c.label, widths[i])).join("  ");
+  const divider = "-".repeat(header.replace(/\x1b\[[0-9;]*m/g, "").length);
+  const lines = [chalk.bold(header), divider];
+  for (const row of rows) {
+    lines.push(columns.map((c, i) => cell(String(row[c.key] ?? ""), widths[i])).join("  "));
+  }
+  return lines.join("\n");
+}
+var TASK_COLUMNS = [
+  { key: "id", label: "ID" },
+  { key: "name", label: "NAME", maxWidth: 60 },
+  { key: "status", label: "STATUS" },
+  { key: "list", label: "LIST" }
+];
+
+// src/interactive.ts
+import { execFileSync } from "child_process";
+import { checkbox, confirm, Separator } from "@inquirer/prompts";
+import chalk2 from "chalk";
+function openUrl(url) {
+  switch (process.platform) {
+    case "darwin":
+      execFileSync("open", [url]);
+      break;
+    case "linux":
+      execFileSync("xdg-open", [url]);
+      break;
+    case "win32":
+      execFileSync("cmd", ["/c", "start", "", url]);
+      break;
+    default:
+      process.stderr.write(`Cannot open browser on ${process.platform}. Visit: ${url}
+`);
+  }
+}
+function formatMs(ms) {
+  const hours = Math.floor(ms / 36e5);
+  const mins = Math.floor(ms % 36e5 / 6e4);
+  if (hours > 0 && mins > 0) return `${hours}h ${mins}m`;
+  if (hours > 0) return `${hours}h`;
+  return `${mins}m`;
+}
+function formatTimestamp(ts) {
+  return new Date(Number(ts)).toLocaleDateString("en-US", {
+    month: "short",
+    day: "numeric",
+    year: "numeric"
+  });
+}
+function descriptionPreview(text, maxLines = 3) {
+  const lines = text.split("\n").filter((l) => l.trim().length > 0);
+  const preview = lines.slice(0, maxLines);
+  const result = preview.map((l) => `  ${chalk2.dim(l.length > 100 ? l.slice(0, 99) + "\u2026" : l)}`).join("\n");
+  if (lines.length > maxLines)
+    return result + `
+  ${chalk2.dim(`... (${lines.length - maxLines} more lines)`)}`;
+  return result;
+}
+function formatTaskDetail(task) {
+  const lines = [];
+  const isInitiative2 = (task.custom_item_id ?? 0) !== 0;
+  const typeLabel = isInitiative2 ? "initiative" : "task";
+  lines.push(chalk2.bold.underline(task.name));
+  lines.push("");
+  const fields = [
+    ["ID", task.id],
+    ["Status", task.status?.status],
+    ["Type", typeLabel],
+    ["List", task.list?.name],
+    [
+      "Assignees",
+      task.assignees?.length ? task.assignees.map((a) => a.username).join(", ") : void 0
+    ],
+    ["Priority", task.priority?.priority],
+    ["Start", task.start_date ? formatTimestamp(task.start_date) : void 0],
+    ["Due", task.due_date ? formatTimestamp(task.due_date) : void 0],
+    ["Estimate", task.time_estimate ? formatMs(task.time_estimate) : void 0],
+    ["Tracked", task.time_spent ? formatMs(task.time_spent) : void 0],
+    ["Tags", task.tags?.length ? task.tags.map((t) => t.name).join(", ") : void 0],
+    ["Parent", task.parent || void 0],
+    ["URL", task.url]
+  ];
+  const maxLabel = Math.max(...fields.filter(([, v]) => v).map(([k]) => k.length));
+  for (const [label, value] of fields) {
+    if (!value) continue;
+    lines.push(`  ${chalk2.bold(label.padEnd(maxLabel + 1))} ${value}`);
+  }
+  if (task.text_content?.trim()) {
+    lines.push("");
+    lines.push(descriptionPreview(task.text_content));
+  }
+  return lines.join("\n");
+}
+function formatChoiceName(task) {
+  const id = task.id.padEnd(12);
+  const name = task.name.length > 50 ? task.name.slice(0, 49) + "\u2026" : task.name.padEnd(50);
+  const status = task.status;
+  return `${id}  ${name}  ${chalk2.dim(status)}`;
+}
+async function interactiveTaskPicker(tasks) {
+  if (tasks.length === 0) return [];
+  const selected = await checkbox({
+    message: `${tasks.length} task(s) found. Select to view details / open in browser:`,
+    choices: tasks.map((t) => ({
+      name: formatChoiceName(t),
+      value: t.id
+    })),
+    pageSize: 20
+  });
+  return tasks.filter((t) => selected.includes(t.id));
+}
+async function groupedTaskPicker(groups) {
+  const allTasks = groups.flatMap((g) => g.tasks);
+  const totalCount = allTasks.length;
+  if (totalCount === 0) return [];
+  const choices = [];
+  for (const group of groups) {
+    if (group.tasks.length === 0) continue;
+    choices.push(new Separator(chalk2.bold(`${group.label} (${group.tasks.length})`)));
+    for (const task of group.tasks) {
+      choices.push({ name: formatChoiceName(task), value: task.id });
+    }
+  }
+  const selected = await checkbox({
+    message: `${totalCount} task(s) found. Select to view details / open in browser:`,
+    choices,
+    pageSize: 20
+  });
+  return allTasks.filter((t) => selected.includes(t.id));
+}
+async function showDetailsAndOpen(tasks, fetchTask) {
+  if (tasks.length === 0) return;
+  const separator = chalk2.dim("\u2500".repeat(60));
+  for (let i = 0; i < tasks.length; i++) {
+    const task = tasks[i];
+    if (i > 0) {
+      console.log("");
+      console.log(separator);
+    }
+    console.log("");
+    if (fetchTask) {
+      const full = await fetchTask(task.id);
+      console.log(formatTaskDetail(full));
+    } else {
+      const fallback = {
+        id: task.id,
+        name: task.name,
+        status: { status: task.status, color: "" },
+        custom_item_id: task.task_type === "initiative" ? 1 : 0,
+        assignees: [],
+        url: task.url,
+        list: { id: "", name: task.list },
+        parent: task.parent
+      };
+      console.log(formatTaskDetail(fallback));
+    }
+  }
+  const urls = tasks.map((t) => t.url);
+  console.log("");
+  const shouldOpen = await confirm({
+    message: `Open ${urls.length} task(s) in browser?`,
+    default: true
+  });
+  if (shouldOpen) {
+    for (const url of urls) {
+      openUrl(url);
+    }
+  }
+}
+
+// src/commands/tasks.ts
+var DONE_PATTERNS = ["done", "complete", "closed"];
+function isDoneStatus(status) {
+  const lower = status.toLowerCase();
+  return DONE_PATTERNS.some((p) => lower.includes(p));
+}
+function isInitiative(task) {
+  return (task.custom_item_id ?? 0) !== 0;
+}
+function summarize(task) {
+  return {
+    id: task.id,
+    name: task.name,
+    status: task.status.status,
+    task_type: isInitiative(task) ? "initiative" : "task",
+    list: task.list.name,
+    url: task.url,
+    ...task.parent ? { parent: task.parent } : {}
+  };
+}
+async function fetchMyTasks(config, opts = {}) {
+  const client = new ClickUpClient(config);
+  const { typeFilter, name, ...apiFilters } = opts;
+  const allTasks = await client.getMyTasks(config.teamId, apiFilters);
+  let filtered = typeFilter === "initiative" ? allTasks.filter(isInitiative) : typeFilter === "task" ? allTasks.filter((t) => !isInitiative(t)) : allTasks;
+  if (name) {
+    const query = name.toLowerCase();
+    filtered = filtered.filter((t) => t.name.toLowerCase().includes(query));
+  }
+  return filtered.map(summarize);
+}
+async function printTasks(tasks, forceJson, config) {
+  if (forceJson || !isTTY()) {
+    console.log(JSON.stringify(tasks, null, 2));
+    return;
+  }
+  if (tasks.length === 0) {
+    console.log("No tasks found.");
+    return;
+  }
+  const fetchTask = config ? (() => {
+    const client = new ClickUpClient(config);
+    return (id) => client.getTask(id);
+  })() : void 0;
+  const selected = await interactiveTaskPicker(tasks);
+  await showDetailsAndOpen(selected, fetchTask);
+}
+
+// src/commands/update.ts
+var PRIORITY_MAP = {
+  urgent: 1,
+  high: 2,
+  normal: 3,
+  low: 4
+};
+function parsePriority(value) {
+  const named = PRIORITY_MAP[value.toLowerCase()];
+  if (named !== void 0) return named;
+  const num = Number(value);
+  if (Number.isInteger(num) && num >= 1 && num <= 4) return num;
+  throw new Error("Priority must be urgent, high, normal, low, or 1-4");
+}
+function parseDueDate(value) {
+  if (!/^\d{4}-\d{2}-\d{2}$/.test(value)) {
+    throw new Error("Date must be in YYYY-MM-DD format");
+  }
+  const date = new Date(value);
+  if (isNaN(date.getTime())) throw new Error(`Invalid date: ${value}`);
+  return date.getTime();
+}
+function parseAssigneeId(value) {
+  const id = Number(value);
+  if (!Number.isInteger(id)) throw new Error("Assignee must be a numeric user ID");
+  return id;
+}
+function buildUpdatePayload(opts) {
+  const payload = {};
+  if (opts.name !== void 0) payload.name = opts.name;
+  if (opts.description !== void 0) payload.description = opts.description;
+  if (opts.status !== void 0) payload.status = opts.status;
+  if (opts.priority !== void 0) payload.priority = parsePriority(opts.priority);
+  if (opts.dueDate !== void 0) {
+    payload.due_date = parseDueDate(opts.dueDate);
+    payload.due_date_time = false;
+  }
+  if (opts.assignee !== void 0) {
+    payload.assignees = { add: [parseAssigneeId(opts.assignee)] };
+  }
+  return payload;
+}
+function hasUpdateFields(options) {
+  return options.name !== void 0 || options.description !== void 0 || options.status !== void 0 || options.priority !== void 0 || options.due_date !== void 0 || options.assignees !== void 0;
+}
+async function updateTask(config, taskId, options) {
+  if (!hasUpdateFields(options))
+    throw new Error(
+      "Provide at least one of: --name, --description, --status, --priority, --due-date, --assignee"
+    );
+  const client = new ClickUpClient(config);
+  const task = await client.updateTask(taskId, options);
+  return { id: task.id, name: task.name };
+}
+
+// src/commands/create.ts
+async function createTask(config, options) {
+  const client = new ClickUpClient(config);
+  let listId = options.list;
+  if (!listId && options.parent) {
+    const parentTask = await client.getTask(options.parent);
+    listId = parentTask.list.id;
+  }
+  if (!listId) {
+    throw new Error("Provide --list or --parent (list is auto-detected from parent task)");
+  }
+  const payload = {
+    name: options.name,
+    ...options.description !== void 0 ? { description: options.description } : {},
+    ...options.parent !== void 0 ? { parent: options.parent } : {},
+    ...options.status !== void 0 ? { status: options.status } : {}
+  };
+  if (options.priority !== void 0) {
+    payload.priority = parsePriority(options.priority);
+  }
+  if (options.dueDate !== void 0) {
+    payload.due_date = parseDueDate(options.dueDate);
+    payload.due_date_time = false;
+  }
+  if (options.assignee !== void 0) {
+    payload.assignees = [parseAssigneeId(options.assignee)];
+  }
+  if (options.tags !== void 0) {
+    payload.tags = options.tags.split(",").map((t) => t.trim());
+  }
+  const task = await client.createTask(listId, payload);
+  return { id: task.id, name: task.name, url: task.url };
+}
+
+// src/commands/get.ts
+async function getTask(config, taskId) {
+  const client = new ClickUpClient(config);
+  return client.getTask(taskId);
+}
+
+// src/commands/init.ts
+import { password, select, confirm as confirm2 } from "@inquirer/prompts";
+import fs2 from "fs";
+async function runInitCommand() {
+  const configPath3 = getConfigPath();
+  if (fs2.existsSync(configPath3)) {
+    const overwrite = await confirm2({
+      message: `Config already exists at ${configPath3}. Overwrite?`,
+      default: false
+    });
+    if (!overwrite) {
+      process.stdout.write("Aborted.\n");
+      return;
+    }
+  }
+  const apiToken = (await password({ message: "ClickUp API token (pk_...):" })).trim();
+  if (!apiToken.startsWith("pk_")) throw new Error("Token must start with pk_");
+  const client = new ClickUpClient({ apiToken });
+  let username;
+  try {
+    const me = await client.getMe();
+    username = me.username;
+  } catch (err) {
+    throw new Error(`Invalid token: ${err instanceof Error ? err.message : String(err)}`, {
+      cause: err
+    });
+  }
+  process.stdout.write(`Authenticated as @${username}
+`);
+  const teams = await client.getTeams();
+  if (teams.length === 0) throw new Error("No workspaces found for this token.");
+  let teamId;
+  if (teams.length === 1) {
+    const [team] = teams;
+    if (!team) throw new Error("No workspaces found for this token.");
+    teamId = team.id;
+    process.stdout.write(`Workspace: ${team.name}
+`);
+  } else {
+    teamId = await select({
+      message: "Select workspace:",
+      choices: teams.map((t) => ({ name: t.name, value: t.id }))
+    });
+  }
+  writeConfig({ apiToken, teamId });
+  process.stdout.write(`Config written to ${configPath3}
+`);
+}
+
+// src/commands/sprint.ts
+function parseSprintDates(name) {
+  const m = name.match(/\((\d{1,2})\/(\d{1,2})\s*[-–]\s*(\d{1,2})\/(\d{1,2})\)/);
+  if (!m) return null;
+  const year = (/* @__PURE__ */ new Date()).getFullYear();
+  const start = new Date(year, Number(m[1]) - 1, Number(m[2]));
+  const end = new Date(year, Number(m[3]) - 1, Number(m[4]), 23, 59, 59);
+  if (end < start) {
+    end.setFullYear(end.getFullYear() + 1);
+  }
+  return { start, end };
+}
+function findActiveSprintList(lists, today = /* @__PURE__ */ new Date()) {
+  if (lists.length === 0) return null;
+  for (const list of lists) {
+    const dates = parseSprintDates(list.name);
+    if (dates && today >= dates.start && today <= dates.end) {
+      return list;
+    }
+  }
+  return lists[lists.length - 1] ?? null;
+}
+var NOISE_WORDS = /* @__PURE__ */ new Set(["product", "team", "the", "and", "for", "test"]);
+function extractSpaceKeywords(spaceName) {
+  return spaceName.replace(/[^a-zA-Z0-9\s]/g, "").split(/\s+/).map((w) => w.toLowerCase()).filter((w) => w.length >= 3 && !NOISE_WORDS.has(w));
+}
+function findRelatedSpaces(mySpaceIds, allSpaces) {
+  const mySpaces = allSpaces.filter((s) => mySpaceIds.has(s.id));
+  const keywords = mySpaces.flatMap((s) => extractSpaceKeywords(s.name));
+  if (keywords.length === 0) return allSpaces;
+  return allSpaces.filter(
+    (s) => mySpaceIds.has(s.id) || keywords.some((kw) => s.name.toLowerCase().includes(kw))
+  );
+}
+async function runSprintCommand(config, opts) {
+  const client = new ClickUpClient(config);
+  process.stderr.write("Detecting active sprint...\n");
+  const [myTasks, allSpaces] = await Promise.all([
+    client.getMyTasks(config.teamId),
+    client.getSpaces(config.teamId)
+  ]);
+  let spaces;
+  if (opts.space) {
+    spaces = allSpaces.filter(
+      (s) => s.name.toLowerCase().includes(opts.space.toLowerCase()) || s.id === opts.space
+    );
+    if (spaces.length === 0) {
+      throw new Error(
+        `No space matching "${opts.space}" found. Use \`cu spaces\` to list available spaces.`
+      );
+    }
+  } else {
+    const mySpaceIds = new Set(
+      myTasks.map((t) => t.space?.id).filter((id) => Boolean(id))
+    );
+    spaces = findRelatedSpaces(mySpaceIds, allSpaces);
+  }
+  const foldersBySpace = await Promise.all(spaces.map((space) => client.getFolders(space.id)));
+  const sprintFolders = foldersBySpace.flat().filter((f) => f.name.toLowerCase().includes("sprint"));
+  const listsByFolder = await Promise.all(
+    sprintFolders.map((folder) => client.getFolderLists(folder.id))
+  );
+  const sprintLists = listsByFolder.flat();
+  const activeList = findActiveSprintList(sprintLists);
+  if (!activeList) {
+    throw new Error('No sprint list found. Ensure sprint folders contain "sprint" in their name.');
+  }
+  process.stderr.write(`Active sprint: ${activeList.name}
+`);
+  const me = await client.getMe();
+  const viewData = await client.getListViews(activeList.id);
+  const listView = viewData.required_views?.list;
+  let sprintTasks;
+  if (listView) {
+    const allViewTasks = await client.getViewTasks(listView.id);
+    sprintTasks = allViewTasks.filter((t) => t.assignees.some((a) => a.id === me.id));
+  } else {
+    sprintTasks = await client.getMyTasksFromList(activeList.id);
+  }
+  const filtered = opts.status ? sprintTasks.filter((t) => t.status.status.toLowerCase() === opts.status.toLowerCase()) : sprintTasks;
+  const summaries = filtered.map(summarize);
+  await printTasks(summaries, opts.json ?? false, config);
+}
+
+// src/commands/subtasks.ts
+async function fetchSubtasks(config, taskId) {
+  const client = new ClickUpClient(config);
+  const parent = await client.getTask(taskId);
+  const tasks = await client.getTasksFromList(parent.list.id, { parent: taskId, subtasks: "false" });
+  return tasks.map(summarize);
+}
+
+// src/commands/comment.ts
+async function postComment(config, taskId, text) {
+  if (!text.trim()) throw new Error("Comment text cannot be empty");
+  const client = new ClickUpClient(config);
+  return client.postComment(taskId, text);
+}
+
+// src/commands/comments.ts
+import chalk3 from "chalk";
+function formatDate(timestamp) {
+  return new Date(Number(timestamp)).toLocaleString("en-US", {
+    month: "short",
+    day: "numeric",
+    year: "numeric",
+    hour: "numeric",
+    minute: "2-digit"
+  });
+}
+async function fetchComments(config, taskId) {
+  const client = new ClickUpClient(config);
+  const comments = await client.getTaskComments(taskId);
+  return comments.map((c) => ({
+    id: c.id,
+    user: c.user.username,
+    date: c.date,
+    text: c.comment_text
+  }));
+}
+function printComments(comments, forceJson) {
+  if (forceJson || !isTTY()) {
+    console.log(JSON.stringify(comments, null, 2));
+    return;
+  }
+  if (comments.length === 0) {
+    console.log("No comments found.");
+    return;
+  }
+  const separator = chalk3.dim("-".repeat(60));
+  for (let i = 0; i < comments.length; i++) {
+    const c = comments[i];
+    if (i > 0) console.log(separator);
+    console.log(`${chalk3.bold(c.user)}  ${chalk3.dim(formatDate(c.date))}`);
+    console.log(c.text);
+    if (i < comments.length - 1) console.log("");
+  }
+}
+
+// src/commands/lists.ts
+async function fetchLists(config, spaceId, opts = {}) {
+  const client = new ClickUpClient(config);
+  const results = [];
+  const folderlessLists = await client.getLists(spaceId);
+  for (const list of folderlessLists) {
+    results.push({ id: list.id, name: list.name, folder: "(none)" });
+  }
+  const folders = await client.getFolders(spaceId);
+  const folderListArrays = await Promise.all(folders.map((f) => client.getFolderLists(f.id)));
+  for (let i = 0; i < folders.length; i++) {
+    const folder = folders[i];
+    for (const list of folderListArrays[i]) {
+      results.push({ id: list.id, name: list.name, folder: folder.name });
+    }
+  }
+  if (opts.name) {
+    const query = opts.name.toLowerCase();
+    return results.filter((l) => l.name.toLowerCase().includes(query));
+  }
+  return results;
+}
+function printLists(lists, forceJson) {
+  if (forceJson || !isTTY()) {
+    console.log(JSON.stringify(lists, null, 2));
+    return;
+  }
+  if (lists.length === 0) {
+    console.log("No lists found.");
+    return;
+  }
+  const table = formatTable(lists, [
+    { key: "id", label: "ID" },
+    { key: "name", label: "NAME", maxWidth: 50 },
+    { key: "folder", label: "FOLDER", maxWidth: 30 }
+  ]);
+  console.log(table);
+}
+
+// src/commands/inbox.ts
+var TIME_PERIODS = [
+  { key: "today", label: "Today" },
+  { key: "yesterday", label: "Yesterday" },
+  { key: "last_7_days", label: "Last 7 days" },
+  { key: "earlier_this_month", label: "Earlier this month" },
+  { key: "last_month", label: "Last month" },
+  { key: "older", label: "Older" }
+];
+function summarizeWithDate(task) {
+  return {
+    ...summarize(task),
+    date_updated: task.date_updated ?? "0"
+  };
+}
+function classifyTimePeriod(timestampMs, now) {
+  const todayStart = new Date(now);
+  todayStart.setHours(0, 0, 0, 0);
+  const yesterdayStart = new Date(todayStart);
+  yesterdayStart.setDate(yesterdayStart.getDate() - 1);
+  const sevenDaysAgo = new Date(todayStart);
+  sevenDaysAgo.setDate(sevenDaysAgo.getDate() - 6);
+  const thisMonthStart = new Date(todayStart.getFullYear(), todayStart.getMonth(), 1);
+  const lastMonthStart = new Date(todayStart.getFullYear(), todayStart.getMonth() - 1, 1);
+  if (timestampMs >= todayStart.getTime()) return "today";
+  if (timestampMs >= yesterdayStart.getTime()) return "yesterday";
+  if (timestampMs >= sevenDaysAgo.getTime()) return "last_7_days";
+  if (timestampMs >= thisMonthStart.getTime()) return "earlier_this_month";
+  if (timestampMs >= lastMonthStart.getTime()) return "last_month";
+  return "older";
+}
+function groupTasks(tasks, now) {
+  const groups = {
+    today: [],
+    yesterday: [],
+    last_7_days: [],
+    earlier_this_month: [],
+    last_month: [],
+    older: []
+  };
+  for (const task of tasks) {
+    const period = classifyTimePeriod(Number(task.date_updated), now);
+    groups[period].push(task);
+  }
+  return groups;
+}
+async function fetchInbox(config, days = 30) {
+  const client = new ClickUpClient(config);
+  const tasks = await client.getMyTasks(config.teamId, { subtasks: true });
+  const cutoff = Date.now() - days * 24 * 60 * 60 * 1e3;
+  return tasks.filter((t) => Number(t.date_updated ?? 0) > cutoff).sort((a, b) => Number(b.date_updated ?? 0) - Number(a.date_updated ?? 0)).map(summarizeWithDate);
+}
+async function printInbox(tasks, forceJson, config) {
+  const now = Date.now();
+  const groups = groupTasks(tasks, now);
+  if (forceJson || !isTTY()) {
+    const jsonGroups = {};
+    for (const { key } of TIME_PERIODS) {
+      if (groups[key].length > 0) {
+        jsonGroups[key] = groups[key];
+      }
+    }
+    console.log(JSON.stringify(jsonGroups, null, 2));
+    return;
+  }
+  if (tasks.length === 0) {
+    console.log("No recently updated tasks.");
+    return;
+  }
+  const pickerGroups = TIME_PERIODS.filter((def) => groups[def.key].length > 0).map((def) => ({
+    label: def.label,
+    tasks: groups[def.key]
+  }));
+  const fetchTask = config ? (() => {
+    const client = new ClickUpClient(config);
+    return (id) => client.getTask(id);
+  })() : void 0;
+  const selected = await groupedTaskPicker(pickerGroups);
+  await showDetailsAndOpen(selected, fetchTask);
+}
+
+// src/commands/spaces.ts
+async function listSpaces(config, opts) {
+  const client = new ClickUpClient(config);
+  let spaces = await client.getSpaces(config.teamId);
+  if (opts.name) {
+    const lower = opts.name.toLowerCase();
+    spaces = spaces.filter((s) => s.name.toLowerCase().includes(lower));
+  }
+  if (opts.my) {
+    const tasks = await client.getMyTasks(config.teamId);
+    const mySpaceIds = new Set(
+      tasks.map((t) => t.space?.id).filter((id) => Boolean(id))
+    );
+    spaces = spaces.filter((s) => mySpaceIds.has(s.id));
+  }
+  if (!opts.json && isTTY()) {
+    const table = formatTable(
+      spaces.map((s) => ({ id: s.id, name: s.name })),
+      [
+        { key: "id", label: "ID" },
+        { key: "name", label: "NAME" }
+      ]
+    );
+    console.log(table);
+  } else {
+    console.log(JSON.stringify(spaces, null, 2));
+  }
+}
+
+// src/commands/assigned.ts
+var CLOSED_STATUSES = /* @__PURE__ */ new Set(["done", "closed", "complete", "completed"]);
+var STATUS_ORDER = [
+  "code review",
+  "in review",
+  "review",
+  "in progress",
+  "to do",
+  "open",
+  "needs definition",
+  "backlog",
+  "blocked"
+];
+function toJsonTask(task, summary) {
+  return {
+    id: summary.id,
+    name: summary.name,
+    status: summary.status,
+    task_type: summary.task_type,
+    list: summary.list,
+    url: summary.url,
+    priority: task.priority?.priority ?? null,
+    due_date: task.due_date ?? null
+  };
+}
+function statusSortKey(status) {
+  const idx = STATUS_ORDER.indexOf(status.toLowerCase());
+  return idx === -1 ? STATUS_ORDER.length : idx;
+}
+function groupByStatus(tasks, includeClosed) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const task of tasks) {
+    const status = task.status.status;
+    const key = status.toLowerCase();
+    if (!includeClosed && CLOSED_STATUSES.has(key)) continue;
+    if (!groups.has(status)) {
+      groups.set(status, []);
+    }
+    groups.get(status).push(task);
+  }
+  return Array.from(groups.entries()).sort((a, b) => {
+    const aIsClosed = CLOSED_STATUSES.has(a[0].toLowerCase());
+    const bIsClosed = CLOSED_STATUSES.has(b[0].toLowerCase());
+    if (aIsClosed !== bIsClosed) return aIsClosed ? 1 : -1;
+    return statusSortKey(a[0]) - statusSortKey(b[0]);
+  }).map(([status, tasks2]) => ({ status, tasks: tasks2 }));
+}
+async function runAssignedCommand(config, opts) {
+  const client = new ClickUpClient(config);
+  const allTasks = await client.getMyTasks(config.teamId);
+  const groups = groupByStatus(allTasks, opts.includeClosed ?? false);
+  if (opts.json || !isTTY()) {
+    const result = {};
+    for (const group of groups) {
+      result[group.status.toLowerCase()] = group.tasks.map((t) => toJsonTask(t, summarize(t)));
+    }
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+  if (groups.length === 0) {
+    console.log("No tasks found.");
+    return;
+  }
+  const pickerGroups = groups.map((g) => ({
+    label: g.status.toUpperCase(),
+    tasks: g.tasks.map(summarize)
+  }));
+  const selected = await groupedTaskPicker(pickerGroups);
+  await showDetailsAndOpen(selected, (id) => client.getTask(id));
+}
+
+// src/commands/open.ts
+function looksLikeTaskId(query) {
+  return /^[a-z0-9]+$/i.test(query) && query.length <= 12;
+}
+async function openTask(config, query, opts = {}) {
+  const client = new ClickUpClient(config);
+  if (looksLikeTaskId(query)) {
+    let task;
+    try {
+      task = await client.getTask(query);
+    } catch {
+    }
+    if (task) {
+      if (opts.json) {
+        console.log(JSON.stringify(task, null, 2));
+      } else {
+        if (isTTY()) {
+          console.log(task.name);
+          console.log(task.url);
+        }
+        openUrl(task.url);
+      }
+      return task;
+    }
+  }
+  const tasks = await fetchMyTasks(config, { name: query });
+  if (tasks.length === 0) {
+    throw new Error(`No tasks found matching "${query}"`);
+  }
+  const first = tasks[0];
+  if (tasks.length > 1 && isTTY()) {
+    console.log(`Found ${tasks.length} matches:`);
+    for (const t of tasks) {
+      console.log(`  ${t.id}  ${t.name}`);
+    }
+    console.log("Opening first match...");
+  }
+  if (opts.json) {
+    const fullTask = await client.getTask(first.id);
+    console.log(JSON.stringify(fullTask, null, 2));
+    return fullTask;
+  }
+  if (isTTY()) {
+    console.log(first.name);
+    console.log(first.url);
+  }
+  openUrl(first.url);
+  return {
+    id: first.id,
+    name: first.name,
+    status: { status: first.status, color: "" },
+    assignees: [],
+    url: first.url,
+    list: { id: "", name: first.list },
+    ...first.parent ? { parent: first.parent } : {}
+  };
+}
+
+// src/commands/summary.ts
+var IN_PROGRESS_PATTERNS = ["in progress", "in review", "doing"];
+function isCompletedRecently(task, cutoff) {
+  if (!isDoneStatus(task.status.status)) return false;
+  const updated = Number(task.date_updated);
+  return !isNaN(updated) && updated >= cutoff;
+}
+function isInProgress(task) {
+  const status = task.status.status.toLowerCase();
+  return IN_PROGRESS_PATTERNS.some((p) => status.includes(p));
+}
+function isOverdue(task, now) {
+  if (!task.due_date) return false;
+  const due = Number(task.due_date);
+  return !isNaN(due) && due < now;
+}
+function categorizeTasks(tasks, hoursBack) {
+  const now = Date.now();
+  const cutoff = now - hoursBack * 60 * 60 * 1e3;
+  const completed = [];
+  const inProgress = [];
+  const overdue = [];
+  for (const task of tasks) {
+    const done = isDoneStatus(task.status.status);
+    if (done && isCompletedRecently(task, cutoff)) {
+      completed.push(summarize(task));
+    }
+    if (!done && isInProgress(task)) {
+      inProgress.push(summarize(task));
+    }
+    if (!done && isOverdue(task, now)) {
+      overdue.push(summarize(task));
+    }
+  }
+  return { completed, inProgress, overdue };
+}
+function printSection(label, tasks) {
+  console.log(`
+${label} (${tasks.length})`);
+  if (tasks.length === 0) {
+    console.log("  None");
+  } else {
+    console.log(formatTable(tasks, TASK_COLUMNS));
+  }
+}
+async function runSummaryCommand(config, opts) {
+  const client = new ClickUpClient(config);
+  const allTasks = await client.getMyTasks(config.teamId);
+  const result = categorizeTasks(allTasks, opts.hours);
+  if (opts.json || !isTTY()) {
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+  printSection("Completed Recently", result.completed);
+  printSection("In Progress", result.inProgress);
+  printSection("Overdue", result.overdue);
+}
+
+// src/commands/overdue.ts
+function isOverdue2(task, now) {
+  if (!task.due_date) return false;
+  return Number(task.due_date) < now;
+}
+async function fetchOverdueTasks(config) {
+  const client = new ClickUpClient(config);
+  const allTasks = await client.getMyTasks(config.teamId);
+  const now = Date.now();
+  return allTasks.filter((t) => isOverdue2(t, now) && !isDoneStatus(t.status.status)).sort((a, b) => Number(a.due_date) - Number(b.due_date)).map(summarize);
+}
+
+// src/commands/config.ts
+var VALID_KEYS = /* @__PURE__ */ new Set(["apiToken", "teamId"]);
+function assertValidKey(key) {
+  if (!VALID_KEYS.has(key)) {
+    throw new Error(`Unknown config key: ${key}. Valid keys: ${[...VALID_KEYS].join(", ")}`);
+  }
+}
+function getConfigValue(key) {
+  assertValidKey(key);
+  const raw = loadRawConfig();
+  const value = raw[key]?.trim();
+  return value || void 0;
+}
+function setConfigValue(key, value) {
+  assertValidKey(key);
+  if (key === "apiToken" && !value.startsWith("pk_")) {
+    throw new Error("apiToken must start with pk_");
+  }
+  if (key === "teamId" && value.trim() === "") {
+    throw new Error("teamId must be non-empty");
+  }
+  const raw = loadRawConfig();
+  const merged = {
+    apiToken: raw.apiToken ?? "",
+    teamId: raw.teamId ?? "",
+    ...{ [key]: value }
+  };
+  writeConfig(merged);
+}
+function configPath2() {
+  return getConfigPath();
+}
+
+// src/commands/assign.ts
+async function resolveUserId(client, value) {
+  if (value === "me") {
+    const user = await client.getMe();
+    return user.id;
+  }
+  return parseAssigneeId(value);
+}
+async function assignTask(config, taskId, opts) {
+  if (!opts.to && !opts.remove) {
+    throw new Error("Provide at least one of: --to, --remove");
+  }
+  const client = new ClickUpClient(config);
+  const add = [];
+  const rem = [];
+  if (opts.to) {
+    add.push(await resolveUserId(client, opts.to));
+  }
+  if (opts.remove) {
+    rem.push(await resolveUserId(client, opts.remove));
+  }
+  return client.updateTask(taskId, {
+    assignees: {
+      ...add.length > 0 ? { add } : {},
+      ...rem.length > 0 ? { rem } : {}
+    }
+  });
+}
+
+// src/commands/completion.ts
+function bashCompletion() {
+  return `_cu_completions() {
+  local cur prev words cword
+
+  if type _init_completion &>/dev/null; then
+    _init_completion || return
+  else
+    cur="\${COMP_WORDS[COMP_CWORD]}"
+    prev="\${COMP_WORDS[COMP_CWORD-1]}"
+    words=("\${COMP_WORDS[@]}")
+    cword=$COMP_CWORD
+  fi
+
+  local commands="init tasks initiatives task update create sprint subtasks comment comments lists spaces inbox assigned open summary overdue assign config completion"
+
+  if [[ $cword -eq 1 ]]; then
+    COMPREPLY=($(compgen -W "$commands --help --version" -- "$cur"))
+    return
+  fi
+
+  local cmd="\${words[1]}"
+
+  case "$prev" in
+    --priority)
+      COMPREPLY=($(compgen -W "urgent high normal low" -- "$cur"))
+      return
+      ;;
+    --status)
+      COMPREPLY=($(compgen -W 'open "in progress" "in review" done closed' -- "$cur"))
+      return
+      ;;
+  esac
+
+  case "$cmd" in
+    tasks|initiatives)
+      COMPREPLY=($(compgen -W "--status --list --space --name --json" -- "$cur"))
+      ;;
+    task)
+      COMPREPLY=($(compgen -W "--json" -- "$cur"))
+      ;;
+    update)
+      COMPREPLY=($(compgen -W "--name --description --status --priority --due-date --assignee" -- "$cur"))
+      ;;
+    create)
+      COMPREPLY=($(compgen -W "--list --name --description --parent --status --priority --due-date --assignee --tags" -- "$cur"))
+      ;;
+    sprint)
+      COMPREPLY=($(compgen -W "--status --space --json" -- "$cur"))
+      ;;
+    subtasks)
+      COMPREPLY=($(compgen -W "--json" -- "$cur"))
+      ;;
+    comment)
+      COMPREPLY=($(compgen -W "--message" -- "$cur"))
+      ;;
+    comments)
+      COMPREPLY=($(compgen -W "--json" -- "$cur"))
+      ;;
+    lists)
+      COMPREPLY=($(compgen -W "--name --json" -- "$cur"))
+      ;;
+    spaces)
+      COMPREPLY=($(compgen -W "--name --my --json" -- "$cur"))
+      ;;
+    inbox)
+      COMPREPLY=($(compgen -W "--json --days" -- "$cur"))
+      ;;
+    assigned)
+      COMPREPLY=($(compgen -W "--include-closed --json" -- "$cur"))
+      ;;
+    open)
+      COMPREPLY=($(compgen -W "--json" -- "$cur"))
+      ;;
+    summary)
+      COMPREPLY=($(compgen -W "--hours --json" -- "$cur"))
+      ;;
+    overdue)
+      COMPREPLY=($(compgen -W "--json" -- "$cur"))
+      ;;
+    assign)
+      COMPREPLY=($(compgen -W "--to --remove --json" -- "$cur"))
+      ;;
+    config)
+      if [[ $cword -eq 2 ]]; then
+        COMPREPLY=($(compgen -W "get set path" -- "$cur"))
+      elif [[ $cword -eq 3 ]]; then
+        local subcmd="\${words[2]}"
+        case "$subcmd" in
+          get|set)
+            COMPREPLY=($(compgen -W "apiToken teamId" -- "$cur"))
+            ;;
+        esac
+      fi
+      ;;
+    completion)
+      COMPREPLY=($(compgen -W "bash zsh fish" -- "$cur"))
+      ;;
+  esac
+}
+complete -F _cu_completions cu
+`;
+}
+function zshCompletion() {
+  return `#compdef cu
+
+_cu() {
+  local -a commands
+  commands=(
+    'init:Set up cu for the first time'
+    'tasks:List tasks assigned to me'
+    'initiatives:List initiatives assigned to me'
+    'task:Get task details'
+    'update:Update a task'
+    'create:Create a new task'
+    'sprint:List my tasks in the current active sprint'
+    'subtasks:List subtasks of a task or initiative'
+    'comment:Post a comment on a task'
+    'comments:List comments on a task'
+    'lists:List all lists in a space'
+    'spaces:List spaces in your workspace'
+    'inbox:Recently updated tasks grouped by time period'
+    'assigned:Show all tasks assigned to me'
+    'open:Open a task in the browser by ID or name'
+    'summary:Daily standup summary'
+    'overdue:List tasks that are past their due date'
+    'assign:Assign or unassign users from a task'
+    'config:Manage CLI configuration'
+    'completion:Output shell completion script'
+  )
+
+  _arguments -C \\
+    '(- *)--help[Show help]' \\
+    '(- *)--version[Show version]' \\
+    '1:command:->command' \\
+    '*::arg:->args'
+
+  case $state in
+    command)
+      _describe 'command' commands
+      ;;
+    args)
+      case $words[1] in
+        tasks|initiatives)
+          _arguments \\
+            '--status[Filter by status]:status:(open "in progress" "in review" done closed)' \\
+            '--list[Filter by list ID]:list_id:' \\
+            '--space[Filter by space ID]:space_id:' \\
+            '--name[Filter by name]:query:' \\
+            '--json[Force JSON output]'
+          ;;
+        task)
+          _arguments \\
+            '1:task_id:' \\
+            '--json[Force JSON output]'
+          ;;
+        update)
+          _arguments \\
+            '1:task_id:' \\
+            '(-n --name)'{-n,--name}'[New task name]:text:' \\
+            '(-d --description)'{-d,--description}'[New description]:text:' \\
+            '(-s --status)'{-s,--status}'[New status]:status:(open "in progress" "in review" done closed)' \\
+            '--priority[Priority level]:priority:(urgent high normal low)' \\
+            '--due-date[Due date]:date:' \\
+            '--assignee[Add assignee]:user_id:'
+          ;;
+        create)
+          _arguments \\
+            '(-l --list)'{-l,--list}'[Target list ID]:list_id:' \\
+            '(-n --name)'{-n,--name}'[Task name]:name:' \\
+            '(-d --description)'{-d,--description}'[Task description]:text:' \\
+            '(-p --parent)'{-p,--parent}'[Parent task ID]:task_id:' \\
+            '(-s --status)'{-s,--status}'[Initial status]:status:(open "in progress" "in review" done closed)' \\
+            '--priority[Priority level]:priority:(urgent high normal low)' \\
+            '--due-date[Due date]:date:' \\
+            '--assignee[Assignee user ID]:user_id:' \\
+            '--tags[Comma-separated tag names]:tags:'
+          ;;
+        sprint)
+          _arguments \\
+            '--status[Filter by status]:status:(open "in progress" "in review" done closed)' \\
+            '--space[Narrow sprint search to a space]:space:' \\
+            '--json[Force JSON output]'
+          ;;
+        subtasks)
+          _arguments \\
+            '1:task_id:' \\
+            '--json[Force JSON output]'
+          ;;
+        comment)
+          _arguments \\
+            '1:task_id:' \\
+            '(-m --message)'{-m,--message}'[Comment text]:text:'
+          ;;
+        comments)
+          _arguments \\
+            '1:task_id:' \\
+            '--json[Force JSON output]'
+          ;;
+        lists)
+          _arguments \\
+            '1:space_id:' \\
+            '--name[Filter by name]:query:' \\
+            '--json[Force JSON output]'
+          ;;
+        spaces)
+          _arguments \\
+            '--name[Filter spaces by name]:query:' \\
+            '--my[Show only spaces where I have assigned tasks]' \\
+            '--json[Force JSON output]'
+          ;;
+        inbox)
+          _arguments \\
+            '--json[Force JSON output]' \\
+            '--days[Lookback period in days]:days:'
+          ;;
+        assigned)
+          _arguments \\
+            '--include-closed[Include done/closed tasks]' \\
+            '--json[Force JSON output]'
+          ;;
+        open)
+          _arguments \\
+            '1:query:' \\
+            '--json[Output task JSON instead of opening]'
+          ;;
+        summary)
+          _arguments \\
+            '--hours[Completed-tasks lookback in hours]:hours:' \\
+            '--json[Force JSON output]'
+          ;;
+        overdue)
+          _arguments \\
+            '--json[Force JSON output]'
+          ;;
+        assign)
+          _arguments \\
+            '1:task_id:' \\
+            '--to[Add assignee]:user_id:' \\
+            '--remove[Remove assignee]:user_id:' \\
+            '--json[Force JSON output]'
+          ;;
+        config)
+          local -a config_cmds
+          config_cmds=(
+            'get:Print a config value'
+            'set:Set a config value'
+            'path:Print config file path'
+          )
+          _arguments -C \\
+            '1:config command:->config_cmd' \\
+            '*::config_arg:->config_args'
+          case $state in
+            config_cmd)
+              _describe 'config command' config_cmds
+              ;;
+            config_args)
+              case $words[1] in
+                get|set)
+                  _arguments '1:key:(apiToken teamId)'
+                  ;;
+              esac
+              ;;
+          esac
+          ;;
+        completion)
+          _arguments '1:shell:(bash zsh fish)'
+          ;;
+      esac
+      ;;
+  esac
+}
+
+_cu
+`;
+}
+function fishCompletion() {
+  return `# Disable file completions
+complete -c cu -f
+
+# Global flags
+complete -c cu -n __fish_use_subcommand -s h -l help -d 'Show help'
+complete -c cu -n __fish_use_subcommand -s V -l version -d 'Show version'
+
+# Commands
+complete -c cu -n __fish_use_subcommand -a init -d 'Set up cu for the first time'
+complete -c cu -n __fish_use_subcommand -a tasks -d 'List tasks assigned to me'
+complete -c cu -n __fish_use_subcommand -a initiatives -d 'List initiatives assigned to me'
+complete -c cu -n __fish_use_subcommand -a task -d 'Get task details'
+complete -c cu -n __fish_use_subcommand -a update -d 'Update a task'
+complete -c cu -n __fish_use_subcommand -a create -d 'Create a new task'
+complete -c cu -n __fish_use_subcommand -a sprint -d 'List my tasks in the current active sprint'
+complete -c cu -n __fish_use_subcommand -a subtasks -d 'List subtasks of a task or initiative'
+complete -c cu -n __fish_use_subcommand -a comment -d 'Post a comment on a task'
+complete -c cu -n __fish_use_subcommand -a comments -d 'List comments on a task'
+complete -c cu -n __fish_use_subcommand -a lists -d 'List all lists in a space'
+complete -c cu -n __fish_use_subcommand -a spaces -d 'List spaces in your workspace'
+complete -c cu -n __fish_use_subcommand -a inbox -d 'Recently updated tasks grouped by time period'
+complete -c cu -n __fish_use_subcommand -a assigned -d 'Show all tasks assigned to me'
+complete -c cu -n __fish_use_subcommand -a open -d 'Open a task in the browser by ID or name'
+complete -c cu -n __fish_use_subcommand -a summary -d 'Daily standup summary'
+complete -c cu -n __fish_use_subcommand -a overdue -d 'List tasks that are past their due date'
+complete -c cu -n __fish_use_subcommand -a assign -d 'Assign or unassign users from a task'
+complete -c cu -n __fish_use_subcommand -a config -d 'Manage CLI configuration'
+complete -c cu -n __fish_use_subcommand -a completion -d 'Output shell completion script'
+
+# tasks / initiatives flags
+complete -c cu -n '__fish_seen_subcommand_from tasks initiatives' -l status -d 'Filter by status'
+complete -c cu -n '__fish_seen_subcommand_from tasks initiatives' -l list -d 'Filter by list ID'
+complete -c cu -n '__fish_seen_subcommand_from tasks initiatives' -l space -d 'Filter by space ID'
+complete -c cu -n '__fish_seen_subcommand_from tasks initiatives' -l name -d 'Filter by name'
+complete -c cu -n '__fish_seen_subcommand_from tasks initiatives' -l json -d 'Force JSON output'
+
+# task flags
+complete -c cu -n '__fish_seen_subcommand_from task' -l json -d 'Force JSON output'
+
+# update flags
+complete -c cu -n '__fish_seen_subcommand_from update' -s n -l name -d 'New task name'
+complete -c cu -n '__fish_seen_subcommand_from update' -s d -l description -d 'New description'
+complete -c cu -n '__fish_seen_subcommand_from update' -s s -l status -d 'New status'
+complete -c cu -n '__fish_seen_subcommand_from update' -l priority -d 'Priority level' -a 'urgent high normal low'
+complete -c cu -n '__fish_seen_subcommand_from update' -l due-date -d 'Due date'
+complete -c cu -n '__fish_seen_subcommand_from update' -l assignee -d 'Add assignee'
+
+# create flags
+complete -c cu -n '__fish_seen_subcommand_from create' -s l -l list -d 'Target list ID'
+complete -c cu -n '__fish_seen_subcommand_from create' -s n -l name -d 'Task name'
+complete -c cu -n '__fish_seen_subcommand_from create' -s d -l description -d 'Task description'
+complete -c cu -n '__fish_seen_subcommand_from create' -s p -l parent -d 'Parent task ID'
+complete -c cu -n '__fish_seen_subcommand_from create' -s s -l status -d 'Initial status'
+complete -c cu -n '__fish_seen_subcommand_from create' -l priority -d 'Priority level' -a 'urgent high normal low'
+complete -c cu -n '__fish_seen_subcommand_from create' -l due-date -d 'Due date'
+complete -c cu -n '__fish_seen_subcommand_from create' -l assignee -d 'Assignee user ID'
+complete -c cu -n '__fish_seen_subcommand_from create' -l tags -d 'Comma-separated tag names'
+
+# sprint flags
+complete -c cu -n '__fish_seen_subcommand_from sprint' -l status -d 'Filter by status'
+complete -c cu -n '__fish_seen_subcommand_from sprint' -l space -d 'Narrow sprint search to a space'
+complete -c cu -n '__fish_seen_subcommand_from sprint' -l json -d 'Force JSON output'
+
+# subtasks flags
+complete -c cu -n '__fish_seen_subcommand_from subtasks' -l json -d 'Force JSON output'
+
+# comment flags
+complete -c cu -n '__fish_seen_subcommand_from comment' -s m -l message -d 'Comment text'
+
+# comments flags
+complete -c cu -n '__fish_seen_subcommand_from comments' -l json -d 'Force JSON output'
+
+# lists flags
+complete -c cu -n '__fish_seen_subcommand_from lists' -l name -d 'Filter by name'
+complete -c cu -n '__fish_seen_subcommand_from lists' -l json -d 'Force JSON output'
+
+# spaces flags
+complete -c cu -n '__fish_seen_subcommand_from spaces' -l name -d 'Filter spaces by name'
+complete -c cu -n '__fish_seen_subcommand_from spaces' -l my -d 'Show only spaces where I have assigned tasks'
+complete -c cu -n '__fish_seen_subcommand_from spaces' -l json -d 'Force JSON output'
+
+# inbox flags
+complete -c cu -n '__fish_seen_subcommand_from inbox' -l json -d 'Force JSON output'
+complete -c cu -n '__fish_seen_subcommand_from inbox' -l days -d 'Lookback period in days'
+
+# assigned flags
+complete -c cu -n '__fish_seen_subcommand_from assigned' -l include-closed -d 'Include done/closed tasks'
+complete -c cu -n '__fish_seen_subcommand_from assigned' -l json -d 'Force JSON output'
+
+# open flags
+complete -c cu -n '__fish_seen_subcommand_from open' -l json -d 'Output task JSON instead of opening'
+
+# summary flags
+complete -c cu -n '__fish_seen_subcommand_from summary' -l hours -d 'Completed-tasks lookback in hours'
+complete -c cu -n '__fish_seen_subcommand_from summary' -l json -d 'Force JSON output'
+
+# overdue flags
+complete -c cu -n '__fish_seen_subcommand_from overdue' -l json -d 'Force JSON output'
+
+# assign flags
+complete -c cu -n '__fish_seen_subcommand_from assign' -l to -d 'Add assignee'
+complete -c cu -n '__fish_seen_subcommand_from assign' -l remove -d 'Remove assignee'
+complete -c cu -n '__fish_seen_subcommand_from assign' -l json -d 'Force JSON output'
+
+# config subcommands
+complete -c cu -n '__fish_seen_subcommand_from config; and not __fish_seen_subcommand_from get set path' -a get -d 'Print a config value'
+complete -c cu -n '__fish_seen_subcommand_from config; and not __fish_seen_subcommand_from get set path' -a set -d 'Set a config value'
+complete -c cu -n '__fish_seen_subcommand_from config; and not __fish_seen_subcommand_from get set path' -a path -d 'Print config file path'
+complete -c cu -n '__fish_seen_subcommand_from get set' -a 'apiToken teamId' -d 'Config key'
+
+# completion subcommand
+complete -c cu -n '__fish_seen_subcommand_from completion' -a 'bash zsh fish' -d 'Shell type'
+`;
+}
+function generateCompletion(shell) {
+  switch (shell) {
+    case "bash":
+      return bashCompletion();
+    case "zsh":
+      return zshCompletion();
+    case "fish":
+      return fishCompletion();
+    default:
+      throw new Error(`Unsupported shell: ${shell}. Supported shells: bash, zsh, fish`);
+  }
+}
+
+// src/index.ts
+var require2 = createRequire(import.meta.url);
+var { version } = require2("../package.json");
+function wrapAction(fn) {
+  return (...args) => {
+    fn(...args).catch((err) => {
+      console.error(err instanceof Error ? err.message : String(err));
+      process.exit(1);
+    });
+  };
+}
+var program = new Command();
+program.name("cu").description("ClickUp CLI for AI agents").version(version).allowExcessArguments(false);
+program.command("init").description("Set up cu for the first time").action(
+  wrapAction(async () => {
+    await runInitCommand();
+  })
+);
+program.command("tasks").description("List tasks assigned to me").option("--status <status>", 'Filter by status (e.g. "in progress")').option("--list <listId>", "Filter by list ID").option("--space <spaceId>", "Filter by space ID").option("--name <partial>", "Filter by name (case-insensitive contains)").option("--json", "Force JSON output even in terminal").action(
+  wrapAction(async (opts) => {
+    const config = loadConfig();
+    const tasks = await fetchMyTasks(config, {
+      typeFilter: "task",
+      statuses: opts.status ? [opts.status] : void 0,
+      listIds: opts.list ? [opts.list] : void 0,
+      spaceIds: opts.space ? [opts.space] : void 0,
+      name: opts.name
+    });
+    await printTasks(tasks, opts.json ?? false, config);
+  })
+);
+program.command("initiatives").description("List initiatives assigned to me").option("--status <status>", "Filter by status").option("--list <listId>", "Filter by list ID").option("--space <spaceId>", "Filter by space ID").option("--name <partial>", "Filter by name (case-insensitive contains)").option("--json", "Force JSON output even in terminal").action(
+  wrapAction(async (opts) => {
+    const config = loadConfig();
+    const tasks = await fetchMyTasks(config, {
+      typeFilter: "initiative",
+      statuses: opts.status ? [opts.status] : void 0,
+      listIds: opts.list ? [opts.list] : void 0,
+      spaceIds: opts.space ? [opts.space] : void 0,
+      name: opts.name
+    });
+    await printTasks(tasks, opts.json ?? false, config);
+  })
+);
+program.command("task <taskId>").description("Get task details").option("--json", "Force JSON output even in terminal").action(
+  wrapAction(async (taskId, opts) => {
+    const config = loadConfig();
+    const result = await getTask(config, taskId);
+    if (opts.json || !isTTY()) {
+      console.log(JSON.stringify(result, null, 2));
+    } else {
+      const lines = [
+        `ID:          ${result.id}`,
+        `Name:        ${result.name}`,
+        `Status:      ${result.status?.status ?? "unknown"}`,
+        `Type:        ${(result.custom_item_id ?? 0) !== 0 ? "initiative" : "task"}`,
+        `List:        ${result.list?.name ?? "unknown"}`,
+        `URL:         ${result.url}`,
+        ...result.parent ? [`Parent:      ${result.parent}`] : [],
+        ...result.description ? ["", result.description] : []
+      ];
+      console.log(lines.join("\n"));
+    }
+  })
+);
+program.command("update <taskId>").description("Update a task").option("-n, --name <text>", "New task name").option("-d, --description <text>", "New description (markdown supported)").option("-s, --status <status>", 'New status (e.g. "in progress", "done")').option("--priority <level>", "Priority: urgent, high, normal, low (or 1-4)").option("--due-date <date>", "Due date (YYYY-MM-DD)").option("--assignee <userId>", "Add assignee by user ID").action(
+  wrapAction(async (taskId, opts) => {
+    const config = loadConfig();
+    const payload = buildUpdatePayload(opts);
+    const result = await updateTask(config, taskId, payload);
+    if (isTTY()) {
+      console.log(`Updated task ${result.id}: "${result.name}"`);
+    } else {
+      console.log(JSON.stringify(result, null, 2));
+    }
+  })
+);
+program.command("create").description("Create a new task").option("-l, --list <listId>", "Target list ID (auto-detected from --parent if omitted)").requiredOption("-n, --name <name>", "Task name").option("-d, --description <text>", "Task description").option("-p, --parent <taskId>", "Parent task ID (list auto-detected from parent)").option("-s, --status <status>", "Initial status").option("--priority <level>", "Priority: urgent, high, normal, low (or 1-4)").option("--due-date <date>", "Due date (YYYY-MM-DD)").option("--assignee <userId>", "Assignee user ID").option("--tags <tags>", "Comma-separated tag names").action(
+  wrapAction(async (opts) => {
+    const config = loadConfig();
+    const result = await createTask(config, opts);
+    if (isTTY()) {
+      console.log(`Created task ${result.id}: "${result.name}" - ${result.url}`);
+    } else {
+      console.log(JSON.stringify(result, null, 2));
+    }
+  })
+);
+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("--json", "Force JSON output even in terminal").action(
+  wrapAction(async (opts) => {
+    const config = loadConfig();
+    await runSprintCommand(config, opts);
+  })
+);
+program.command("subtasks <taskId>").description("List subtasks of a task or initiative").option("--json", "Force JSON output even in terminal").action(
+  wrapAction(async (taskId, opts) => {
+    const config = loadConfig();
+    const tasks = await fetchSubtasks(config, taskId);
+    await printTasks(tasks, opts.json ?? false, config);
+  })
+);
+program.command("comment <taskId>").description("Post a comment on a task").requiredOption("-m, --message <text>", "Comment text").action(
+  wrapAction(async (taskId, opts) => {
+    const config = loadConfig();
+    const result = await postComment(config, taskId, opts.message);
+    if (isTTY()) {
+      console.log(`Comment posted (id: ${result.id})`);
+    } else {
+      console.log(JSON.stringify(result, null, 2));
+    }
+  })
+);
+program.command("comments <taskId>").description("List comments on a task").option("--json", "Force JSON output even in terminal").action(
+  wrapAction(async (taskId, opts) => {
+    const config = loadConfig();
+    const comments = await fetchComments(config, taskId);
+    printComments(comments, opts.json ?? false);
+  })
+);
+program.command("lists <spaceId>").description("List all lists in a space (including lists inside folders)").option("--name <partial>", "Filter by name (case-insensitive contains)").option("--json", "Force JSON output even in terminal").action(
+  wrapAction(async (spaceId, opts) => {
+    const config = loadConfig();
+    const lists = await fetchLists(config, spaceId, { name: opts.name });
+    printLists(lists, opts.json ?? false);
+  })
+);
+program.command("spaces").description("List spaces in your workspace").option("--name <partial>", "Filter spaces by name (case-insensitive contains)").option("--my", "Show only spaces where I have assigned tasks").option("--json", "Force JSON output even in terminal").action(
+  wrapAction(async (opts) => {
+    const config = loadConfig();
+    await listSpaces(config, opts);
+  })
+);
+program.command("inbox").description("Recently updated tasks grouped by time period").option("--json", "Force JSON output even in terminal").option("--days <n>", "Lookback period in days", "30").action(
+  wrapAction(async (opts) => {
+    const config = loadConfig();
+    const days = Number(opts.days ?? 30);
+    if (!Number.isFinite(days) || days <= 0) {
+      console.error("Error: --days must be a positive number");
+      process.exit(1);
+    }
+    const tasks = await fetchInbox(config, days);
+    await printInbox(tasks, opts.json ?? false, config);
+  })
+);
+program.command("assigned").description("Show all tasks assigned to me, grouped by status").option("--include-closed", "Include done/closed tasks").option("--json", "Force JSON output even in terminal").action(
+  wrapAction(async (opts) => {
+    const config = loadConfig();
+    await runAssignedCommand(config, opts);
+  })
+);
+program.command("open <query>").description("Open a task in the browser by ID or name").option("--json", "Output task JSON instead of opening").action(
+  wrapAction(async (query, opts) => {
+    const config = loadConfig();
+    await openTask(config, query, opts);
+  })
+);
+program.command("summary").description("Daily standup summary: completed, in-progress, overdue").option("--hours <n>", "Completed-tasks lookback in hours", "24").option("--json", "Force JSON output even in terminal").action(
+  wrapAction(async (opts) => {
+    const config = loadConfig();
+    const hours = Number(opts.hours ?? 24);
+    if (!Number.isFinite(hours) || hours <= 0) {
+      console.error("Error: --hours must be a positive number");
+      process.exit(1);
+    }
+    await runSummaryCommand(config, { hours, json: opts.json ?? false });
+  })
+);
+program.command("overdue").description("List tasks that are past their due date").option("--json", "Force JSON output even in terminal").action(
+  wrapAction(async (opts) => {
+    const config = loadConfig();
+    const tasks = await fetchOverdueTasks(config);
+    await printTasks(tasks, opts.json ?? false, config);
+  })
+);
+program.command("assign <taskId>").description("Assign or unassign users from a task").option("--to <userId>", 'Add assignee (user ID or "me")').option("--remove <userId>", 'Remove assignee (user ID or "me")').option("--json", "Force JSON output even in terminal").action(
+  wrapAction(async (taskId, opts) => {
+    const config = loadConfig();
+    const result = await assignTask(config, taskId, opts);
+    if (opts.json || !isTTY()) {
+      console.log(JSON.stringify(result, null, 2));
+    } else {
+      const parts = [];
+      if (opts.to) parts.push(`Assigned ${opts.to} to task ${taskId}`);
+      if (opts.remove) parts.push(`Removed ${opts.remove} from task ${taskId}`);
+      console.log(parts.join("; "));
+    }
+  })
+);
+var configCmd = program.command("config").description("Manage CLI configuration");
+configCmd.command("get <key>").description("Print a config value").action(
+  wrapAction(async (key) => {
+    const value = getConfigValue(key);
+    if (value !== void 0) {
+      console.log(value);
+    }
+  })
+);
+configCmd.command("set <key> <value>").description("Set a config value").action(
+  wrapAction(async (key, value) => {
+    setConfigValue(key, value);
+  })
+);
+configCmd.command("path").description("Print config file path").action(
+  wrapAction(async () => {
+    console.log(configPath2());
+  })
+);
+program.command("completion <shell>").description("Output shell completion script (bash, zsh, fish)").action(
+  wrapAction(async (shell) => {
+    const script = generateCompletion(shell);
+    process.stdout.write(script);
+  })
+);
+process.on("SIGINT", () => {
+  process.stderr.write("\nInterrupted\n");
+  process.exit(130);
+});
+program.parse();