@nijaru/tk 0.0.4 → 0.1.1

package/src/cli.ts

@@ -1,695 +0,0 @@
-#!/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 { parseDueDate, parseEstimate } from "./lib/time";
-import {
-  formatTaskList,
-  formatTaskDetail,
-  formatJson,
-  formatConfig,
-  green,
-  red,
-  yellow,
-  dim,
-} from "./lib/format";
-import { findRoot, setWorkingDir } from "./lib/root";
-import { parseId } from "./types";
-import type { Status, TaskWithMeta } from "./types";
-import { BASH_COMPLETION, ZSH_COMPLETION, FISH_COMPLETION } from "./lib/completions";
-import { MAIN_HELP, COMMAND_HELP } from "./lib/help";
-
-const VALID_STATUSES: Status[] = ["open", "active", "done"];
-const PROJECT_PATTERN = /^[a-z][a-z0-9]*$/;
-
-const COMMON_OPTIONS = {
-  project: { type: "string", short: "P" },
-  priority: { type: "string", short: "p" },
-  labels: { type: "string", short: "l" },
-} as const;
-
-const TASK_MUTATION_OPTIONS = {
-  ...COMMON_OPTIONS,
-  description: { type: "string", short: "d" },
-  assignees: { type: "string", short: "A" },
-  parent: { type: "string" },
-  estimate: { type: "string" },
-  due: { type: "string" },
-} as const;
-
-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 (e.g., 'api', 'web2').`,
-    );
-  }
-}
-
-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;
-  if (!/^\d+$/.test(input)) {
-    throw new Error(`Invalid limit: ${input}. Must be a positive number.`);
-  }
-  const n = Number(input);
-  if (n < 1) {
-    throw new Error(`Invalid limit: ${input}. Must be a positive number.`);
-  }
-  return n;
-}
-
-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 partial ID
-  const resolved = storage.resolveId(input);
-  if (resolved) return resolved;
-
-  // Check for ambiguous matches
-  const matches = storage.findMatchingIds(input);
-  if (matches.length > 1) {
-    throw new Error(
-      `Ambiguous ID '${input}' matches ${matches.length} tasks: ${matches.join(", ")}. Use more characters to narrow it down.`,
-    );
-  }
-
-  // If it's a valid full ID format but doesn't exist, we still return it
-  // and let getTask handle the "not found" error consistently.
-  if (parseId(input)) return input;
-
-  throw new Error(`Task not found: ${input}. Run 'tk ls' to see available tasks.`);
-}
-
-/**
- * Resolves an ID and fetches the task.
- * Handles "Task not found" and cleanup output automatically.
- */
-function resolveTask(input: string | undefined, context: string): TaskWithMeta {
-  const id = resolveId(input, context);
-  const result = storage.getTask(id);
-  if (!result) error(`Task not found: ${id}. Run 'tk ls' to see available tasks.`);
-
-  outputCleanup(id, result.cleanup);
-  return result.task;
-}
-
-const rawArgs = process.argv.slice(2);
-
-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);
-}
-
-// Find command: first non-flag argument
-const commandIndex = argsWithoutDir.findIndex((arg) => !isFlag(arg));
-const command = commandIndex >= 0 ? argsWithoutDir[commandIndex] : undefined;
-
-// Get args for command (before stripping flags)
-const postCommandArgs = commandIndex >= 0 ? argsWithoutDir.slice(commandIndex + 1) : [];
-const preCommandArgs = commandIndex >= 0 ? argsWithoutDir.slice(0, commandIndex) : argsWithoutDir;
-
-// Global flag detection:
-// --json can appear anywhere and should be stripped from args
-// --help/-h detected before command OR as first arg after command (not in message content)
-// --version/-V only detected before command
-const jsonFlag = argsWithoutDir.includes("--json");
-const helpFlag =
-  preCommandArgs.includes("--help") ||
-  preCommandArgs.includes("-h") ||
-  postCommandArgs[0] === "--help" ||
-  postCommandArgs[0] === "-h";
-const versionFlag = preCommandArgs.includes("--version") || preCommandArgs.includes("-V");
-
-// Strip --json from args (works from any position)
-// Strip --help/-h only if it's the first arg (to allow "tk ls --help")
-const args = postCommandArgs
-  .filter((arg) => arg !== "--json")
-  .filter((arg, i) => i !== 0 || (arg !== "--help" && arg !== "-h"));
-
-function output(data: unknown, formatted: string) {
-  console.log(jsonFlag ? formatJson(data) : formatted);
-}
-
-function outputCleanup(taskId: string, cleanup: storage.CleanupInfo | null) {
-  if (cleanup && !jsonFlag) {
-    console.error(storage.formatCleanupMessage(taskId, cleanup));
-  }
-}
-
-function error(message: string): never {
-  console.error(red(`Error: ${message}`));
-  process.exit(1);
-}
-
-function showHelp(): void {
-  console.log(MAIN_HELP);
-}
-
-function showCommandHelp(cmd: string): void {
-  const help = COMMAND_HELP[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 },
-          dim(`Already initialized: ${info.tasksDir}`),
-        );
-      } else {
-        const path = storage.initTasks(values.project);
-        output({ path, created: true }, green(`Initialized: ${path}`));
-      }
-      break;
-    }
-
-    case "add": {
-      const { values, positionals } = parseArgs({
-        args,
-        options: TASK_MUTATION_OPTIONS,
-        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}. Run 'tk ls' to see available tasks.`);
-        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: {
-          ...COMMON_OPTIONS,
-          label: COMMON_OPTIONS.labels, // alias for consistency
-          status: { type: "string", short: "s" },
-          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}. Run 'tk ls' to see available tasks.`);
-        parentFilter = resolved;
-      }
-
-      const list = storage.listTasks({
-        status,
-        priority,
-        project: values.project,
-        label: values.label ?? values.labels,
-        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, undefined, "No ready tasks. All tasks are either done or blocked."),
-      );
-      break;
-    }
-
-    case "show": {
-      const task = resolveTask(args[0], "show");
-      output(task, formatTaskDetail(task, task.logs));
-      break;
-    }
-
-    case "start": {
-      const task = resolveTask(args[0], "start");
-      if (task.status === "active")
-        error(`Task already active. Use 'tk done ${task.id}' to complete it.`);
-      if (task.status === "done") error(`Task already done. Use 'tk reopen ${task.id}' first.`);
-      const updated = storage.updateTaskStatus(task.id, "active");
-      output(updated, green(`Started: ${task.id}`));
-      break;
-    }
-
-    case "done": {
-      const task = resolveTask(args[0], "done");
-      const updated = storage.updateTaskStatus(task.id, "done");
-      output(updated, green(`Completed: ${task.id}`));
-      break;
-    }
-
-    case "reopen": {
-      const task = resolveTask(args[0], "reopen");
-      const updated = storage.updateTaskStatus(task.id, "open");
-      output(updated, green(`Reopened: ${task.id}`));
-      break;
-    }
-
-    case "edit": {
-      const { values, positionals } = parseArgs({
-        args,
-        options: {
-          ...TASK_MUTATION_OPTIONS,
-          title: { type: "string", short: "t" },
-        },
-        allowPositionals: true,
-      });
-      const task = resolveTask(positionals[0], "edit");
-
-      // 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: string) => 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}. Run 'tk ls' to see available tasks.`);
-        resolvedParent = resolved;
-        const parentResult = storage.validateParent(resolvedParent, task.id);
-        if (!parentResult.ok) error(parentResult.error!);
-      }
-
-      const updated = storage.updateTask(task.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, green(`Updated: ${task.id}`));
-      break;
-    }
-
-    case "log": {
-      const task = resolveTask(args[0], "log");
-      const message = args[1]?.trim();
-      if (!message) error('Message required: tk log <id> "<message>"');
-      if (args.length > 2) {
-        error(
-          'Message must be quoted: tk log <id> "<message>"\n' +
-            `  Got ${args.length - 1} arguments instead of 1`,
-        );
-      }
-      const entry = storage.addLogEntry(task.id, message);
-      output(entry, green(`Logged: ${task.id}`));
-      break;
-    }
-
-    case "block": {
-      if (!args[0] || !args[1])
-        error(
-          "Two IDs required: tk block <task> <blocker>. The first task becomes blocked by the second.",
-        );
-      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 },
-        green(`${taskId} blocked by ${blockerId}`),
-      );
-      break;
-    }
-
-    case "unblock": {
-      if (!args[0] || !args[1]) error("Two IDs required: tk unblock <task> <blocker>.");
-      const taskId = resolveId(args[0], "unblock");
-      const blockerId = resolveId(args[1], "unblock");
-      const removed = storage.removeBlock(taskId, blockerId);
-      if (!removed) error(`${taskId} is not blocked by ${blockerId}`);
-      output(
-        { task_id: taskId, blocked_by: blockerId },
-        green(`${taskId} unblocked from ${blockerId}`),
-      );
-      break;
-    }
-
-    case "rm":
-    case "remove": {
-      const id = resolveId(args[0], "rm");
-      const deleted = storage.deleteTask(id);
-      if (!deleted) error(`Task not found: ${id}. Run 'tk ls' to see available tasks.`);
-      output({ id, deleted: true }, green(`Deleted: ${id}`));
-      break;
-    }
-
-    case "clean": {
-      const config = storage.getConfig();
-      const { values } = parseArgs({
-        args,
-        options: {
-          "older-than": { type: "string" },
-          force: { type: "boolean", short: "f" },
-        },
-        allowPositionals: true,
-      });
-
-      // Get days from CLI or config
-      let days: number | false;
-      if (values["older-than"] !== undefined) {
-        if (!/^\d+$/.test(values["older-than"])) {
-          error(`Invalid --older-than: ${values["older-than"]}. Use a number of days.`);
-        }
-        days = Number(values["older-than"]);
-      } else {
-        days = config.clean_after;
-        // Validate config value at runtime
-        if (days !== false && (typeof days !== "number" || days < 0 || !Number.isFinite(days))) {
-          error(
-            `Invalid clean_after in config: ${JSON.stringify(days)}. Must be a number or false.`,
-          );
-        }
-      }
-
-      if (days === false && !values.force) {
-        error("Cleaning is disabled (clean_after: false). Use --force to override.");
-      }
-
-      const ms = days === false ? 0 : days * 24 * 60 * 60 * 1000;
-      const count = storage.cleanTasks({
-        olderThanMs: ms,
-        force: values.force,
-      });
-      output({ deleted: count }, green(`Cleaned ${count} tasks`));
-      break;
-    }
-
-    case "check": {
-      const checkResult = storage.checkTasks();
-
-      if (jsonFlag) {
-        output(checkResult, "");
-      } else {
-        // Report cleaned issues
-        if (checkResult.cleaned.length > 0) {
-          for (const { task, info } of checkResult.cleaned) {
-            console.log(storage.formatCleanupMessage(task, info));
-          }
-        }
-
-        // Report unfixable issues
-        if (checkResult.unfixable.length > 0) {
-          console.log(red("\nUnfixable issues (require manual intervention):"));
-          for (const { file, error: err } of checkResult.unfixable) {
-            console.log(red(`  ${file}: ${err}`));
-          }
-        }
-
-        // Summary
-        if (checkResult.cleaned.length === 0 && checkResult.unfixable.length === 0) {
-          console.log(green(`All ${checkResult.totalTasks} tasks OK`));
-        } else {
-          const parts: string[] = [];
-          if (checkResult.cleaned.length > 0) {
-            parts.push(yellow(`${checkResult.cleaned.length} fixed`));
-          }
-          if (checkResult.unfixable.length > 0) {
-            parts.push(red(`${checkResult.unfixable.length} unfixable`));
-          }
-          console.log(`\nChecked ${checkResult.totalTasks} tasks: ${parts.join(", ")}`);
-        }
-      }
-      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,
-              green(
-                `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, green(`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, green(`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 required: tk config alias <name> <path>");
-            }
-            const updated = storage.setAlias(alias, path);
-            output(updated, green(`Added alias: ${alias} → ${path}`));
-          } else {
-            // List aliases
-            const aliases = config.aliases;
-            if (Object.keys(aliases).length === 0) {
-              output(
-                { aliases: {} },
-                "No aliases defined. Add one with: tk config alias <name> <path>",
-              );
-            } else {
-              const lines = Object.entries(aliases)
-                .map(([a, p]) => `${a} → ${p}`)
-                .join("\n");
-              output({ aliases }, lines);
-            }
-          }
-          break;
-        }
-        default:
-          error(`Unknown config command: ${subcommand}. Valid: project, alias.`);
-      }
-      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>. Add to your shell's rc file.");
-      }
-      break;
-    }
-
-    default:
-      error(`Unknown command: ${command}. Run 'tk --help' for usage.`);
-  }
-}
-
-try {
-  main();
-} catch (e) {
-  if (e instanceof Error) {
-    console.error(red(`Error: ${e.message}`));
-  } else {
-    console.error(red("An unexpected error occurred"));
-  }
-  process.exit(1);
-}