@khangal.j/fireside-cli 0.0.2 → 0.0.4

package/README.md

@@ -11,13 +11,45 @@ npm install -g @khangal.j/fireside-cli
 ## Usage
 
 ```sh
-fireside login --base-url http://localhost:3000
+fireside login
 fireside status
 fireside hello
 fireside my-stuff
+fireside my-stuff --project personal
+fireside my-stuff --json
 fireside projects list
+fireside tasks list
+fireside tasks list --project personal
+fireside tasks get <task-id>
+fireside tasks get <task-id> --context
+fireside tasks get <task-id> --handoff
+fireside tasks create --project personal --board main --column maybe --title "Ship CLI"
+fireside tasks update <task-id> --title "Ship task CLI"
+fireside tasks delete <task-id>
+fireside tasks handoff create <task-id> --to @alice --summary "Ready for review" --context-file handoff.md
 ```
 
+## Task Commands
+
+- `fireside tasks list [--project <project>] [--board <board>] [--column <column>] [--json]`
+- `fireside tasks get <task-id> [--project <project>] [--context] [--handoff] [--json]`
+- `fireside tasks create --project <project> --column <column> --title <title> [--board <board>] [--description <text> | --description-file <path>] [--due-date YYYY-MM-DD] [--assignee <member>]... [--json]`
+- `fireside tasks update <task-id> [--project <project>] [--title <title>] [--description <text> | --description-file <path> | --clear-description] [--due-date YYYY-MM-DD | --clear-due-date] [--assignee <member>]... [--clear-assignees] [--json]`
+- `fireside tasks delete <task-id> [--project <project>] [--json]`
+- `fireside tasks handoff create <task-id> --to <member> --summary <summary> [--project <project>] [--next <member>] [--context <markdown> | --context-file <path>] [--json]`
+
+Member selectors accept a user id, email, `@username`, or `me`.
+For handoffs, `--to` must be another project member.
+
+By default, the CLI talks to:
+
+```text
+https://fireside.khangaljargal.workers.dev
+```
+
+Override it for local development or another environment with `--base-url` or
+`FIRESIDE_BASE_URL`.
+
 ## Local State
 
 The CLI stores local files under the `fireside` config directory.

package/dist/index.js

@@ -1,8 +1,32 @@
 #!/usr/bin/env node
 "use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 
 // src/index.ts
+var import_promises2 = require("fs/promises");
 var import_commander = require("commander");
+var import_picocolors = __toESM(require("picocolors"));
 
 // src/lib/api.ts
 var DEVICE_CODE_GRANT_TYPE = "urn:ietf:params:oauth:grant-type:device_code";
@@ -109,6 +133,78 @@ async function listProjects(baseUrl, accessToken) {
     headers: getAuthHeaders(accessToken)
   });
 }
