@nijaru/tk 0.0.5 → 0.1.1

package/src/lib/help.ts

@@ -1,266 +0,0 @@
-import { version } from "../../package.json";
-
-export const MAIN_HELP = `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 (active/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
-  mv, move     Move task to different project
-  rm, remove   Delete task
-  clean        Remove old done tasks
-  check        Check for data issues
-  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.
-`;
-
-export const COMMAND_HELP: 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 (active/open + unblocked)
-
-USAGE:
-  tk ready
-
-Shows active or 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>"
-
-Message must be quoted.
-
-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
-`,
-  mv: `tk mv - Move a task to a different project
-
-USAGE:
-  tk mv <id> <project>
-
-Moves a task to a new project, keeping the same ref.
-Errors if the new ID already exists.
-Updates all blocked_by and parent references.
-
-EXAMPLES:
-  tk mv api-a1b2 web        # Moves api-a1b2 → web-a1b2
-  tk mv a1b2 archive        # Partial ID resolution
-`,
-  move: `tk move - Move a task to a different project (alias for 'mv')
-
-USAGE:
-  tk move <id> <project>
-
-Run 'tk mv --help' for options.
-`,
-  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 <days>   Age threshold in days (default: from config, 14)
-  -f, --force           Remove all done tasks (ignores age and disabled state)
-
-EXAMPLES:
-  tk clean                  # Remove done tasks older than config.clean_after days
-  tk clean --older-than 30  # Remove done tasks older than 30 days
-  tk clean --force          # Remove all done tasks regardless of age
-`,
-  check: `tk check - Check for data issues
-
-USAGE:
-  tk check
-
-Scans all tasks for issues. Auto-fixable issues (orphaned references, ID
-mismatches) are fixed automatically. Unfixable issues (corrupted JSON) are
-reported for manual intervention.
-
-Note: Auto-fixing also happens during normal task operations (show, done,
-edit, etc.) - this command is for bulk cleanup or diagnostics.
-
-EXAMPLES:
-  tk check                  # Scan and fix all 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-*)
-
-EXAMPLES:
-  tk config project api
-  tk config project lsmvec --rename cloudlsmvec
-`,
-  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
-`,
-};

package/src/lib/priority.test.ts

@@ -1,105 +0,0 @@
-import { test, expect, describe } from "bun:test";
-import { parsePriority, formatPriority, formatPriorityName } from "./priority";
-
-describe("parsePriority", () => {
-  describe("valid inputs", () => {
-    test("returns 3 (medium) for undefined", () => {
-      expect(parsePriority(undefined)).toBe(3);
-    });
-
-    test("parses numeric strings 0-4", () => {
-      expect(parsePriority("0")).toBe(0);
-      expect(parsePriority("1")).toBe(1);
-      expect(parsePriority("2")).toBe(2);
-      expect(parsePriority("3")).toBe(3);
-      expect(parsePriority("4")).toBe(4);
-    });
-
-    test("parses numbers 0-4", () => {
-      expect(parsePriority(0)).toBe(0);
-      expect(parsePriority(1)).toBe(1);
-      expect(parsePriority(2)).toBe(2);
-      expect(parsePriority(3)).toBe(3);
-      expect(parsePriority(4)).toBe(4);
-    });
-
-    test("parses p0-p4 format (lowercase)", () => {
-      expect(parsePriority("p0")).toBe(0);
-      expect(parsePriority("p1")).toBe(1);
-      expect(parsePriority("p2")).toBe(2);
-      expect(parsePriority("p3")).toBe(3);
-      expect(parsePriority("p4")).toBe(4);
-    });
-
-    test("parses P0-P4 format (uppercase)", () => {
-      expect(parsePriority("P0")).toBe(0);
-      expect(parsePriority("P1")).toBe(1);
-      expect(parsePriority("P2")).toBe(2);
-      expect(parsePriority("P3")).toBe(3);
-      expect(parsePriority("P4")).toBe(4);
-    });
-
-    test("parses named priorities", () => {
-      expect(parsePriority("none")).toBe(0);
-      expect(parsePriority("urgent")).toBe(1);
-      expect(parsePriority("high")).toBe(2);
-      expect(parsePriority("medium")).toBe(3);
-      expect(parsePriority("low")).toBe(4);
-    });
-
-    test("parses named priorities case-insensitively", () => {
-      expect(parsePriority("URGENT")).toBe(1);
-      expect(parsePriority("High")).toBe(2);
-      expect(parsePriority("MEDIUM")).toBe(3);
-    });
-  });
-
-  describe("invalid inputs", () => {
-    test("throws for out of range numbers", () => {
-      expect(() => parsePriority("5")).toThrow("Invalid priority");
-      expect(() => parsePriority("-1")).toThrow("Invalid priority");
-      expect(() => parsePriority("99")).toThrow("Invalid priority");
-    });
-
-    test("throws for out of range pX format", () => {
-      expect(() => parsePriority("p5")).toThrow("Invalid priority");
-      expect(() => parsePriority("p6")).toThrow("Invalid priority");
-      expect(() => parsePriority("p-1")).toThrow("Invalid priority");
-    });
-
-    test("throws for invalid named priorities", () => {
-      expect(() => parsePriority("critical")).toThrow("Invalid priority");
-      expect(() => parsePriority("abc")).toThrow("Invalid priority");
-    });
-
-    test("throws for empty string", () => {
-      expect(() => parsePriority("")).toThrow("Invalid priority");
-    });
-
-    test("error message includes valid formats", () => {
-      expect(() => parsePriority("invalid")).toThrow(
-        "Use 0-4, p0-p4, or none/urgent/high/medium/low",
-      );
-    });
-  });
-});
-
-describe("formatPriority", () => {
-  test("formats priorities as pX", () => {
-    expect(formatPriority(0)).toBe("p0");
-    expect(formatPriority(1)).toBe("p1");
-    expect(formatPriority(2)).toBe("p2");
-    expect(formatPriority(3)).toBe("p3");
-    expect(formatPriority(4)).toBe("p4");
-  });
-});
-
-describe("formatPriorityName", () => {
-  test("formats priorities as names", () => {
-    expect(formatPriorityName(0)).toBe("none");
-    expect(formatPriorityName(1)).toBe("urgent");
-    expect(formatPriorityName(2)).toBe("high");
-    expect(formatPriorityName(3)).toBe("medium");
-    expect(formatPriorityName(4)).toBe("low");
-  });
-});

package/src/lib/priority.ts

@@ -1,40 +0,0 @@
-import type { Priority } from "../types";
-import { PRIORITY_FROM_NAME, PRIORITY_LABELS } from "../types";
-
-/**
- * Parse priority from various formats:
- * - Number: 0-4
- * - Prefixed: p0-p4
- * - Named: none, urgent, high, medium, low
- */
-export function parsePriority(input: string | number | undefined): Priority {
-  if (input === undefined) return 3; // default: medium
-
-  const str = String(input).toLowerCase();
-
-  // Handle named format
-  const named = PRIORITY_FROM_NAME[str];
-  if (named !== undefined) {
-    return named;
-  }
-
-  // Handle pX format
-  if (str.startsWith("p")) {
-    const num = parseInt(str.slice(1), 10);
-    if (num >= 0 && num <= 4) return num as Priority;
-  }
-
-  // Handle numeric format
-  const num = parseInt(str, 10);
-  if (num >= 0 && num <= 4) return num as Priority;
-
-  throw new Error(`Invalid priority: ${input}. Use 0-4, p0-p4, or none/urgent/high/medium/low.`);
-}
-
-export function formatPriority(p: Priority): string {
-  return `p${p}`;
-}
-
-export function formatPriorityName(p: Priority): string {
-  return PRIORITY_LABELS[p];
-}

package/src/lib/root.ts

@@ -1,79 +0,0 @@
-import { existsSync } from "fs";
-import { join, dirname, resolve } from "path";
-
-const TASKS_DIR = ".tasks";
-const GIT_DIR = ".git";
-
-// Global override for working directory (set via -C flag)
-let workingDir: string | null = null;
-
-export function setWorkingDir(dir: string | null): void {
-  workingDir = dir ? resolve(dir) : null;
-}
-
-export function getWorkingDir(): string {
-  return workingDir ?? process.cwd();
-}
-
-export interface RootInfo {
-  root: string;
-  tasksDir: string;
-  exists: boolean;
-}
-
-/**
- * Find the project root by walking up directories.
- * Looks for existing .tasks/ or .git/ directory.
- * Returns cwd if neither found.
- */
-export function findRoot(): RootInfo {
-  let current = getWorkingDir();
-
-  while (true) {
-    const tasksPath = join(current, TASKS_DIR);
-    if (existsSync(tasksPath)) {
-      return { root: current, tasksDir: tasksPath, exists: true };
-    }
-
-    const gitPath = join(current, GIT_DIR);
-    if (existsSync(gitPath)) {
-      return {
-        root: current,
-        tasksDir: join(current, TASKS_DIR),
-        exists: false,
-      };
-    }
-
-    const parent = dirname(current);
-    if (parent === current) break; // Reached filesystem root
-    current = parent;
-  }
-
-  // No .git or .tasks found, use working dir
-  const wd = getWorkingDir();
-  return {
-    root: wd,
-    tasksDir: join(wd, TASKS_DIR),
-    exists: false,
-  };
-}
-
-/**
- * Get the tasks directory path, optionally requiring it to exist.
- */
-export function getTasksDir(requireExists = false): string {
-  const info = findRoot();
-  if (requireExists && !info.exists) {
-    throw new TasksNotFoundError(info.root);
-  }
-  return info.tasksDir;
-}
-
-export class TasksNotFoundError extends Error {
-  constructor(searchedFrom: string) {
-    super(
-      `No .tasks/ directory found. Run 'tk add' to create one, or initialize with 'tk init'.\nSearched from: ${searchedFrom}`,
-    );
-    this.name = "TasksNotFoundError";
-  }
-}

package/src/lib/time.test.ts

@@ -1,222 +0,0 @@
-import { test, expect, describe } from "bun:test";
-import {
-  isTaskOverdue,
-  daysUntilDue,
-  formatRelativeTime,
-  formatDate,
-  formatLocalDate,
-  parseDueDate,
-  parseEstimate,
-  DUE_SOON_THRESHOLD,
-} from "./time";
-
-describe("isTaskOverdue", () => {
-  test("returns false when no due date", () => {
-    expect(isTaskOverdue(null, "open")).toBe(false);
-  });
-
-  test("returns false for done tasks regardless of date", () => {
-    expect(isTaskOverdue("2020-01-01", "done")).toBe(false);
-  });
-
-  test("returns false for active done tasks", () => {
-    expect(isTaskOverdue("2020-01-01", "done")).toBe(false);
-  });
-
-  test("returns true for past dates (open)", () => {
-    expect(isTaskOverdue("2020-01-01", "open")).toBe(true);
-  });
-
-  test("returns true for past dates (active)", () => {
-    expect(isTaskOverdue("2020-06-15", "active")).toBe(true);
-  });
-
-  test("returns false for today", () => {
-    const today = new Date().toISOString().split("T")[0]!;
-    expect(isTaskOverdue(today, "open")).toBe(false);
-  });
-
-  test("returns false for future dates", () => {
-    const future = new Date();
-    future.setDate(future.getDate() + 7);
-    const dateStr = future.toISOString().split("T")[0]!;
-    expect(isTaskOverdue(dateStr, "open")).toBe(false);
-  });
-
-  test("returns false for invalid date string", () => {
-    expect(isTaskOverdue("not-a-date", "open")).toBe(false);
-  });
-});
-
-describe("daysUntilDue", () => {
-  test("returns null when no due date", () => {
-    expect(daysUntilDue(null, "open")).toBeNull();
-  });
-
-  test("returns null when no due date (active)", () => {
-    expect(daysUntilDue(null, "active")).toBeNull();
-  });
-
-  test("returns null for done tasks", () => {
-    const future = new Date();
-    future.setDate(future.getDate() + 3);
-    const dateStr = future.toISOString().split("T")[0]!;
-    expect(daysUntilDue(dateStr, "done")).toBeNull();
-  });
-
-  test("returns 0 for due today (open)", () => {
-    const today = new Date().toISOString().split("T")[0]!;
-    expect(daysUntilDue(today, "open")).toBe(0);
-  });
-
-  test("returns 0 for due today (active)", () => {
-    const today = new Date().toISOString().split("T")[0]!;
-    expect(daysUntilDue(today, "active")).toBe(0);
-  });
-
-  test("returns N for due in N days", () => {
-    const future = new Date();
-    future.setDate(future.getDate() + 3);
-    const dateStr = future.toISOString().split("T")[0]!;
-    expect(daysUntilDue(dateStr, "open")).toBe(3);
-  });
-
-  test("returns null for past dates (already overdue)", () => {
-    expect(daysUntilDue("2020-01-01", "open")).toBeNull();
-  });
-
-  test("returns null for invalid date string", () => {
-    expect(daysUntilDue("not-a-date", "open")).toBeNull();
-  });
-
-  test("DUE_SOON_THRESHOLD is 7", () => {
-    expect(DUE_SOON_THRESHOLD).toBe(7);
-  });
-});
-
-describe("formatRelativeTime", () => {
-  test("returns 'now' for very recent timestamps", () => {
-    const ts = new Date().toISOString();
-    expect(formatRelativeTime(ts)).toBe("now");
-  });
-
-  test("returns minutes for timestamps minutes ago", () => {
-    const ts = new Date(Date.now() - 5 * 60 * 1000).toISOString();
-    expect(formatRelativeTime(ts)).toBe("5m");
-  });
-
-  test("returns hours for timestamps hours ago", () => {
-    const ts = new Date(Date.now() - 3 * 60 * 60 * 1000).toISOString();
-    expect(formatRelativeTime(ts)).toBe("3h");
-  });
-
-  test("returns days for timestamps days ago", () => {
-    const ts = new Date(Date.now() - 2 * 24 * 60 * 60 * 1000).toISOString();
-    expect(formatRelativeTime(ts)).toBe("2d");
-  });
-});
-
-describe("formatDate", () => {
-  test("returns a non-empty string for a valid ISO timestamp", () => {
-    const result = formatDate("2024-01-15T10:30:00.000Z");
-    expect(typeof result).toBe("string");
-    expect(result.length).toBeGreaterThan(0);
-  });
-});
-
-describe("formatLocalDate", () => {
-  test("formats date as YYYY-MM-DD", () => {
-    const date = new Date(2026, 0, 15); // Jan 15 2026
-    expect(formatLocalDate(date)).toBe("2026-01-15");
-  });
-
-  test("zero-pads month and day", () => {
-    const date = new Date(2026, 1, 5); // Feb 5 2026
-    expect(formatLocalDate(date)).toBe("2026-02-05");
-  });
-});
-
-describe("parseDueDate", () => {
-  test("returns undefined for undefined input", () => {
-    expect(parseDueDate(undefined)).toBeUndefined();
-  });
-
-  test("returns undefined for '-' (clear sentinel)", () => {
-    expect(parseDueDate("-")).toBeUndefined();
-  });
-
-  test("returns valid YYYY-MM-DD unchanged", () => {
-    expect(parseDueDate("2026-06-15")).toBe("2026-06-15");
-  });
-
-  test("parses +Nd relative date", () => {
-    const result = parseDueDate("+7d");
-    expect(result).toMatch(/^\d{4}-\d{2}-\d{2}$/);
-    const resultDate = new Date(result!);
-    const today = new Date();
-    const diffDays = Math.round((resultDate.getTime() - today.getTime()) / (1000 * 60 * 60 * 24));
-    expect(diffDays).toBeGreaterThanOrEqual(6);
-    expect(diffDays).toBeLessThanOrEqual(8);
-  });
-
-  test("parses +Nw relative date", () => {
-    const result = parseDueDate("+2w");
-    expect(result).toMatch(/^\d{4}-\d{2}-\d{2}$/);
-  });
-
-  test("parses +Nm relative date", () => {
-    const result = parseDueDate("+1m");
-    expect(result).toMatch(/^\d{4}-\d{2}-\d{2}$/);
-  });
-
-  test("parses +Nh relative date", () => {
-    const result = parseDueDate("+3h");
-    expect(result).toMatch(/^\d{4}-\d{2}-\d{2}$/);
-  });
-
-  test("throws for invalid relative format", () => {
-    expect(() => parseDueDate("+7x")).toThrow("Invalid relative date");
-  });
-
-  test("throws for bare + with no content", () => {
-    expect(() => parseDueDate("+")).toThrow("Invalid relative date");
-  });
-
-  test("throws for non-date string", () => {
-    expect(() => parseDueDate("not-a-date")).toThrow("Invalid date format");
-  });
-
-  test("throws for invalid calendar date (month 13)", () => {
-    expect(() => parseDueDate("2026-13-01")).toThrow("Invalid date format");
-  });
-
-  test("throws for invalid calendar date (day 32)", () => {
-    expect(() => parseDueDate("2026-01-32")).toThrow("Invalid date format");
-  });
-});
-
-describe("parseEstimate", () => {
-  test("returns undefined for undefined input", () => {
-    expect(parseEstimate(undefined)).toBeUndefined();
-  });
-
-  test("parses valid integer string", () => {
-    expect(parseEstimate("42")).toBe(42);
-  });
-
-  test("parses zero", () => {
-    expect(parseEstimate("0")).toBe(0);
-  });
-
-  test("throws for non-numeric string", () => {
-    expect(() => parseEstimate("abc")).toThrow("Invalid estimate");
-  });
-
-  test("throws for decimal", () => {
-    expect(() => parseEstimate("3.5")).toThrow("Invalid estimate");
-  });
-
-  test("throws for negative number", () => {
-    expect(() => parseEstimate("-1")).toThrow("Invalid estimate");
-  });
-});