@task-mcp/cli 1.0.21 → 1.0.22

package/dist/index.js

@@ -0,0 +1,818 @@
+#!/usr/bin/env bun
+// @bun
+
+// src/ansi.ts
+import {
+  color,
+  style,
+  styled,
+  c,
+  BOX,
+  box,
+  drawBox,
+  hline,
+  stripAnsi,
+  displayWidth,
+  visibleLength,
+  pad,
+  padEnd,
+  padStart,
+  center,
+  truncateStr,
+  progressBar,
+  sideBySide,
+  sideBySideArrays,
+  table,
+  renderTable,
+  statusColors,
+  statusIcons,
+  icons,
+  formatStatus,
+  priorityColors,
+  formatPriority,
+  formatDependencies,
+  banner
+} from "@task-mcp/shared";
+import { truncateStr as truncateStr2 } from "@task-mcp/shared";
+
+// src/commands/dashboard.ts
+import {
+  renderGlobalDashboard,
+  renderWorkspaceDashboard
+} from "@task-mcp/shared";
+
+// src/storage.ts
+import {
+  TaskStore,
+  InboxStore,
+  StateStore
+} from "@task-mcp/mcp-server/storage";
+var _taskStore = null;
+var _inboxStore = null;
+var _stateStore = null;
+function getTaskStore() {
+  if (!_taskStore) {
+    _taskStore = new TaskStore;
+  }
+  return _taskStore;
+}
+function getInboxStore() {
+  if (!_inboxStore) {
+    _inboxStore = new InboxStore;
+  }
+  return _inboxStore;
+}
+function getStateStore() {
+  if (!_stateStore) {
+    _stateStore = new StateStore;
+  }
+  return _stateStore;
+}
+function getCurrentWorkspace() {
+  return getTaskStore().currentWorkspace;
+}
+async function listWorkspaces() {
+  const taskStore = getTaskStore();
+  const workspaceNames = await taskStore.listWorkspaces();
+  const workspaces = [];
+  for (const name of workspaceNames) {
+    const tasks = await taskStore.list({ workspaces: [name] });
+    workspaces.push({
+      name,
+      taskCount: tasks.length,
+      completedCount: tasks.filter((t) => t.status === "completed").length
+    });
+  }
+  return workspaces;
+}
+async function listTasks() {
+  return getTaskStore().list();
+}
+async function listAllTasks() {
+  return getTaskStore().listAll();
+}
+async function listInboxItems(status) {
+  return getInboxStore().list({ status });
+}
+async function getActiveTag() {
+  return getStateStore().getActiveTag();
+}
+
+// src/commands/dashboard.ts
+async function dashboard(workspaceName) {
+  const workspaces = await listWorkspaces();
+  const activeTag = await getActiveTag();
+  const currentWorkspace = getCurrentWorkspace();
+  if (workspaces.length === 0) {
+    console.log(c.yellow("No tasks found. Create a task first using the MCP server."));
+    return;
+  }
+  let selectedWorkspace;
+  let tasks;
+  if (workspaceName) {
+    selectedWorkspace = workspaces.find((w) => w.name === workspaceName || w.name.startsWith(workspaceName));
+    if (!selectedWorkspace) {
+      console.log(c.error(`Workspace not found: ${workspaceName}`));
+      return;
+    }
+    tasks = await listAllTasks();
+    tasks = tasks.filter((t) => t.workspace === selectedWorkspace.name);
+  } else if (workspaces.length === 1) {
+    selectedWorkspace = workspaces[0];
+    tasks = await listTasks();
+  } else {
+    tasks = await listAllTasks();
+  }
+  const inboxItems = await listInboxItems("pending");
+  const allTasksForLookup = await listAllTasks();
+  const tasksByWorkspace = new Map;
+  for (const task of allTasksForLookup) {
+    const workspaceTasks = tasksByWorkspace.get(task.workspace) ?? [];
+    workspaceTasks.push(task);
+    tasksByWorkspace.set(task.workspace, workspaceTasks);
+  }
+  const getWorkspaceTasks = (ws) => tasksByWorkspace.get(ws) ?? [];
+  let output;
+  if (selectedWorkspace) {
+    output = renderWorkspaceDashboard(selectedWorkspace.name, tasks, { version: VERSION, activeTag });
+  } else {
+    output = renderGlobalDashboard(workspaces, tasks, inboxItems, getWorkspaceTasks, { version: VERSION, activeTag });
+  }
+  console.log(output);
+}
+
+// src/constants.ts
+var MENU_SEPARATOR_WIDTH = 40;
+var LIST_SEPARATOR_WIDTH = 50;
+var ERROR_MESSAGE_DELAY_MS = 1000;
+var WELCOME_SCREEN_DELAY_MS = 1000;
+var COLUMN_WIDTH_ID = 6;
+var COLUMN_WIDTH_TITLE = 45;
+var COLUMN_WIDTH_PROJECT_NAME = 30;
+var COLUMN_WIDTH_STATUS = 14;
+var COLUMN_WIDTH_PRIORITY = 10;
+var COLUMN_WIDTH_DATE = 12;
+var INBOX_PROMOTE_TITLE_MAX_LENGTH = 100;
+var INBOX_DISCARD_PREVIEW_LENGTH = 50;
+var ID_DISPLAY_LENGTH = 4;
+
+// src/commands/list.ts
+function formatDate(dateStr) {
+  if (!dateStr)
+    return c.gray("-");
+  const date = new Date(dateStr);
+  return date.toLocaleDateString();
+}
+async function listTasksCmd(options) {
+  let tasks;
+  if (options.workspace) {
+    const allTasks = await listAllTasks();
+    tasks = allTasks.filter((t) => t.workspace === options.workspace || t.workspace.startsWith(options.workspace));
+  } else {
+    tasks = await listTasks();
+  }
+  if (options.status) {
+    const statuses = options.status.split(",");
+    tasks = tasks.filter((t) => statuses.includes(t.status));
+  } else if (!options.all) {
+    tasks = tasks.filter((t) => t.status !== "completed" && t.status !== "cancelled");
+  }
+  if (options.priority) {
+    const priorities = options.priority.split(",");
+    tasks = tasks.filter((t) => priorities.includes(t.priority));
+  }
+  if (tasks.length === 0) {
+    console.log(c.gray("No tasks found."));
+    return;
+  }
+  const currentWorkspace = getCurrentWorkspace();
+  console.log(c.bold(`
+Tasks (${tasks.length}) - ${c.cyan(currentWorkspace)}
+`));
+  const columns = [
+    { header: "ID", key: "id", width: COLUMN_WIDTH_ID, format: (v) => c.cyan(String(v).slice(0, ID_DISPLAY_LENGTH)) },
+    { header: "Title", key: "title", width: COLUMN_WIDTH_TITLE },
+    { header: "Status", key: "status", width: COLUMN_WIDTH_STATUS, format: (v) => formatStatus(v) },
+    { header: "Priority", key: "priority", width: COLUMN_WIDTH_PRIORITY, format: (v) => formatPriority(v) },
+    { header: "Due", key: "dueDate", width: COLUMN_WIDTH_DATE, format: (v) => formatDate(v) }
+  ];
+  console.log(table(tasks, columns));
+  console.log();
+}
+async function listWorkspacesCmd() {
+  const workspaces = await listWorkspaces();
+  const currentWorkspace = getCurrentWorkspace();
+  if (workspaces.length === 0) {
+    console.log(c.gray("No workspaces found."));
+    return;
+  }
+  console.log(c.bold(`
+Workspaces (${workspaces.length})
+`));
+  const workspacesWithCurrent = workspaces.map((ws) => ({
+    ...ws,
+    current: ws.name === currentWorkspace ? c.green("\u25CF") : "",
+    progress: `${ws.completedCount}/${ws.taskCount}`
+  }));
+  const columns = [
+    { header: "", key: "current", width: 2 },
+    { header: "Name", key: "name", width: COLUMN_WIDTH_PROJECT_NAME, format: (v) => c.cyan(String(v)) },
+    { header: "Tasks", key: "progress", width: COLUMN_WIDTH_PRIORITY }
+  ];
+  console.log(table(workspacesWithCurrent, columns));
+  console.log();
+}
+
+// src/interactive.ts
+import * as readline from "readline";
+async function prompt(question) {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.trim());
+    });
+  });
+}
+async function showMenu(title, options) {
+  console.clear();
+  console.log(banner("TASK MCP"));
+  console.log();
+  console.log(c.bold(c.cyan(title)));
+  console.log(c.dim("\u2500".repeat(MENU_SEPARATOR_WIDTH)));
+  console.log();
+  for (const opt of options) {
+    const desc = opt.description ? c.dim(` - ${opt.description}`) : "";
+    console.log(`  ${c.yellow(opt.key)}  ${opt.label}${desc}`);
+  }
+  console.log();
+  const choice = await prompt(c.cyan("Select option: "));
+  const selected = options.find((o) => o.key.toLowerCase() === choice.toLowerCase());
+  if (selected) {
+    await selected.action();
+  } else if (choice !== "") {
+    console.log(c.error(`Invalid option: ${choice}`));
+    await sleep(ERROR_MESSAGE_DELAY_MS);
+  }
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function waitForKey(message = "Press Enter to continue...") {
+  await prompt(c.dim(message));
+}
+async function mainMenu() {
+  const options = [
+    {
+      key: "d",
+      label: "Dashboard",
+      description: "View workspace dashboard",
+      action: async () => {
+        await dashboardMenu();
+      }
+    },
+    {
+      key: "w",
+      label: "Workspaces",
+      description: "List workspaces",
+      action: async () => {
+        await workspacesMenu();
+      }
+    },
+    {
+      key: "t",
+      label: "Tasks",
+      description: "List and filter tasks",
+      action: async () => {
+        await tasksMenu();
+      }
+    },
+    {
+      key: "x",
+      label: "Exit",
+      description: "Exit interactive mode",
+      action: () => {
+        console.log(c.dim("Goodbye!"));
+        process.exit(0);
+      }
+    }
+  ];
+  await showMenu("Main Menu", options);
+  return true;
+}
+async function dashboardMenu() {
+  console.clear();
+  console.log(c.bold(c.cyan("Dashboard")));
+  console.log(c.dim("\u2500".repeat(MENU_SEPARATOR_WIDTH)));
+  console.log();
+  const workspace = await prompt(c.cyan("Workspace name (Enter for current): "));
+  console.log();
+  await dashboard(workspace || undefined);
+  console.log();
+  await waitForKey();
+}
+async function workspacesMenu() {
+  const options = [
+    {
+      key: "l",
+      label: "List Workspaces",
+      action: async () => {
+        console.clear();
+        await listWorkspacesCmd();
+        console.log();
+        await waitForKey();
+      }
+    },
+    {
+      key: "b",
+      label: "Back to Main Menu",
+      action: () => {}
+    }
+  ];
+  await showMenu("Workspaces", options);
+}
+async function tasksMenu() {
+  const options = [
+    {
+      key: "l",
+      label: "List All Tasks",
+      action: async () => {
+        console.clear();
+        await listTasksCmd({ all: false });
+        console.log();
+        await waitForKey();
+      }
+    },
+    {
+      key: "p",
+      label: "Filter by Priority",
+      action: async () => {
+        console.clear();
+        const priority = await prompt(c.cyan("Priority (critical/high/medium/low): "));
+        if (priority) {
+          await listTasksCmd({ priority });
+        }
+        console.log();
+        await waitForKey();
+      }
+    },
+    {
+      key: "s",
+      label: "Filter by Status",
+      action: async () => {
+        console.clear();
+        const status = await prompt(c.cyan("Status (pending/in_progress/blocked/completed): "));
+        if (status) {
+          await listTasksCmd({ status });
+        }
+        console.log();
+        await waitForKey();
+      }
+    },
+    {
+      key: "a",
+      label: "All (include completed)",
+      action: async () => {
+        console.clear();
+        await listTasksCmd({ all: true });
+        console.log();
+        await waitForKey();
+      }
+    },
+    {
+      key: "b",
+      label: "Back to Main Menu",
+      action: () => {}
+    }
+  ];
+  await showMenu("Tasks", options);
+}
+async function startInteractive() {
+  console.clear();
+  console.log(banner("TASK MCP"));
+  console.log();
+  console.log(c.bold("Welcome to Task MCP Interactive Mode"));
+  console.log(c.dim("Navigate using keyboard shortcuts"));
+  console.log();
+  await sleep(WELCOME_SCREEN_DELAY_MS);
+  while (true) {
+    try {
+      await mainMenu();
+    } catch (error) {
+      if (error instanceof Error && error.message.includes("readline was closed")) {
+        console.log();
+        console.log(c.dim("Goodbye!"));
+        process.exit(0);
+      }
+      throw error;
+    }
+  }
+}
+
+// src/commands/inbox.ts
+import { parseInboxInput } from "@task-mcp/shared";
+async function inboxAddCmd(options) {
+  const parsed = parseInboxInput(options.content);
+  const inboxStore = getInboxStore();
+  const item = await inboxStore.add({
+    content: parsed.content,
+    source: options.source ?? "cli",
+    tags: parsed.tags
+  });
+  console.log();
+  console.log(c.green("\u2713") + " Captured to inbox");
+  console.log();
+  console.log("  " + c.dim("ID:") + " " + c.cyan(item.id));
+  console.log("  " + c.dim("Content:") + " " + item.content);
+  if (parsed.tags?.length) {
+    console.log("  " + c.dim("Tags:") + " " + parsed.tags.map((t) => c.yellow("#" + t)).join(" "));
+  }
+  console.log();
+  console.log(c.dim("Use 'task inbox promote " + item.id + "' to convert to task"));
+  console.log();
+}
+async function inboxListCmd(options) {
+  const status = options.all ? undefined : options.status ?? "pending";
+  const inboxStore = getInboxStore();
+  const items = await inboxStore.list({ status });
+  console.log();
+  if (items.length === 0) {
+    console.log(c.dim(status ? `No ${status} items in inbox.` : "Inbox is empty."));
+    console.log();
+    return;
+  }
+  const title = status ? `Inbox (${status})` : "Inbox (all)";
+  console.log(c.bold(c.cyan(title)) + c.dim(` - ${items.length} items`));
+  console.log(c.dim("\u2500".repeat(LIST_SEPARATOR_WIDTH)));
+  console.log();
+  for (const item of items) {
+    const statusIcon = item.status === "pending" ? c.yellow("\u25CB") : item.status === "promoted" ? c.green("\u2713") : c.dim("\xD7");
+    const date = new Date(item.capturedAt).toLocaleDateString();
+    const tags = item.tags?.length ? " " + item.tags.map((t) => c.dim("#" + t)).join(" ") : "";
+    console.log(`${statusIcon} ${c.cyan(item.id)} ${c.dim("(" + date + ")")}`);
+    console.log(`  ${item.content}${tags}`);
+    if (item.promotedToTaskId) {
+      console.log(`  ${c.dim("\u2192 Task:")} ${c.green(item.promotedToTaskId)}`);
+    }
+    console.log();
+  }
+}
+async function inboxGetCmd(itemId) {
+  const inboxStore = getInboxStore();
+  const item = await inboxStore.get(itemId);
+  if (!item) {
+    console.log();
+    console.log(c.error(`Inbox item not found: ${itemId}`));
+    console.log();
+    return;
+  }
+  console.log();
+  console.log(c.bold(c.cyan("Inbox Item")));
+  console.log(c.dim("\u2500".repeat(MENU_SEPARATOR_WIDTH)));
+  console.log();
+  console.log("  " + c.dim("ID:") + " " + item.id);
+  console.log("  " + c.dim("Status:") + " " + formatStatus(item.status));
+  console.log("  " + c.dim("Captured:") + " " + new Date(item.capturedAt).toLocaleString());
+  if (item.source) {
+    console.log("  " + c.dim("Source:") + " " + item.source);
+  }
+  if (item.tags?.length) {
+    console.log("  " + c.dim("Tags:") + " " + item.tags.map((t) => c.yellow("#" + t)).join(" "));
+  }
+  console.log();
+  console.log(c.bold("Content:"));
+  console.log("  " + item.content);
+  if (item.promotedToTaskId) {
+    console.log();
+    console.log(c.green("\u2192 Promoted to: " + item.promotedToTaskId));
+  }
+  console.log();
+}
+async function inboxPromoteCmd(options) {
+  const inboxStore = getInboxStore();
+  const taskStore = getTaskStore();
+  const item = await inboxStore.get(options.itemId);
+  if (!item) {
+    console.log();
+    console.log(c.error(`Inbox item not found: ${options.itemId}`));
+    console.log();
+    return;
+  }
+  if (item.status === "promoted") {
+    console.log();
+    console.log(c.warning(`Item already promoted to: ${item.promotedToTaskId}`));
+    console.log();
+    return;
+  }
+  const task = await taskStore.create({
+    title: options.title ?? item.content.slice(0, INBOX_PROMOTE_TITLE_MAX_LENGTH),
+    description: item.content,
+    priority: options.priority ?? "medium",
+    tags: item.tags
+  });
+  await inboxStore.promote(options.itemId, task.id);
+  console.log();
+  console.log(c.green("\u2713") + " Promoted to task");
+  console.log();
+  console.log("  " + c.dim("Task ID:") + " " + c.cyan(task.id));
+  console.log("  " + c.dim("Title:") + " " + task.title);
+  console.log("  " + c.dim("Workspace:") + " " + task.workspace);
+  console.log("  " + c.dim("Priority:") + " " + formatPriority(task.priority));
+  console.log();
+}
+async function inboxDiscardCmd(itemId) {
+  const inboxStore = getInboxStore();
+  const item = await inboxStore.discard(itemId);
+  if (!item) {
+    console.log();
+    console.log(c.error(`Inbox item not found: ${itemId}`));
+    console.log();
+    return;
+  }
+  console.log();
+  console.log(c.dim("\xD7") + " Discarded: " + item.content.slice(0, INBOX_DISCARD_PREVIEW_LENGTH) + "...");
+  console.log();
+}
+async function inboxDeleteCmd(itemId) {
+  const inboxStore = getInboxStore();
+  const deleted = await inboxStore.delete(itemId);
+  if (!deleted) {
+    console.log();
+    console.log(c.error(`Inbox item not found: ${itemId}`));
+    console.log();
+    return;
+  }
+  console.log();
+  console.log(c.green("\u2713") + " Deleted: " + itemId);
+  console.log();
+}
+async function inboxCountCmd() {
+  const inboxStore = getInboxStore();
+  const count = await inboxStore.getPendingCount();
+  console.log();
+  if (count > 0) {
+    console.log(c.yellow("\uD83D\uDCE5") + ` ${count} pending item${count === 1 ? "" : "s"} in inbox`);
+  } else {
+    console.log(c.dim("Inbox is empty"));
+  }
+  console.log();
+}
+// package.json
+var package_default = {
+  name: "@task-mcp/cli",
+  version: "1.0.21",
+  description: "Zero-dependency CLI for task-mcp with Bun native visualization",
+  type: "module",
+  bin: {
+    task: "./dist/index.js"
+  },
+  main: "./dist/index.js",
+  files: [
+    "dist",
+    "README.md"
+  ],
+  scripts: {
+    build: "bun build ./src/index.ts --outdir ./dist --target bun --external @task-mcp/shared --external @task-mcp/mcp-server",
+    dev: "bun run ./src/index.ts",
+    dashboard: "bun run ./src/index.ts dashboard",
+    typecheck: "bun --bun tsc --noEmit"
+  },
+  keywords: [
+    "task-mcp",
+    "cli",
+    "task-management",
+    "terminal",
+    "dashboard"
+  ],
+  author: "addsalt1t",
+  license: "MIT",
+  repository: {
+    type: "git",
+    url: "git+https://github.com/addsalt1t/task-mcp.git",
+    directory: "packages/cli"
+  },
+  dependencies: {
+    "@task-mcp/mcp-server": "workspace:*",
+    "@task-mcp/shared": "workspace:*"
+  },
+  devDependencies: {
+    "@types/bun": "^1.1.14",
+    typescript: "^5.7.2"
+  }
+};
+
+// src/index.ts
+var VERSION = package_default.version;
+function parseArgs(argv) {
+  const args = argv.slice(2);
+  const flags = {};
+  const positional = [];
+  for (let i = 0;i < args.length; i++) {
+    const arg = args[i];
+    if (arg.startsWith("--")) {
+      const [key, value] = arg.slice(2).split("=");
+      if (value !== undefined) {
+        flags[key] = value;
+      } else if (args[i + 1] && !args[i + 1].startsWith("-")) {
+        flags[key] = args[++i];
+      } else {
+        flags[key] = true;
+      }
+    } else if (arg.startsWith("-") && arg.length === 2) {
+      const key = arg.slice(1);
+      if (args[i + 1] && !args[i + 1].startsWith("-")) {
+        flags[key] = args[++i];
+      } else {
+        flags[key] = true;
+      }
+    } else {
+      positional.push(arg);
+    }
+  }
+  return {
+    command: positional[0] ?? "dashboard",
+    args: positional.slice(1),
+    flags
+  };
+}
+function showHelp() {
+  console.log(`
+${c.cyan(c.bold("Task MCP CLI"))} ${c.gray(`v${VERSION}`)}
+${c.dim("Zero-dependency terminal visualization for task-mcp")}
+
+${c.yellow("USAGE")}
+  ${c.bold("task")} [command] [options]
+
+${c.yellow("COMMANDS")}
+  ${c.cyan("dashboard")} [workspace]    Show workspace dashboard (default)
+  ${c.cyan("d")} [workspace]            Alias for dashboard
+  ${c.cyan("list")}                     List all tasks
+  ${c.cyan("ls")}                       Alias for list
+  ${c.cyan("workspaces")}               List all workspaces
+  ${c.cyan("ws")}                       Alias for workspaces
+  ${c.cyan("inbox")} <subcommand>       Manage inbox (add/list/get/promote/discard)
+  ${c.cyan("interactive")}              Start interactive mode
+  ${c.cyan("i")}                        Alias for interactive
+  ${c.cyan("help")}                     Show this help message
+  ${c.cyan("version")}                  Show version
+
+${c.yellow("INBOX SUBCOMMANDS")}
+  ${c.cyan("inbox")} "content"          Quick capture to inbox
+  ${c.cyan("inbox add")} "content"      Add item with natural language
+  ${c.cyan("inbox list")}               List pending items
+  ${c.cyan("inbox get")} <id>           Show item details
+  ${c.cyan("inbox promote")} <id>       Promote to task
+  ${c.cyan("inbox discard")} <id>       Discard item
+  ${c.cyan("inbox count")}              Show pending count
+
+${c.yellow("OPTIONS")}
+  ${c.cyan("-i, --interactive")}        Start interactive mode
+  ${c.cyan("--status")} <status>        Filter tasks by status (pending,in_progress,blocked,completed,cancelled)
+  ${c.cyan("--priority")} <priority>    Filter tasks by priority (critical,high,medium,low)
+  ${c.cyan("--all")}                    Include completed/cancelled tasks
+
+${c.yellow("EXAMPLES")}
+  ${c.dim("# Show dashboard for all projects")}
+  task
+
+  ${c.dim("# Show dashboard for a specific project")}
+  task dashboard proj_abc123
+
+  ${c.dim("# List pending high-priority tasks")}
+  task list --status pending --priority high
+
+  ${c.dim("# List all workspaces")}
+  task workspaces --all
+`);
+}
+function showVersion() {
+  console.log(`task-mcp-cli v${VERSION}`);
+}
+async function handleInboxCommand(args, flags) {
+  const subcommand = args[0];
+  const subcommands = ["add", "list", "ls", "get", "promote", "discard", "delete", "count"];
+  if (subcommand && !subcommands.includes(subcommand)) {
+    await inboxAddCmd({ content: args.join(" ") });
+    return;
+  }
+  switch (subcommand) {
+    case "add":
+      if (!args[1]) {
+        console.log(c.error('Usage: task inbox add "content"'));
+        return;
+      }
+      await inboxAddCmd({ content: args.slice(1).join(" ") });
+      break;
+    case "list":
+    case "ls":
+      await inboxListCmd({
+        all: flags.all === true,
+        status: flags.status
+      });
+      break;
+    case "get":
+      if (!args[1]) {
+        console.log(c.error("Usage: task inbox get <item-id>"));
+        return;
+      }
+      await inboxGetCmd(args[1]);
+      break;
+    case "promote":
+      if (!args[1]) {
+        console.log(c.error("Usage: task inbox promote <item-id> [--priority <p>]"));
+        return;
+      }
+      await inboxPromoteCmd({
+        itemId: args[1],
+        title: flags.title,
+        priority: flags.priority
+      });
+      break;
+    case "discard":
+      if (!args[1]) {
+        console.log(c.error("Usage: task inbox discard <item-id>"));
+        return;
+      }
+      await inboxDiscardCmd(args[1]);
+      break;
+    case "delete":
+      if (!args[1]) {
+        console.log(c.error("Usage: task inbox delete <item-id>"));
+        return;
+      }
+      await inboxDeleteCmd(args[1]);
+      break;
+    case "count":
+      await inboxCountCmd();
+      break;
+    default:
+      await inboxListCmd({ all: false });
+      break;
+  }
+}
+async function main() {
+  const { command, args, flags } = parseArgs(process.argv);
+  if (flags.i === true || flags.interactive === true) {
+    await startInteractive();
+    return;
+  }
+  try {
+    switch (command) {
+      case "dashboard":
+      case "d":
+        await dashboard(args[0]);
+        break;
+      case "list":
+      case "ls":
+        await listTasksCmd({
+          workspace: args[0],
+          status: flags.status,
+          priority: flags.priority,
+          all: flags.all === true
+        });
+        break;
+      case "workspaces":
+      case "ws":
+        await listWorkspacesCmd();
+        break;
+      case "interactive":
+      case "i":
+        await startInteractive();
+        break;
+      case "inbox":
+        await handleInboxCommand(args, flags);
+        break;
+      case "help":
+      case "-h":
+      case "--help":
+        showHelp();
+        break;
+      case "version":
+      case "-v":
+      case "--version":
+        showVersion();
+        break;
+      default:
+        console.log(c.error(`Unknown command: ${command}`));
+        console.log(c.dim("Run 'task help' for usage information."));
+        process.exit(1);
+    }
+  } catch (error) {
+    if (error instanceof Error) {
+      console.error(c.error(`Error: ${error.message}`));
+    } else {
+      console.error(c.error("An unexpected error occurred"));
+    }
+    process.exit(1);
+  }
+}
+if (import.meta.main) {
+  main();
+}
+export {
+  parseArgs,
+  VERSION
+};