+async function getProjectBoards(baseUrl, accessToken, projectId) {
+  return requestJson(
+    `${baseUrl}/api/projects/${encodeURIComponent(projectId)}/boards`,
+    {
+      headers: getAuthHeaders(accessToken)
+    }
+  );
+}
+async function createTask(baseUrl, accessToken, projectId, boardId, input) {
+  return requestJson(
+    `${baseUrl}/api/projects/${encodeURIComponent(projectId)}/boards/${encodeURIComponent(boardId)}/tasks`,
+    {
+      method: "POST",
+      headers: {
+        ...getAuthHeaders(accessToken),
+        "content-type": "application/json"
+      },
+      body: JSON.stringify(input)
+    }
+  );
+}
+async function updateTask(baseUrl, accessToken, projectId, boardId, taskId, input) {
+  return requestJson(
+    `${baseUrl}/api/projects/${encodeURIComponent(projectId)}/boards/${encodeURIComponent(boardId)}/tasks/${encodeURIComponent(taskId)}`,
+    {
+      method: "PATCH",
+      headers: {
+        ...getAuthHeaders(accessToken),
+        "content-type": "application/json"
+      },
+      body: JSON.stringify(input)
+    }
+  );
+}
+async function deleteTask(baseUrl, accessToken, projectId, boardId, taskId) {
+  return requestJson(
+    `${baseUrl}/api/projects/${encodeURIComponent(projectId)}/boards/${encodeURIComponent(boardId)}/tasks/${encodeURIComponent(taskId)}`,
+    {
+      method: "DELETE",
+      headers: getAuthHeaders(accessToken)
+    }
+  );
+}
+async function getTaskContext(baseUrl, accessToken, projectId, boardId, taskId) {
+  return requestJson(
+    `${baseUrl}/api/projects/${encodeURIComponent(projectId)}/boards/${encodeURIComponent(boardId)}/tasks/${encodeURIComponent(taskId)}/context`,
+    {
+      headers: getAuthHeaders(accessToken)
+    }
+  );
+}
+async function createTaskHandoff(baseUrl, accessToken, projectId, boardId, taskId, input) {
+  return requestJson(
+    `${baseUrl}/api/projects/${encodeURIComponent(projectId)}/boards/${encodeURIComponent(boardId)}/tasks/${encodeURIComponent(taskId)}/handoffs`,
+    {
+      method: "POST",
+      headers: {
+        ...getAuthHeaders(accessToken),
+        "content-type": "application/json"
+      },
+      body: JSON.stringify(input)
+    }
+  );
+}
+async function listTaskHandoffs(baseUrl, accessToken, projectId, boardId, taskId) {
+  return requestJson(
+    `${baseUrl}/api/projects/${encodeURIComponent(projectId)}/boards/${encodeURIComponent(boardId)}/tasks/${encodeURIComponent(taskId)}/handoffs`,
+    {
+      headers: getAuthHeaders(accessToken)
+    }
+  );
+}
 async function listAssignedTasks(baseUrl, accessToken) {
   return requestJson(`${baseUrl}/api/my-stuff`, {
     headers: getAuthHeaders(accessToken)
@@ -134,7 +230,7 @@ async function getHello(baseUrl, accessToken) {
 var import_promises = require("fs/promises");
 var import_node_os = require("os");
 var import_node_path = require("path");
-var DEFAULT_BASE_URL = "http://localhost:3000";
+var DEFAULT_BASE_URL = "https://fireside.khangaljargal.workers.dev";
 var legacyMigrationPromise = null;
 function normalizeBaseUrl(baseUrl) {
   return baseUrl.trim().replace(/\/+$/, "");
@@ -366,6 +462,69 @@ function openBrowser(url) {
 }
 
 // src/index.ts
+function printInfo(message) {
+  console.log(`${import_picocolors.default.cyan("[i]")} ${message}`);
+}
+function printSuccess(message) {
+  console.log(`${import_picocolors.default.green("[ok]")} ${message}`);
+}
+function printWarning(message) {
+  console.log(`${import_picocolors.default.yellow("[!]")} ${message}`);
+}
+function printKeyValue(label, value) {
+  console.log(`${import_picocolors.default.dim(`${label}:`)} ${value}`);
+}
+function formatUrl(url) {
+  return import_picocolors.default.underline(import_picocolors.default.cyan(url));
+}
+function formatCode(code) {
+  return import_picocolors.default.bold(import_picocolors.default.magenta(code));
+}
+function formatUsername(username) {
+  return username ? import_picocolors.default.cyan(`@${username}`) : import_picocolors.default.dim("Not set");
+}
+function formatHeading(title, id) {
+  if (!id) {
+    return import_picocolors.default.bold(title);
+  }
+  return `${import_picocolors.default.bold(title)} ${import_picocolors.default.dim(`(${id})`)}`;
+}
+function formatProjectColor(color) {
+  const colorFormatters = {
+    amber: import_picocolors.default.yellow,
+    blue: import_picocolors.default.blue,
+    cyan: import_picocolors.default.cyan,
+    emerald: import_picocolors.default.green,
+    lime: import_picocolors.default.green,
+    pink: import_picocolors.default.magenta,
+    red: import_picocolors.default.red,
+    slate: import_picocolors.default.white,
+    violet: import_picocolors.default.magenta
+  };
+  const formatter = colorFormatters[color] || ((value) => value);
+  return `${formatter("o")} ${formatter(color)}`;
+}
+function formatProjectMarker(color) {
+  const colorFormatters = {
+    amber: import_picocolors.default.yellow,
+    blue: import_picocolors.default.blue,
+    cyan: import_picocolors.default.cyan,
+    emerald: import_picocolors.default.green,
+    lime: import_picocolors.default.green,
+    pink: import_picocolors.default.magenta,
+    red: import_picocolors.default.red,
+    slate: import_picocolors.default.white,
+    violet: import_picocolors.default.magenta
+  };
+  const formatter = colorFormatters[color] || ((value) => value);
+  return formatter("o");
+}
+function formatNames(names) {
+  if (!names.length) {
+    return import_picocolors.default.dim("None");
+  }
+  return names.map((name) => import_picocolors.default.cyan(name)).join(import_picocolors.default.dim(", "));
+}
 function formatUserCodeForDisplay(userCode) {
   return userCode.match(/.{1,4}/g)?.join("-") || userCode;
 }
@@ -383,15 +542,321 @@ async function requireAuthState() {
   }
   return state;
 }
+function collectOptionValue(value, previous) {
+  return [...previous, value];
+}
+function normalizeLookupValue(value) {
+  return value.trim().toLowerCase();
+}
+function matchIdOrTitle(item, selector) {
+  const trimmedSelector = selector.trim();
+  if (!trimmedSelector.length) {
+    return false;
+  }
+  if (item.id === trimmedSelector) {
+    return true;
+  }
+  const normalizedSelector = normalizeLookupValue(trimmedSelector);
+  const normalizedTitle = normalizeLookupValue(item.title);
+  return normalizedTitle === normalizedSelector || normalizedTitle.includes(normalizedSelector);
+}
+function resolveByIdOrTitle(items, selector, itemLabel) {
+  const trimmedSelector = selector.trim();
+  if (!trimmedSelector.length) {
+    throw new Error(`${itemLabel} is required.`);
+  }
+  const exactIdMatch = items.find((item) => item.id === trimmedSelector);
+  if (exactIdMatch) {
+    return exactIdMatch;
+  }
+  const normalizedSelector = normalizeLookupValue(trimmedSelector);
+  const exactTitleMatches = items.filter(
+    (item) => normalizeLookupValue(item.title) === normalizedSelector
+  );
+  if (exactTitleMatches.length === 1) {
+    return exactTitleMatches[0];
+  }
+  if (exactTitleMatches.length > 1) {
+    throw new Error(
+      `Multiple ${itemLabel}s match "${selector}". Use the ${itemLabel} id instead.`
+    );
+  }
+  const partialMatches = items.filter(
+    (item) => normalizeLookupValue(item.title).includes(normalizedSelector)
+  );
+  if (partialMatches.length === 1) {
+    return partialMatches[0];
+  }
+  if (partialMatches.length > 1) {
+    throw new Error(
+      `Multiple ${itemLabel}s match "${selector}". Use the ${itemLabel} id instead.`
+    );
+  }
+  throw new Error(`No ${itemLabel} found for "${selector}".`);
+}
+function resolveBoard(boards, boardSelector) {
+  if (boardSelector) {
+    return resolveByIdOrTitle(boards, boardSelector, "board");
+  }
+  if (boards.length === 1) {
+    return boards[0];
+  }
+  throw new Error("This project has multiple boards. Pass `--board`.");
+}
+function resolveColumn(columns, columnSelector) {
+  if (columnSelector) {
+    return resolveByIdOrTitle(columns, columnSelector, "column");
+  }
+  if (columns.length === 1) {
+    return columns[0];
+  }
+  throw new Error("This board has multiple columns. Pass `--column`.");
+}
+function uniqueStrings(values) {
+  return [...new Set(values)];
+}
+function formatMember(member) {
+  return member.username ? `${member.name} ${import_picocolors.default.cyan(`@${member.username}`)}` : member.name;
+}
+function formatMemberList(members) {
+  if (!members.length) {
+    return import_picocolors.default.dim("None");
+  }
+  return members.map((member) => formatMember(member)).join(import_picocolors.default.dim(", "));
+}
+function compareTaskEntries(left, right) {
+  return left.project.title.localeCompare(right.project.title) || left.board.position - right.board.position || left.column.position - right.column.position || left.task.position - right.task.position || left.task.title.localeCompare(right.task.title);
+}
+function flattenTaskEntries(projectBoardsResults) {
+  return projectBoardsResults.flatMap(
+    ({ boardsData, project }) => boardsData.boards.flatMap(
+      (board) => board.columns.flatMap(
+        (column) => column.tasks.map((task) => ({
+          board,
+          column,
+          members: boardsData.members,
+          project,
+          task
+        }))
+      )
+    )
+  ).sort(compareTaskEntries);
+}
+function serializeTaskEntry(taskEntry, contextRevision, taskHandoff) {
+  return {
+    board: {
+      id: taskEntry.board.id,
+      title: taskEntry.board.title
+    },
+    column: {
+      id: taskEntry.column.id,
+      role: taskEntry.column.role,
+      title: taskEntry.column.title
+    },
+    ...contextRevision !== void 0 ? { contextRevision } : {},
+    ...taskHandoff !== void 0 ? { handoff: taskHandoff } : {},
+    project: {
+      color: taskEntry.project.color,
+      id: taskEntry.project.id,
+      title: taskEntry.project.title
+    },
+    task: taskEntry.task
+  };
+}
+function serializeTaskHandoff(taskEntry, taskHandoff) {
+  return {
+    board: {
+      id: taskEntry.board.id,
+      title: taskEntry.board.title
+    },
+    column: {
+      id: taskEntry.column.id,
+      title: taskEntry.column.title
+    },
+    handoff: taskHandoff,
+    project: {
+      color: taskEntry.project.color,
+      id: taskEntry.project.id,
+      title: taskEntry.project.title
+    },
+    task: {
+      id: taskEntry.task.id,
+      title: taskEntry.task.title
+    }
+  };
+}
+function printTaskSummary(taskEntry) {
+  console.log(formatHeading(taskEntry.task.title, taskEntry.task.id));
+  console.log(
+    `  ${formatProjectMarker(taskEntry.project.color)} ${import_picocolors.default.cyan(taskEntry.project.title)} ${import_picocolors.default.dim(`/ ${taskEntry.board.title} / ${taskEntry.column.title}`)}`
+  );
+  if (taskEntry.task.dueDate) {
+    printKeyValue("  Due", import_picocolors.default.yellow(formatDueDate(taskEntry.task.dueDate)));
+  }
+  printKeyValue("  Assignees", formatMemberList(taskEntry.task.assignees));
+  if (taskEntry.task.description) {
+    console.log(`  ${taskEntry.task.description}`);
+  }
+  console.log("");
+}
+function printTaskDetails(taskEntry, contextRevision, taskHandoff) {
+  console.log(formatHeading(taskEntry.task.title, taskEntry.task.id));
+  printKeyValue("  Project", import_picocolors.default.cyan(taskEntry.project.title));
+  printKeyValue("  Board", taskEntry.board.title);
+  printKeyValue("  Column", taskEntry.column.title);
+  printKeyValue(
+    "  Due",
+    taskEntry.task.dueDate ? import_picocolors.default.yellow(formatDueDate(taskEntry.task.dueDate)) : import_picocolors.default.dim("None")
+  );
+  printKeyValue("  Assignees", formatMemberList(taskEntry.task.assignees));
+  printKeyValue("  Description", taskEntry.task.description || import_picocolors.default.dim("None"));
+  if (contextRevision !== void 0) {
+    printKeyValue(
+      "  Task context",
+      contextRevision ? `v${contextRevision.version}` : import_picocolors.default.dim("None")
+    );
+    if (contextRevision?.contentMarkdown) {
+      console.log("");
+      console.log(contextRevision.contentMarkdown);
+    }
+  }
+  if (taskHandoff !== void 0) {
+    printKeyValue(
+      "  Active handoff",
+      taskHandoff ? import_picocolors.default.cyan(taskHandoff.id) : import_picocolors.default.dim("None")
+    );
+    if (taskHandoff) {
+      printKeyValue("  Handoff status", import_picocolors.default.cyan(taskHandoff.status));
+      printKeyValue("  Handoff from", formatMember(taskHandoff.fromUser));
+      printKeyValue("  Handoff to", formatMember(taskHandoff.toUser));
+      printKeyValue(
+        "  Handoff next assignee",
+        formatMember(taskHandoff.nextAssigneeUser)
+      );
+      printKeyValue("  Handoff summary", taskHandoff.summary);
+      if (taskHandoff.contextMarkdown) {
+        console.log("");
+        console.log(taskHandoff.contextMarkdown);
+      }
+    }
+  }
+}
+function printTaskHandoff(taskEntry, taskHandoff) {
+  console.log(formatHeading(taskEntry.task.title, taskEntry.task.id));
+  console.log(
+    `  ${formatProjectMarker(taskEntry.project.color)} ${import_picocolors.default.cyan(taskEntry.project.title)} ${import_picocolors.default.dim(`/ ${taskEntry.board.title} / ${taskEntry.column.title}`)}`
+  );
+  printKeyValue("  Handoff", taskHandoff.id);
+  printKeyValue("  Status", import_picocolors.default.cyan(taskHandoff.status));
+  printKeyValue("  From", formatMember(taskHandoff.fromUser));
+  printKeyValue("  To", formatMember(taskHandoff.toUser));
+  printKeyValue("  Next assignee", formatMember(taskHandoff.nextAssigneeUser));
+  console.log(`  ${taskHandoff.summary}`);
+}
+async function readTextFile(filePath, label) {
+  try {
+    return await (0, import_promises2.readFile)(filePath, "utf8");
+  } catch (error) {
+    const message = error instanceof Error ? error.message : `Unable to read ${label} file.`;
+    throw new Error(`Failed to read ${label} file: ${message}`);
+  }
+}
+async function resolveTextInput(value, filePath, label) {
+  if (value !== void 0 && filePath !== void 0) {
+    throw new Error(
+      `Pass either \`--${label}\` or \`--${label}-file\`, not both.`
+    );
+  }
+  if (filePath !== void 0) {
+    return readTextFile(filePath, label);
+  }
+  return value;
+}
+async function loadCliContext(baseUrl) {
+  const state = await requireAuthState();
+  const configState = await loadConfigState();
+  return {
+    accessToken: state.accessToken,
+    baseUrl: await resolveBaseUrl(baseUrl, configState)
+  };
+}
+async function loadCliContextWithCurrentUser(baseUrl) {
+  const cliContext = await loadCliContext(baseUrl);
+  return {
+    ...cliContext,
+    user: await getCurrentUser(cliContext.baseUrl, cliContext.accessToken)
+  };
+}
+async function loadProjectBoardsResults(baseUrl, accessToken, projectSelector) {
+  const projects = await listProjects(baseUrl, accessToken);
+  const selectedProjects = projectSelector ? [resolveByIdOrTitle(projects, projectSelector, "project")] : projects;
+  return Promise.all(
+    selectedProjects.map(async (project) => ({
+      boardsData: await getProjectBoards(baseUrl, accessToken, project.id),
+      project
+    }))
+  );
+}
+async function resolveTaskEntry(baseUrl, accessToken, taskId, projectSelector) {
+  const taskEntries = flattenTaskEntries(
+    await loadProjectBoardsResults(baseUrl, accessToken, projectSelector)
+  ).filter((taskEntry) => taskEntry.task.id === taskId);
+  if (!taskEntries.length) {
+    throw new Error(`Task ${taskId} was not found.`);
+  }
+  return taskEntries[0];
+}
+function resolveProjectMember(members, selector, currentUserId) {
+  const trimmedSelector = selector.trim();
+  if (!trimmedSelector.length) {
+    throw new Error("Member selector is required.");
+  }
+  if (trimmedSelector === "me") {
+    const currentMember = members.find((member) => member.id === currentUserId);
+    if (!currentMember) {
+      throw new Error("You are not a member of this project.");
+    }
+    return currentMember;
+  }
+  const exactIdMatch = members.find((member) => member.id === trimmedSelector);
+  if (exactIdMatch) {
+    return exactIdMatch;
+  }
+  const normalizedSelector = normalizeLookupValue(
+    trimmedSelector.startsWith("@") ? trimmedSelector.slice(1) : trimmedSelector
+  );
+  const usernameMatch = members.find(
+    (member) => normalizeLookupValue(member.username || "") === normalizedSelector
+  );
+  if (usernameMatch) {
+    return usernameMatch;
+  }
+  const emailMatch = members.find(
+    (member) => normalizeLookupValue(member.email) === normalizedSelector
+  );
+  if (emailMatch) {
+    return emailMatch;
+  }
+  throw new Error(
+    `No project member found for "${selector}". Use a user id, email, @username, or \`me\`.`
+  );
+}
+function resolveProjectMemberIds(members, selectors, currentUserId) {
+  return uniqueStrings(
+    selectors.map(
+      (selector) => resolveProjectMember(members, selector, currentUserId).id
+    )
+  );
+}
 function printProjects(projects) {
   if (!projects.length) {
-    console.log("No projects found.");
+    printWarning("No projects found.");
     return;
   }
   for (const project of projects) {
-    console.log(`${project.title} (${project.id})`);
-    console.log(`  Color: ${project.color}`);
-    console.log(`  Members: ${project.members.length}`);
+    console.log(formatHeading(project.title, project.id));
+    printKeyValue("  Color", formatProjectColor(project.color));
+    printKeyValue("  Members", import_picocolors.default.cyan(String(project.members.length)));
     console.log(`  ${project.description}`);
     console.log("");
   }
@@ -406,49 +871,69 @@ function formatDueDate(dueDate) {
     year: "numeric"
   }).format(/* @__PURE__ */ new Date(`${dueDate}T00:00:00`));
 }
-function printAssignedTasks(baseUrl, tasks) {
+function filterAssignedTasksByProject(tasks, projectFilter) {
+  const trimmedProjectFilter = projectFilter?.trim();
+  const normalizedProjectFilter = trimmedProjectFilter?.toLowerCase();
+  if (!normalizedProjectFilter) {
+    return tasks;
+  }
+  return tasks.filter((task) => {
+    const normalizedProjectTitle = task.projectTitle.toLowerCase();
+    return task.projectId === trimmedProjectFilter || normalizedProjectTitle === normalizedProjectFilter || normalizedProjectTitle.includes(normalizedProjectFilter);
+  });
+}
+function printAssignedTasks(tasks, projectFilter) {
   if (!tasks.length) {
-    console.log("Nothing assigned right now.");
+    if (projectFilter) {
+      printWarning(
+        `No assigned tasks found for project filter: ${projectFilter}`
+      );
+      return;
+    }
+    printWarning("Nothing assigned right now.");
     return;
   }
   for (const task of tasks) {
-    console.log(`${task.title} (${task.id})`);
+    console.log(formatHeading(task.title, task.id));
     console.log(
-      `  ${task.projectTitle} / ${task.boardTitle} / ${task.columnTitle}`
+      `  ${formatProjectMarker(task.projectColor)} ${import_picocolors.default.cyan(task.projectTitle)} ${import_picocolors.default.dim(`/ ${task.boardTitle} / ${task.columnTitle}`)}`
     );
-    console.log(`  Due: ${formatDueDate(task.dueDate)}`);
-    console.log(
-      `  Assignees: ${task.assignees.map((assignee) => assignee.name).join(", ") || "None"}`
+    if (task.dueDate) {
+      printKeyValue("  Due", import_picocolors.default.yellow(formatDueDate(task.dueDate)));
+    }
+    printKeyValue(
+      "  Assignees",
+      formatNames(task.assignees.map((assignee) => assignee.name))
     );
     if (task.description) {
       console.log(`  ${task.description}`);
     }
-    console.log(
-      `  ${baseUrl}/projects/${encodeURIComponent(task.projectId)}/boards/tasks/${encodeURIComponent(task.id)}`
-    );
     console.log("");
   }
 }
 var program = new import_commander.Command();
-program.name("fireside").description("Fireside CLI").version("0.0.1").showHelpAfterError();
+program.name("fireside").description("Fireside CLI").version("0.0.2").configureOutput({
+  outputError: (message, write) => write(import_picocolors.default.red(message))
+}).showHelpAfterError();
 addBaseUrlOption(
   program.command("login").description("Authenticate with Fireside using device authorization").option("--no-open", "Do not open the browser automatically").action(async (options) => {
     const configState = await loadConfigState();
     const baseUrl = await resolveBaseUrl(options.baseUrl, configState);
     const deviceCode = await createDeviceCode(baseUrl);
     const verificationUrl = deviceCode.verification_uri;
-    console.log(`Base URL: ${baseUrl}`);
-    console.log(`Open this URL: ${verificationUrl}`);
-    console.log(
-      `Enter this code in the browser: ${formatUserCodeForDisplay(deviceCode.user_code)}`
+    printKeyValue("Base URL", formatUrl(baseUrl));
+    printKeyValue("Open", formatUrl(verificationUrl));
+    printKeyValue(
+      "Code",
+      formatCode(formatUserCodeForDisplay(deviceCode.user_code))
     );
     if (options.open) {
       const opened = openBrowser(verificationUrl);
       if (opened) {
-        console.log("Opened the browser for approval.");
+        printSuccess("Opened the browser for approval.");
       }
     }
-    console.log("Waiting for approval...");
+    printInfo("Waiting for approval...");
     const accessToken = await pollForAccessToken(
       baseUrl,
       deviceCode.device_code,
@@ -460,17 +945,20 @@ addBaseUrlOption(
       createdAt: (/* @__PURE__ */ new Date()).toISOString()
     });
     const user = await getCurrentUser(baseUrl, accessToken);
-    console.log(`Signed in as ${user.email}.`);
+    printSuccess(`Signed in as ${import_picocolors.default.bold(user.email)}.`);
+    if (user.username) {
+      printKeyValue("Username", formatUsername(user.username));
+    }
   })
 );
 program.command("logout").description("Remove the local CLI session").action(async () => {
   const state = await loadAuthState();
   if (!state) {
-    console.log("Already signed out.");
+    printInfo("Already signed out.");
     return;
   }
   await clearAuthState();
-  console.log("Removed the local CLI session.");
+  printSuccess("Removed the local CLI session.");
 });
 addBaseUrlOption(
   program.command("status").description("Show the current authenticated CLI user").action(async (options) => {
@@ -478,8 +966,11 @@ addBaseUrlOption(
     const configState = await loadConfigState();
     const baseUrl = await resolveBaseUrl(options.baseUrl, configState);
     const user = await getCurrentUser(baseUrl, state.accessToken);
-    console.log(`Base URL: ${baseUrl}`);
-    console.log(`Signed in as: ${user.name} <${user.email}>`);
+    printKeyValue("Base URL", formatUrl(baseUrl));
+    printSuccess(
+      `Signed in as ${import_picocolors.default.bold(user.name)} <${import_picocolors.default.cyan(user.email)}>`
+    );
+    printKeyValue("Username", formatUsername(user.username));
   })
 );
 addBaseUrlOption(
@@ -488,17 +979,27 @@ addBaseUrlOption(
     const configState = await loadConfigState();
     const baseUrl = await resolveBaseUrl(options.baseUrl, configState);
     const message = await getHello(baseUrl, state.accessToken);
-    console.log(message);
+    printInfo(message);
   })
 );
 addBaseUrlOption(
-  program.command("my-stuff").description("List tasks currently assigned to you").action(async (options) => {
-    const state = await requireAuthState();
-    const configState = await loadConfigState();
-    const baseUrl = await resolveBaseUrl(options.baseUrl, configState);
-    const tasks = await listAssignedTasks(baseUrl, state.accessToken);
-    printAssignedTasks(baseUrl, tasks);
-  })
+  program.command("my-stuff").description("List tasks currently assigned to you").option("--json", "Print assigned tasks as JSON").option("-p, --project <project>", "Filter by project id or title").action(
+    async (options) => {
+      const state = await requireAuthState();
+      const configState = await loadConfigState();
+      const baseUrl = await resolveBaseUrl(options.baseUrl, configState);
+      const tasks = await listAssignedTasks(baseUrl, state.accessToken);
+      const filteredTasks = filterAssignedTasksByProject(
+        tasks,
+        options.project
+      );
+      if (options.json) {
+        console.log(JSON.stringify(filteredTasks, null, 2));
+        return;
+      }
+      printAssignedTasks(filteredTasks, options.project);
+    }
+  )
 );
 addBaseUrlOption(
   program.command("projects").description("Interact with project APIs").command("list").description("List accessible projects").action(async function() {
@@ -512,12 +1013,326 @@ addBaseUrlOption(
     printProjects(projects);
   })
 );
+var tasksCommand = program.command("tasks").description("Interact with tasks");
+addBaseUrlOption(
+  tasksCommand.command("list").description("List accessible tasks").option("--json", "Print tasks as JSON").option("-p, --project <project>", "Filter by project id or title").option("--board <board>", "Filter by board id or title").option("--column <column>", "Filter by column id or title").action(
+    async (options) => {
+      const { accessToken, baseUrl } = await loadCliContext(options.baseUrl);
+      let taskEntries = flattenTaskEntries(
+        await loadProjectBoardsResults(baseUrl, accessToken, options.project)
+      );
+      if (options.board) {
+        taskEntries = taskEntries.filter(
+          (taskEntry) => matchIdOrTitle(taskEntry.board, options.board)
+        );
+      }
+      if (options.column) {
+        taskEntries = taskEntries.filter(
+          (taskEntry) => matchIdOrTitle(taskEntry.column, options.column)
+        );
+      }
+      if (options.json) {
+        console.log(
+          JSON.stringify(
+            taskEntries.map((taskEntry) => serializeTaskEntry(taskEntry)),
+            null,
+            2
+          )
+        );
+        return;
+      }
+      if (!taskEntries.length) {
+        printWarning("No tasks found.");
+        return;
+      }
+      for (const taskEntry of taskEntries) {
+        printTaskSummary(taskEntry);
+      }
+    }
+  )
+);
+addBaseUrlOption(
+  tasksCommand.command("get <taskId>").description("Show a task by id").option("--json", "Print the task as JSON").option("-p, --project <project>", "Limit lookup to a project id or title").option("--context", "Load the latest saved task context").option("--handoff", "Load the active handoff context").action(
+    async (taskId, options) => {
+      const { accessToken, baseUrl } = await loadCliContext(options.baseUrl);
+      const taskEntry = await resolveTaskEntry(
+        baseUrl,
+        accessToken,
+        taskId,
+        options.project
+      );
+      const contextRevision = options.context ? await getTaskContext(
+        baseUrl,
+        accessToken,
+        taskEntry.project.id,
+        taskEntry.board.id,
+        taskId
+      ) : void 0;
+      const taskHandoff = options.handoff ? (await listTaskHandoffs(
+        baseUrl,
+        accessToken,
+        taskEntry.project.id,
+        taskEntry.board.id,
+        taskId
+      )).find((handoff) => handoff.status === "active") || null : void 0;
+      if (options.json) {
+        console.log(
+          JSON.stringify(
+            serializeTaskEntry(taskEntry, contextRevision, taskHandoff),
+            null,
+            2
+          )
+        );
+        return;
+      }
+      printTaskDetails(taskEntry, contextRevision, taskHandoff);
+    }
+  )
+);
+addBaseUrlOption(
+  tasksCommand.command("create").description("Create a task").requiredOption("-p, --project <project>", "Project id or title").requiredOption("-t, --title <title>", "Task title").requiredOption("-c, --column <column>", "Column id or title").option("--board <board>", "Board id or title").option("--description <description>", "Task description").option("--description-file <path>", "Read task description from a file").option("--due-date <date>", "Due date in YYYY-MM-DD format").option(
+    "-a, --assignee <member>",
+    "Assign a member by id, email, @username, or me",
+    collectOptionValue,
+    []
+  ).option("--json", "Print the created task as JSON").action(
+    async (options) => {
+      const { accessToken, baseUrl, user } = await loadCliContextWithCurrentUser(options.baseUrl);
+      const [projectBoardsResult] = await loadProjectBoardsResults(
+        baseUrl,
+        accessToken,
+        options.project
+      );
+      const board = resolveBoard(
+        projectBoardsResult.boardsData.boards,
+        options.board
+      );
+      const column = resolveColumn(board.columns, options.column);
+      const description = await resolveTextInput(
+        options.description,
+        options.descriptionFile,
+        "description"
+      );
+      const assigneeIds = resolveProjectMemberIds(
+        projectBoardsResult.boardsData.members,
+        options.assignee,
+        user.id
+      );
+      const createdTask = await createTask(
+        baseUrl,
+        accessToken,
+        projectBoardsResult.project.id,
+        board.id,
+        {
+          assigneeIds,
+          boardColumnId: column.id,
+          description: description ?? "",
+          dueDate: options.dueDate ?? "",
+          title: options.title
+        }
+      );
+      const taskEntry = {
+        board,
+        column,
+        members: projectBoardsResult.boardsData.members,
+        project: projectBoardsResult.project,
+        task: createdTask
+      };
+      if (options.json) {
+        console.log(JSON.stringify(serializeTaskEntry(taskEntry), null, 2));
+        return;
+      }
+      printSuccess("Created task.");
+      printTaskSummary(taskEntry);
+    }
+  )
+);
+addBaseUrlOption(
+  tasksCommand.command("update <taskId>").description("Update a task").option("-p, --project <project>", "Limit lookup to a project id or title").option("-t, --title <title>", "New task title").option("--description <description>", "New task description").option("--description-file <path>", "Read task description from a file").option("--clear-description", "Clear the task description").option("--due-date <date>", "Set the due date in YYYY-MM-DD format").option("--clear-due-date", "Clear the due date").option(
+    "-a, --assignee <member>",
+    "Replace assignees using id, email, @username, or me",
+    collectOptionValue,
+    []
+  ).option("--clear-assignees", "Remove all assignees").option("--json", "Print the updated task as JSON").action(
+    async (taskId, options) => {
+      if (options.title === void 0 && options.description === void 0 && options.descriptionFile === void 0 && !options.clearDescription && options.dueDate === void 0 && !options.clearDueDate && !options.assignee.length && !options.clearAssignees) {
+        throw new Error("No updates requested.");
+      }
+      if (options.clearDescription && (options.description !== void 0 || options.descriptionFile !== void 0)) {
+        throw new Error(
+          "Pass either a new description or `--clear-description`, not both."
+        );
+      }
+      if (options.clearDueDate && options.dueDate !== void 0) {
+        throw new Error(
+          "Pass either `--due-date` or `--clear-due-date`, not both."
+        );
+      }
+      if (options.clearAssignees && options.assignee.length) {
+        throw new Error(
+          "Pass either `--assignee` or `--clear-assignees`, not both."
+        );
+      }
+      const { accessToken, baseUrl, user } = await loadCliContextWithCurrentUser(options.baseUrl);
+      const taskEntry = await resolveTaskEntry(
+        baseUrl,
+        accessToken,
+        taskId,
+        options.project
+      );
+      const description = await resolveTextInput(
+        options.description,
+        options.descriptionFile,
+        "description"
+      );
+      const assigneeIds = options.clearAssignees ? [] : options.assignee.length ? resolveProjectMemberIds(
+        taskEntry.members,
+        options.assignee,
+        user.id
+      ) : taskEntry.task.assignees.map((assignee) => assignee.id);
+      const updatedTask = await updateTask(
+        baseUrl,
+        accessToken,
+        taskEntry.project.id,
+        taskEntry.board.id,
+        taskId,
+        {
+          assigneeIds,
+          description: options.clearDescription ? "" : description ?? taskEntry.task.description ?? "",
+          dueDate: options.clearDueDate ? "" : options.dueDate ?? taskEntry.task.dueDate ?? "",
+          title: options.title ?? taskEntry.task.title
+        }
+      );
+      const updatedTaskEntry = {
+        ...taskEntry,
+        task: updatedTask
+      };
+      if (options.json) {
+        console.log(
+          JSON.stringify(serializeTaskEntry(updatedTaskEntry), null, 2)
+        );
+        return;
+      }
+      printSuccess("Updated task.");
+      printTaskDetails(updatedTaskEntry);
+    }
+  )
+);
+addBaseUrlOption(
+  tasksCommand.command("delete <taskId>").description("Delete a task").option("-p, --project <project>", "Limit lookup to a project id or title").option("--json", "Print the deleted task metadata as JSON").action(
+    async (taskId, options) => {
+      const { accessToken, baseUrl } = await loadCliContext(options.baseUrl);
+      const taskEntry = await resolveTaskEntry(
+        baseUrl,
+        accessToken,
+        taskId,
+        options.project
+      );
+      const deletedTask = await deleteTask(
+        baseUrl,
+        accessToken,
+        taskEntry.project.id,
+        taskEntry.board.id,
+        taskId
+      );
+      if (options.json) {
+        console.log(
+          JSON.stringify(
+            {
+              board: {
+                id: taskEntry.board.id,
+                title: taskEntry.board.title
+              },
+              column: {
+                id: taskEntry.column.id,
+                title: taskEntry.column.title
+              },
+              id: deletedTask.id,
+              project: {
+                id: taskEntry.project.id,
+                title: taskEntry.project.title
+              }
+            },
+            null,
+            2
+          )
+        );
+        return;
+      }
+      printSuccess(
+        `Deleted ${import_picocolors.default.bold(taskEntry.task.title)} ${import_picocolors.default.dim(`(${deletedTask.id})`)}.`
+      );
+    }
+  )
+);
+var taskHandoffCommand = tasksCommand.command("handoff").description("Create and manage task handoffs");
+addBaseUrlOption(
+  taskHandoffCommand.command("create <taskId>").description("Create a handoff for a task").requiredOption("--to <member>", "Target user id, email, or @username").requiredOption("--summary <summary>", "Short handoff summary").option("-p, --project <project>", "Limit lookup to a project id or title").option("--next <member>", "Who should own the task after completion").option("--context <markdown>", "Handoff AI context markdown").option("--context-file <path>", "Read handoff AI context from a file").option("--json", "Print the created handoff as JSON").action(
+    async (taskId, options) => {
+      const { accessToken, baseUrl, user } = await loadCliContextWithCurrentUser(options.baseUrl);
+      const taskEntry = await resolveTaskEntry(
+        baseUrl,
+        accessToken,
+        taskId,
+        options.project
+      );
+      const contextMarkdown = await resolveTextInput(
+        options.context,
+        options.contextFile,
+        "context"
+      );
+      if (contextMarkdown === void 0) {
+        throw new Error(
+          "Handoff context is required. Pass `--context` or `--context-file`."
+        );
+      }
+      const toUser = resolveProjectMember(
+        taskEntry.members,
+        options.to,
+        user.id
+      );
+      if (toUser.id === user.id) {
+        throw new Error("Choose another project member for `--to`.");
+      }
+      const nextAssigneeUser = resolveProjectMember(
+        taskEntry.members,
+        options.next || "me",
+        user.id
+      );
+      const taskHandoff = await createTaskHandoff(
+        baseUrl,
+        accessToken,
+        taskEntry.project.id,
+        taskEntry.board.id,
+        taskId,
+        {
+          contextMarkdown,
+          nextAssigneeUserId: nextAssigneeUser.id,
+          summary: options.summary,
+          toUserId: toUser.id
+        }
+      );
+      if (options.json) {
+        console.log(
+          JSON.stringify(
+            serializeTaskHandoff(taskEntry, taskHandoff),
+            null,
+            2
+          )
+        );
+        return;
+      }
+      printSuccess("Created handoff.");
+      printTaskHandoff(taskEntry, taskHandoff);
+    }
+  )
+);
 async function main() {
   try {
     await program.parseAsync(process.argv);
   } catch (error) {
     const message = error instanceof Error ? error.message : "Unknown CLI error.";
-    console.error(message);
+    console.error(`${import_picocolors.default.red("[x]")} ${message}`);
     process.exitCode = 1;
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@khangal.j/fireside-cli",
-  "version": "0.0.2",
+  "version": "0.0.4",
   "description": "Fireside CLI",
   "license": "MIT",
   "private": false,
@@ -26,9 +26,11 @@
     "start": "node dist/index.js"
   },
   "dependencies": {
-    "commander": "^14.0.1"
+    "commander": "^14.0.1",
+    "picocolors": "^1.1.1"
   },
   "devDependencies": {
+    "@types/node": "^25.6.0",
     "tsup": "^8.5.0"
   }
 }