@khangal.j/fireside-cli 0.0.1 → 0.0.3

package/README.md

@@ -11,19 +11,49 @@ 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 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] [--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.
 
-- macOS: `~/Library/Application Support/fireside/{config,auth}.json`
-- Linux: `$XDG_CONFIG_HOME/fireside/{config,auth}.json` or `~/.config/fireside/{config,auth}.json`
+- macOS/Linux: `$XDG_CONFIG_HOME/fireside/{config,auth}.json` or `~/.config/fireside/{config,auth}.json`
 - Windows: `%APPDATA%\\fireside\\{config,auth}.json`
 
 `config.json` stores settings like `baseUrl`. `auth.json` stores the local session token.

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,70 @@ 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 listAssignedTasks(baseUrl, accessToken) {
   return requestJson(`${baseUrl}/api/my-stuff`, {
     headers: getAuthHeaders(accessToken)
@@ -134,27 +222,28 @@ 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(/\/+$/, "");
 }
+function getUnixConfigHomeDirectory() {
+  return process.env.XDG_CONFIG_HOME || (0, import_node_path.join)((0, import_node_os.homedir)(), ".config");
+}
 function getConfigDirectory(appName = "fireside") {
   switch (process.platform) {
-    case "darwin":
-      return (0, import_node_path.join)((0, import_node_os.homedir)(), "Library", "Application Support", appName);
     case "win32":
       return (0, import_node_path.join)(
         process.env.APPDATA || (0, import_node_path.join)((0, import_node_os.homedir)(), "AppData", "Roaming"),
         appName
       );
     default:
-      return (0, import_node_path.join)(
-        process.env.XDG_CONFIG_HOME || (0, import_node_path.join)((0, import_node_os.homedir)(), ".config"),
-        appName
-      );
+      return (0, import_node_path.join)(getUnixConfigHomeDirectory(), appName);
   }
 }
+function getLegacyMacOsConfigDirectory(appName) {
+  return (0, import_node_path.join)((0, import_node_os.homedir)(), "Library", "Application Support", appName);
+}
 function getAuthStateFilePath() {
   return (0, import_node_path.join)(getConfigDirectory(), "auth.json");
 }
@@ -162,8 +251,17 @@ function getConfigStateFilePath() {
   return (0, import_node_path.join)(getConfigDirectory(), "config.json");
 }
 function getLegacyAuthStateFilePath() {
+  if (process.platform === "darwin") {
+    return (0, import_node_path.join)(getLegacyMacOsConfigDirectory("fireside-cli"), "auth.json");
+  }
   return (0, import_node_path.join)(getConfigDirectory("fireside-cli"), "auth.json");
 }
+function getLegacyMacOsAuthStateFilePath() {
+  return (0, import_node_path.join)(getLegacyMacOsConfigDirectory("fireside"), "auth.json");
+}
+function getLegacyMacOsConfigStateFilePath() {
+  return (0, import_node_path.join)(getLegacyMacOsConfigDirectory("fireside"), "config.json");
+}
 async function fileExists(filePath) {
   try {
     await (0, import_promises.access)(filePath);
@@ -215,6 +313,40 @@ function isLegacyAuthState(value) {
   return isAuthState(value) && isConfigState(value);
 }
 async function migrateLegacyState() {
+  const authStateFilePath = getAuthStateFilePath();
+  const configStateFilePath = getConfigStateFilePath();
+  let hasAuthState = await fileExists(authStateFilePath);
+  let hasConfigState = await fileExists(configStateFilePath);
+  if (process.platform === "darwin") {
+    const legacyMacOsAuthState = await readStateFile(
+      getLegacyMacOsAuthStateFilePath()
+    );
+    const legacyMacOsConfigState = await readStateFile(
+      getLegacyMacOsConfigStateFilePath()
+    );
+    if (legacyMacOsAuthState !== null) {
+      if (!isAuthState(legacyMacOsAuthState)) {
+        throw new Error("Invalid legacy auth state file format.");
+      }
+      if (!hasAuthState) {
+        await writeStateFile(authStateFilePath, legacyMacOsAuthState);
+        hasAuthState = true;
+      }
+      await (0, import_promises.rm)(getLegacyMacOsAuthStateFilePath(), { force: true });
+    }
+    if (legacyMacOsConfigState !== null) {
+      if (!isConfigState(legacyMacOsConfigState)) {
+        throw new Error("Invalid legacy config state file format.");
+      }
+      if (!hasConfigState) {
+        await writeStateFile(configStateFilePath, {
+          baseUrl: normalizeBaseUrl(legacyMacOsConfigState.baseUrl)
+        });
+        hasConfigState = true;
+      }
+      await (0, import_promises.rm)(getLegacyMacOsConfigStateFilePath(), { force: true });
+    }
+  }
   const legacyState = await readStateFile(getLegacyAuthStateFilePath());
   if (legacyState === null) {
     return;
@@ -222,18 +354,18 @@ async function migrateLegacyState() {
   if (!isLegacyAuthState(legacyState)) {
     throw new Error("Invalid legacy auth state file format.");
   }
-  const authStateFilePath = getAuthStateFilePath();
-  const configStateFilePath = getConfigStateFilePath();
-  if (!await fileExists(authStateFilePath)) {
+  if (!hasAuthState) {
     await writeStateFile(authStateFilePath, {
       accessToken: legacyState.accessToken,
       createdAt: legacyState.createdAt
     });
+    hasAuthState = true;
   }
-  if (!await fileExists(configStateFilePath)) {
+  if (!hasConfigState) {
     await writeStateFile(configStateFilePath, {
       baseUrl: normalizeBaseUrl(legacyState.baseUrl)
     });
+    hasConfigState = true;
   }
   await (0, import_promises.rm)(getLegacyAuthStateFilePath(), { force: true });
 }
@@ -322,6 +454,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;
 }
@@ -339,15 +534,306 @@ 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) {
+  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 } : {},
+    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) {
+  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);
+    }
+  }
+}
+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("");
   }
@@ -362,49 +848,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,
@@ -416,17 +922,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) => {
@@ -434,8 +943,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(
@@ -444,17 +956,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() {
@@ -468,12 +990,302 @@ 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").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;
+      if (options.json) {
+        console.log(
+          JSON.stringify(
+            serializeTaskEntry(taskEntry, contextRevision),
+            null,
+            2
+          )
+        );
+        return;
+      }
+      printTaskDetails(taskEntry, contextRevision);
+    }
+  )
+);
+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.1",
+  "version": "0.0.3",
   "description": "Fireside CLI",
   "license": "MIT",
   "private": false,
@@ -26,7 +26,8 @@
     "start": "node dist/index.js"
   },
   "dependencies": {
-    "commander": "^14.0.1"
+    "commander": "^14.0.1",
+    "picocolors": "^1.1.1"
   },
   "devDependencies": {
     "tsup": "^8.5.0"