@nijaru/tk 0.0.1

package/src/cli.ts

@@ -0,0 +1,871 @@
+#!/usr/bin/env bun
+import { parseArgs } from "util";
+import { version } from "../package.json";
+
+import * as storage from "./db/storage";
+import { parsePriority } from "./lib/priority";
+import { formatTaskList, formatTaskDetail, formatJson, formatConfig } from "./lib/format";
+import { findRoot, setWorkingDir } from "./lib/root";
+import { parseId } from "./types";
+import type { Status } from "./types";
+import { BASH_COMPLETION, ZSH_COMPLETION, FISH_COMPLETION } from "./lib/completions";
+
+const VALID_STATUSES: Status[] = ["open", "active", "done"];
+const PROJECT_PATTERN = /^[a-z][a-z0-9]*$/;
+
+function validateProject(name: string): void {
+  if (!PROJECT_PATTERN.test(name)) {
+    throw new Error(
+      `Invalid project name: ${name}. Use lowercase letters and numbers, starting with a letter.`,
+    );
+  }
+}
+
+function parseStatus(input: string | undefined): Status | undefined {
+  if (!input) return undefined;
+  if (!VALID_STATUSES.includes(input as Status)) {
+    throw new Error(`Invalid status: ${input}. Use: ${VALID_STATUSES.join(", ")}`);
+  }
+  return input as Status;
+}
+
+function parseLimit(input: string | undefined): number | undefined {
+  if (!input) return undefined;
+  const n = parseInt(input, 10);
+  if (isNaN(n) || n < 1) {
+    throw new Error(`Invalid limit: ${input}. Must be a positive number.`);
+  }
+  return n;
+}
+
+function parseEstimate(input: string | undefined): number | undefined {
+  if (!input) return undefined;
+  const n = parseInt(input, 10);
+  if (isNaN(n) || n < 0) {
+    throw new Error(`Invalid estimate: ${input}. Must be a non-negative number.`);
+  }
+  return n;
+}
+
+function parseDueDate(input: string | undefined): string | undefined {
+  if (!input) return undefined;
+  if (input === "-") return undefined; // clear
+
+  // Handle relative dates like +7d
+  if (input.startsWith("+")) {
+    const match = input.match(/^\+(\d+)([dwmh])$/);
+    if (match && match[1] && match[2]) {
+      const num = match[1];
+      const unit = match[2];
+      const n = parseInt(num, 10);
+      const now = new Date();
+      switch (unit) {
+        case "h":
+          now.setHours(now.getHours() + n);
+          break;
+        case "d":
+          now.setDate(now.getDate() + n);
+          break;
+        case "w":
+          now.setDate(now.getDate() + n * 7);
+          break;
+        case "m":
+          now.setMonth(now.getMonth() + n);
+          break;
+      }
+      return now.toISOString().split("T")[0];
+    }
+    throw new Error(`Invalid relative date: ${input}. Use format like +7d, +2w, +1m`);
+  }
+
+  // Validate and normalize to YYYY-MM-DD
+  const date = new Date(input);
+  if (isNaN(date.getTime())) {
+    throw new Error(`Invalid date: ${input}. Use YYYY-MM-DD or +Nd format.`);
+  }
+  return date.toISOString().split("T")[0];
+}
+
+function parseLabels(input: string | undefined): string[] | undefined {
+  if (!input) return undefined;
+  return input
+    .split(",")
+    .map((l) => l.trim())
+    .filter(Boolean);
+}
+
+function parseAssignees(input: string | undefined): string[] | undefined {
+  if (!input) return undefined;
+  // Expand @me to git user
+  const assignees = input
+    .split(",")
+    .map((a) => a.trim())
+    .filter(Boolean);
+  return assignees.map((a) => {
+    if (a === "@me") {
+      try {
+        const result = Bun.spawnSync(["git", "config", "user.name"]);
+        if (result.success) {
+          return result.stdout.toString().trim() || a;
+        }
+      } catch {
+        // Fall through to return @me
+      }
+    }
+    return a;
+  });
+}
+
+function resolveId(input: string | undefined, context: string): string {
+  if (!input) {
+    throw new Error(`ID required: tk ${context} <id>`);
+  }
+
+  // Try to resolve ambiguous ID (just a number)
+  const resolved = storage.resolveId(input);
+  if (resolved) return resolved;
+
+  // Check if it's a valid full ID
+  if (parseId(input)) return input;
+
+  throw new Error(
+    `Invalid task ID: ${input}. Use format like tk-a1b2, or just the ref (a1b2) if unambiguous.`,
+  );
+}
+
+const rawArgs = process.argv.slice(2);
+
+// Global flags that can appear anywhere in the command
+const GLOBAL_FLAGS = new Set(["--json", "--help", "-h", "--version", "-V"]);
+
+function isFlag(arg: string): boolean {
+  return arg.startsWith("-");
+}
+
+// Extract -C <dir> flag (can appear anywhere)
+let dirFlag: string | null = null;
+const argsWithoutDir: string[] = [];
+for (let i = 0; i < rawArgs.length; i++) {
+  const arg = rawArgs[i];
+  if (arg === "-C" && rawArgs[i + 1]) {
+    dirFlag = rawArgs[i + 1]!;
+    i++; // skip next arg
+  } else {
+    argsWithoutDir.push(arg!);
+  }
+}
+if (dirFlag) {
+  setWorkingDir(dirFlag);
+}
+
+// Extract global flags from anywhere in args
+const jsonFlag = argsWithoutDir.includes("--json");
+const helpFlag = argsWithoutDir.includes("--help") || argsWithoutDir.includes("-h");
+const versionFlag = argsWithoutDir.includes("--version") || argsWithoutDir.includes("-V");
+
+// Find command: first non-flag argument
+const command = argsWithoutDir.find((arg) => !isFlag(arg));
+
+// Get args for command: everything except the command itself and global flags
+const args = argsWithoutDir.filter((arg) => arg !== command && !GLOBAL_FLAGS.has(arg));
+
+function output(data: unknown, formatted: string) {
+  console.log(jsonFlag ? formatJson(data) : formatted);
+}
+
+function error(message: string): never {
+  console.error(`Error: ${message}`);
+  process.exit(1);
+}
+
+function showHelp() {
+  console.log(`tk v${version} - Task tracker for AI agents
+
+USAGE:
+  tk <command> [options]
+
+COMMANDS:
+  init         Initialize .tasks/ directory
+  add          Create task
+  ls, list     List tasks
+  ready        List ready tasks (open + unblocked)
+  show         Show task details
+  start        Start working (open -> active)
+  done         Complete task
+  reopen       Reopen task
+  edit         Edit task
+  log          Add log entry
+  block        Add blocker
+  unblock      Remove blocker
+  rm, remove   Delete task
+  clean        Remove old done tasks
+  config       Show/set configuration
+  completions  Output shell completions
+
+GLOBAL OPTIONS:
+  -C <dir>     Run in different directory
+  --json       Output as JSON
+  -h, --help   Show help
+  -V           Show version
+
+Run 'tk <command> --help' for command-specific options.
+`);
+}
+
+function showCommandHelp(cmd: string) {
+  const helps: Record<string, string> = {
+    init: `tk init - Initialize .tasks/ directory
+
+USAGE:
+  tk init [options]
+
+OPTIONS:
+  -P, --project <name>   Set default project name
+`,
+    add: `tk add - Create a new task
+
+USAGE:
+  tk add <title> [options]
+
+OPTIONS:
+  -p, --priority <0-4>       Priority (0=none, 1=urgent, 2=high, 3=medium, 4=low)
+  -P, --project <name>       Project prefix for ID
+  -d, --description <text>   Description
+  -l, --labels <csv>         Labels (comma-separated)
+  -A, --assignees <csv>      Assignees (comma-separated, @me for git user)
+  --parent <id>              Parent task ID
+  --estimate <n>             Estimate (user-defined units)
+  --due <date>               Due date (YYYY-MM-DD or +Nh/+Nd/+Nw/+Nm)
+
+EXAMPLES:
+  tk add "Fix login bug" -p 1
+  tk add "New feature" -P api -l bug,urgent
+  tk add "Sprint task" --due +7d
+`,
+    ls: `tk ls - List tasks
+
+USAGE:
+  tk ls [options]
+
+OPTIONS:
+  -s, --status <status>   Filter by status (open, active, done)
+  -p, --priority <0-4>    Filter by priority
+  -P, --project <name>    Filter by project
+  -l, --label <label>     Filter by label
+  --assignee <name>       Filter by assignee
+  --parent <id>           Filter by parent
+  --roots                 Show only root tasks (no parent)
+  --overdue               Show only overdue tasks
+  -n, --limit <n>         Limit results (default: 20)
+  -a, --all               Show all (no limit)
+
+EXAMPLES:
+  tk ls -s open -p 1      # Urgent open tasks
+  tk ls --overdue         # Overdue tasks
+  tk ls -P api --roots    # Root tasks in api project
+`,
+    list: `tk list - List tasks (alias for 'ls')
+
+Run 'tk ls --help' for options.
+`,
+    ready: `tk ready - List ready tasks (open + unblocked)
+
+USAGE:
+  tk ready
+
+Shows open tasks that are not blocked by any incomplete task.
+`,
+    show: `tk show - Show task details
+
+USAGE:
+  tk show <id>
+
+EXAMPLES:
+  tk show tk-1
+  tk show 1        # If unambiguous
+`,
+    start: `tk start - Start working on a task
+
+USAGE:
+  tk start <id>
+
+Changes status from open to active.
+`,
+    done: `tk done - Complete a task
+
+USAGE:
+  tk done <id>
+
+Changes status to done.
+`,
+    reopen: `tk reopen - Reopen a task
+
+USAGE:
+  tk reopen <id>
+
+Changes status back to open.
+`,
+    edit: `tk edit - Edit a task
+
+USAGE:
+  tk edit <id> [options]
+
+OPTIONS:
+  -t, --title <text>         New title
+  -d, --description <text>   New description
+  -p, --priority <0-4>       New priority
+  -l, --labels <csv>         Replace labels (use +tag/-tag to add/remove)
+  -A, --assignees <csv>      Replace assignees
+  --parent <id>              Set parent (use - to clear)
+  --estimate <n>             Set estimate (use - to clear)
+  --due <date>               Set due date (use - to clear)
+
+EXAMPLES:
+  tk edit tk-1 -t "New title"
+  tk edit tk-1 -l +urgent     # Add label
+  tk edit tk-1 --due -        # Clear due date
+`,
+    log: `tk log - Add a log entry to a task
+
+USAGE:
+  tk log <id> <message>
+
+EXAMPLES:
+  tk log tk-1 "Started implementation"
+  tk log tk-1 "Blocked on API changes"
+`,
+    block: `tk block - Add a blocker dependency
+
+USAGE:
+  tk block <task> <blocker>
+
+The first task becomes blocked by the second.
+
+EXAMPLES:
+  tk block tk-2 tk-1    # tk-2 is blocked by tk-1
+`,
+    unblock: `tk unblock - Remove a blocker dependency
+
+USAGE:
+  tk unblock <task> <blocker>
+
+EXAMPLES:
+  tk unblock tk-2 tk-1
+`,
+    rm: `tk rm - Delete a task
+
+USAGE:
+  tk rm <id>
+
+EXAMPLES:
+  tk rm tk-1
+`,
+    remove: `tk remove - Delete a task (alias for 'rm')
+
+USAGE:
+  tk remove <id>
+`,
+    clean: `tk clean - Remove old completed tasks
+
+USAGE:
+  tk clean [options]
+
+OPTIONS:
+  --older-than <duration>   Age threshold (default: 7d)
+  -a, --all                 Remove all done tasks (ignore age)
+
+DURATION FORMAT:
+  7d = 7 days, 2w = 2 weeks, 24h = 24 hours
+
+EXAMPLES:
+  tk clean                  # Remove done tasks older than 7 days
+  tk clean --older-than 30d
+  tk clean -a               # Remove all done tasks
+`,
+    config: `tk config - Show or set configuration
+
+USAGE:
+  tk config                              Show all config
+  tk config project                      Show default project
+  tk config project <name>               Set default project
+  tk config project <new> --rename <old> Rename project (old-* → new-*)
+  tk config alias                        List aliases
+  tk config alias <name> <path>          Add alias
+  tk config alias --rm <name>            Remove alias
+
+EXAMPLES:
+  tk config project api
+  tk config project lsmvec --rename cloudlsmvec
+  tk config alias web src/web
+`,
+    completions: `tk completions - Output shell completions
+
+USAGE:
+  tk completions <shell>
+
+SHELLS:
+  bash   Bash completion script
+  zsh    Zsh completion script
+  fish   Fish completion script
+
+EXAMPLES:
+  eval "$(tk completions bash)"   # Add to ~/.bashrc
+  eval "$(tk completions zsh)"    # Add to ~/.zshrc
+`,
+  };
+
+  const help = helps[cmd];
+  if (help) {
+    console.log(help);
+  } else {
+    console.error(`Unknown command: ${cmd}. Run 'tk --help' for usage.`);
+    process.exit(1);
+  }
+}
+
+function main() {
+  if (versionFlag) {
+    console.log(`tk v${version}`);
+    return;
+  }
+
+  if (!command) {
+    showHelp();
+    return;
+  }
+
+  // Handle 'tk help' and 'tk help <command>'
+  if (command === "help") {
+    const subcommand = args[0];
+    if (subcommand) {
+      showCommandHelp(subcommand);
+    } else {
+      showHelp();
+    }
+    return;
+  }
+
+  if (helpFlag) {
+    showCommandHelp(command);
+    return;
+  }
+
+  switch (command) {
+    case "init": {
+      const { values } = parseArgs({
+        args,
+        options: {
+          project: { type: "string", short: "P" },
+        },
+        allowPositionals: true,
+      });
+      if (values.project) {
+        validateProject(values.project);
+      }
+      const info = findRoot();
+      if (info.exists) {
+        output({ path: info.tasksDir, created: false }, `Already initialized: ${info.tasksDir}`);
+      } else {
+        const path = storage.initTasks(values.project);
+        output({ path, created: true }, `Initialized: ${path}`);
+      }
+      break;
+    }
+
+    case "add": {
+      const { values, positionals } = parseArgs({
+        args,
+        options: {
+          description: { type: "string", short: "d" },
+          priority: { type: "string", short: "p" },
+          project: { type: "string", short: "P" },
+          labels: { type: "string", short: "l" },
+          assignees: { type: "string", short: "A" },
+          parent: { type: "string" },
+          estimate: { type: "string" },
+          due: { type: "string" },
+        },
+        allowPositionals: true,
+      });
+      const title = positionals[0]?.trim();
+      if (!title) error("Title required: tk add <title>");
+
+      // Validate project if provided
+      if (values.project) {
+        validateProject(values.project);
+      }
+
+      // Resolve and validate parent if provided
+      let parentId: string | undefined;
+      if (values.parent) {
+        const resolved = storage.resolveId(values.parent);
+        if (!resolved) error(`Parent task not found: ${values.parent}`);
+        parentId = resolved;
+        const parentResult = storage.validateParent(parentId);
+        if (!parentResult.ok) error(parentResult.error!);
+      }
+
+      const task = storage.createTask({
+        title,
+        description: values.description,
+        priority: parsePriority(values.priority),
+        project: values.project,
+        labels: parseLabels(values.labels),
+        assignees: parseAssignees(values.assignees),
+        parent: parentId,
+        estimate: parseEstimate(values.estimate),
+        due_date: parseDueDate(values.due),
+      });
+      output(task, task.id);
+      break;
+    }
+
+    case "ls":
+    case "list": {
+      const { values } = parseArgs({
+        args,
+        options: {
+          status: { type: "string", short: "s" },
+          priority: { type: "string", short: "p" },
+          project: { type: "string", short: "P" },
+          label: { type: "string", short: "l" },
+          assignee: { type: "string" },
+          parent: { type: "string" },
+          roots: { type: "boolean" },
+          overdue: { type: "boolean" },
+          limit: { type: "string", short: "n" },
+          all: { type: "boolean", short: "a" },
+        },
+        allowPositionals: true,
+      });
+      const status = parseStatus(values.status);
+      const priority = values.priority ? parsePriority(values.priority) : undefined;
+      const limit = values.all ? undefined : (parseLimit(values.limit) ?? 20);
+
+      // Resolve parent filter if provided
+      let parentFilter: string | undefined;
+      if (values.parent) {
+        const resolved = storage.resolveId(values.parent);
+        if (!resolved) error(`Parent task not found: ${values.parent}`);
+        parentFilter = resolved;
+      }
+
+      const list = storage.listTasks({
+        status,
+        priority,
+        project: values.project,
+        label: values.label,
+        assignee: values.assignee,
+        parent: parentFilter,
+        roots: values.roots,
+        overdue: values.overdue,
+        limit,
+      });
+      output(list, formatTaskList(list));
+      break;
+    }
+
+    case "ready": {
+      const list = storage.listReadyTasks();
+      output(list, formatTaskList(list));
+      break;
+    }
+
+    case "show": {
+      const id = resolveId(args[0], "show");
+      const task = storage.getTaskWithMeta(id);
+      if (!task) error(`Task not found: ${id}`);
+      output(task, formatTaskDetail(task, task.logs));
+      break;
+    }
+
+    case "start": {
+      const id = resolveId(args[0], "start");
+      const task = storage.getTask(id);
+      if (!task) error(`Task not found: ${id}`);
+      if (task.status !== "open") error(`Task is ${task.status}, not open`);
+      const updated = storage.updateTaskStatus(id, "active");
+      output(updated, `Started: ${id}`);
+      break;
+    }
+
+    case "done": {
+      const id = resolveId(args[0], "done");
+      const task = storage.getTask(id);
+      if (!task) error(`Task not found: ${id}`);
+      const updated = storage.updateTaskStatus(id, "done");
+      output(updated, `Completed: ${id}`);
+      break;
+    }
+
+    case "reopen": {
+      const id = resolveId(args[0], "reopen");
+      const task = storage.getTask(id);
+      if (!task) error(`Task not found: ${id}`);
+      const updated = storage.updateTaskStatus(id, "open");
+      output(updated, `Reopened: ${id}`);
+      break;
+    }
+
+    case "edit": {
+      const { values, positionals } = parseArgs({
+        args,
+        options: {
+          title: { type: "string", short: "t" },
+          description: { type: "string", short: "d" },
+          priority: { type: "string", short: "p" },
+          labels: { type: "string", short: "l" },
+          assignees: { type: "string", short: "A" },
+          parent: { type: "string" },
+          estimate: { type: "string" },
+          due: { type: "string" },
+        },
+        allowPositionals: true,
+      });
+      const id = resolveId(positionals[0], "edit");
+      const task = storage.getTask(id);
+      if (!task) error(`Task not found: ${id}`);
+
+      // Handle label modifications (+tag, -tag)
+      let labels: string[] | undefined;
+      if (values.labels) {
+        if (values.labels.startsWith("+")) {
+          // Add label (avoid duplicates)
+          const newLabel = values.labels.slice(1);
+          labels = task.labels.includes(newLabel) ? task.labels : [...task.labels, newLabel];
+        } else if (values.labels.startsWith("-")) {
+          // Remove label
+          const removeLabel = values.labels.slice(1);
+          labels = task.labels.filter((l) => l !== removeLabel);
+        } else {
+          // Replace labels
+          labels = parseLabels(values.labels);
+        }
+      }
+
+      // Resolve and validate parent if provided (and not clearing)
+      let resolvedParent: string | null | undefined;
+      if (values.parent === "-") {
+        resolvedParent = null;
+      } else if (values.parent) {
+        const resolved = storage.resolveId(values.parent);
+        if (!resolved) error(`Parent task not found: ${values.parent}`);
+        resolvedParent = resolved;
+        const parentResult = storage.validateParent(resolvedParent, id);
+        if (!parentResult.ok) error(parentResult.error!);
+      }
+
+      const updated = storage.updateTask(id, {
+        title: values.title?.trim() || undefined,
+        description: values.description,
+        priority: values.priority ? parsePriority(values.priority) : undefined,
+        labels,
+        assignees: parseAssignees(values.assignees),
+        parent: resolvedParent,
+        estimate: values.estimate === "-" ? null : (parseEstimate(values.estimate) ?? undefined),
+        due_date: values.due === "-" ? null : (parseDueDate(values.due) ?? undefined),
+      });
+      output(updated, `Updated: ${id}`);
+      break;
+    }
+
+    case "log": {
+      const id = resolveId(args[0], "log");
+      const message = args.slice(1).join(" ").trim();
+      if (!message) error("Message required: tk log <id> <message>");
+      const task = storage.getTask(id);
+      if (!task) error(`Task not found: ${id}`);
+      const entry = storage.addLogEntry(id, message);
+      output(entry, `Logged: ${id}`);
+      break;
+    }
+
+    case "block": {
+      if (!args[0] || !args[1]) error("Usage: tk block <task> <blocker>");
+      const taskId = resolveId(args[0], "block");
+      const blockerId = resolveId(args[1], "block");
+      if (taskId === blockerId) error("Task cannot block itself");
+      const result = storage.addBlock(taskId, blockerId);
+      if (!result.ok) error(result.error!);
+      output({ task_id: taskId, blocked_by: blockerId }, `${taskId} blocked by ${blockerId}`);
+      break;
+    }
+
+    case "unblock": {
+      if (!args[0] || !args[1]) error("Usage: tk unblock <task> <blocker>");
+      const taskId = resolveId(args[0], "unblock");
+      const blockerId = resolveId(args[1], "unblock");
+      const success = storage.removeBlock(taskId, blockerId);
+      if (!success) error("Block not found");
+      output({ task_id: taskId, blocked_by: blockerId }, `${taskId} unblocked from ${blockerId}`);
+      break;
+    }
+
+    case "rm":
+    case "remove": {
+      const id = resolveId(args[0], "rm");
+      const success = storage.deleteTask(id);
+      if (!success) error(`Task not found: ${id}`);
+      output({ id, deleted: true }, `Deleted: ${id}`);
+      break;
+    }
+
+    case "clean": {
+      const { values } = parseArgs({
+        args,
+        options: {
+          "older-than": { type: "string", default: "7d" },
+          done: { type: "boolean" },
+          all: { type: "boolean", short: "a" },
+        },
+        allowPositionals: true,
+      });
+      const olderThan = values["older-than"] || "7d";
+      const ms = parseDuration(olderThan);
+      const status = values.done ? ("done" as Status) : undefined;
+      const count = storage.cleanTasks({
+        olderThanMs: ms,
+        status,
+        all: values.all,
+      });
+      output({ deleted: count }, `Cleaned ${count} tasks`);
+      break;
+    }
+
+    case "config": {
+      const subcommand = args[0];
+      const config = storage.getConfig();
+
+      if (!subcommand) {
+        // Show all config
+        output(config, formatConfig(config));
+        break;
+      }
+
+      switch (subcommand) {
+        case "project": {
+          const { values, positionals } = parseArgs({
+            args: args.slice(1),
+            options: {
+              rename: { type: "string" },
+            },
+            allowPositionals: true,
+          });
+          const newProject = positionals[0];
+          if (!newProject) {
+            output({ project: config.project }, config.project);
+          } else if (values.rename) {
+            validateProject(newProject);
+            const result = storage.renameProject(values.rename, newProject);
+            output(
+              result,
+              `Renamed ${result.renamed.length} tasks: ${values.rename}-* → ${newProject}-*` +
+                (result.referencesUpdated > 0
+                  ? `\nUpdated ${result.referencesUpdated} references`
+                  : ""),
+            );
+          } else {
+            validateProject(newProject);
+            const updated = storage.setDefaultProject(newProject);
+            output(updated, `Default project: ${newProject}`);
+          }
+          break;
+        }
+        case "alias": {
+          const { values, positionals } = parseArgs({
+            args: args.slice(1),
+            options: {
+              rm: { type: "string" },
+              list: { type: "boolean" },
+            },
+            allowPositionals: true,
+          });
+
+          if (values.rm) {
+            const updated = storage.removeAlias(values.rm);
+            output(updated, `Removed alias: ${values.rm}`);
+          } else if (positionals.length >= 2) {
+            const alias = positionals[0];
+            const path = positionals[1];
+            if (!alias || !path || !alias.trim()) {
+              error("Alias name and path are required");
+            }
+            const updated = storage.setAlias(alias, path);
+            output(updated, `Added alias: ${alias} → ${path}`);
+          } else {
+            // List aliases
+            const aliases = config.aliases;
+            if (Object.keys(aliases).length === 0) {
+              output({ aliases: {} }, "No aliases defined.");
+            } else {
+              const lines = Object.entries(aliases)
+                .map(([a, p]) => `${a} → ${p}`)
+                .join("\n");
+              output({ aliases }, lines);
+            }
+          }
+          break;
+        }
+        default:
+          error(`Unknown config command: ${subcommand}`);
+      }
+      break;
+    }
+
+    case "completions": {
+      const shell = args[0];
+      switch (shell) {
+        case "bash":
+          console.log(BASH_COMPLETION);
+          break;
+        case "zsh":
+          console.log(ZSH_COMPLETION);
+          break;
+        case "fish":
+          console.log(FISH_COMPLETION);
+          break;
+        default:
+          error("Shell required: tk completions <bash|zsh|fish>");
+      }
+      break;
+    }
+
+    default:
+      error(`Unknown command: ${command}. Run 'tk --help' for usage.`);
+  }
+}
+
+function parseDuration(s: string): number {
+  const match = s.match(/^(\d+)(s|m|h|d|w)$/);
+  if (!match || !match[1] || !match[2]) {
+    throw new Error(`Invalid duration: ${s}. Use format like 7d, 24h, 30m, 90s, or 2w`);
+  }
+  const num = match[1];
+  const unit = match[2];
+  const n = parseInt(num);
+  switch (unit) {
+    case "s":
+      return n * 1000;
+    case "m":
+      return n * 60 * 1000;
+    case "h":
+      return n * 60 * 60 * 1000;
+    case "d":
+      return n * 24 * 60 * 60 * 1000;
+    case "w":
+      return n * 7 * 24 * 60 * 60 * 1000;
+    default:
+      throw new Error(`Invalid duration unit: ${unit}`);
+  }
+}
+
+try {
+  main();
+} catch (e) {
+  if (e instanceof Error) {
+    console.error(`Error: ${e.message}`);
+  } else {
+    console.error("An unexpected error occurred");
+  }
+  process.exit(1);
+}