@nijaru/tk 0.0.4 → 0.1.1

package/src/cli.test.ts

@@ -1,976 +0,0 @@
-import { test, expect, beforeEach, afterEach, describe } from "bun:test";
-import { mkdtempSync, rmSync, existsSync } from "fs";
-import { join } from "path";
-import { tmpdir } from "os";
-
-const PROJECT_ROOT = import.meta.dir.replace("/src", "");
-const CLI_PATH = join(PROJECT_ROOT, "src/cli.ts");
-
-async function run(
-  args: string[],
-  cwd: string,
-): Promise<{ stdout: string; stderr: string; exitCode: number }> {
-  const proc = Bun.spawn(["bun", "run", CLI_PATH, ...args], {
-    cwd,
-    stdout: "pipe",
-    stderr: "pipe",
-    env: { ...process.env, NO_COLOR: "1" },
-  });
-
-  const stdout = await new Response(proc.stdout).text();
-  const stderr = await new Response(proc.stderr).text();
-  const exitCode = await proc.exited;
-
-  return { stdout: stdout.trim(), stderr: stderr.trim(), exitCode };
-}
-
-describe("tk CLI", () => {
-  let testDir: string;
-
-  beforeEach(() => {
-    testDir = mkdtempSync(join(tmpdir(), "tk-test-"));
-    Bun.spawnSync(["git", "init"], { cwd: testDir });
-  });
-
-  afterEach(() => {
-    rmSync(testDir, { recursive: true, force: true });
-  });
-
-  test("--help shows usage", async () => {
-    const { stdout, exitCode } = await run(["--help"], testDir);
-    expect(exitCode).toBe(0);
-    expect(stdout).toContain("tk v");
-    expect(stdout).toContain("COMMANDS:");
-    expect(stdout).toContain("add");
-    expect(stdout).toContain("Run 'tk <command> --help'");
-  });
-
-  test("command --help shows command-specific help", async () => {
-    const { stdout: addHelp, exitCode: addCode } = await run(["add", "--help"], testDir);
-    expect(addCode).toBe(0);
-    expect(addHelp).toContain("tk add");
-    expect(addHelp).toContain("--priority");
-
-    const { stdout: lsHelp, exitCode: lsCode } = await run(["ls", "--help"], testDir);
-    expect(lsCode).toBe(0);
-    expect(lsHelp).toContain("tk ls");
-    expect(lsHelp).toContain("--status");
-  });
-
-  test("help <command> shows command-specific help", async () => {
-    const { stdout, exitCode } = await run(["help", "add"], testDir);
-    expect(exitCode).toBe(0);
-    expect(stdout).toContain("tk add");
-    expect(stdout).toContain("--priority");
-  });
-
-  test("--version shows version", async () => {
-    const { stdout, exitCode } = await run(["--version"], testDir);
-    expect(exitCode).toBe(0);
-    expect(stdout).toMatch(/^tk v\d+\.\d+\.\d+$/);
-  });
-
-  test("unknown command errors", async () => {
-    const { stderr, exitCode } = await run(["unknown"], testDir);
-    expect(exitCode).toBe(1);
-    expect(stderr).toContain("Unknown command: unknown");
-  });
-
-  describe("add", () => {
-    test("creates task and returns ID", async () => {
-      const { stdout, exitCode } = await run(["add", "Test task"], testDir);
-      expect(exitCode).toBe(0);
-      expect(stdout).toMatch(/^tk-[a-z0-9]{4}$/);
-    });
-
-    test("creates task with priority", async () => {
-      const { stdout } = await run(["add", "Urgent task", "-p", "1"], testDir);
-      const id = stdout.trim();
-
-      const { stdout: showOut } = await run(["show", id, "--json"], testDir);
-      const task = JSON.parse(showOut);
-      expect(task.priority).toBe(1);
-    });
-
-    test("creates task with description", async () => {
-      const { stdout } = await run(["add", "Task", "-d", "Description here"], testDir);
-      const id = stdout.trim();
-
-      const { stdout: showOut } = await run(["show", id, "--json"], testDir);
-      const task = JSON.parse(showOut);
-      expect(task.description).toBe("Description here");
-    });
-
-    test("accepts p0-p4 priority format", async () => {
-      const { stdout } = await run(["add", "Task", "-p", "p1"], testDir);
-      const id = stdout.trim();
-
-      const { stdout: showOut } = await run(["show", id, "--json"], testDir);
-      const task = JSON.parse(showOut);
-      expect(task.priority).toBe(1);
-    });
-
-    test("accepts named priority format", async () => {
-      const { stdout } = await run(["add", "Task", "-p", "urgent"], testDir);
-      const id = stdout.trim();
-
-      const { stdout: showOut } = await run(["show", id, "--json"], testDir);
-      const task = JSON.parse(showOut);
-      expect(task.priority).toBe(1);
-    });
-
-    test("creates task with labels", async () => {
-      const { stdout } = await run(["add", "Task", "-l", "bug,urgent"], testDir);
-      const id = stdout.trim();
-
-      const { stdout: showOut } = await run(["show", id, "--json"], testDir);
-      const task = JSON.parse(showOut);
-      expect(task.labels).toContain("bug");
-      expect(task.labels).toContain("urgent");
-    });
-
-    test("creates task with due date", async () => {
-      const { stdout } = await run(["add", "Task", "--due", "2026-01-15"], testDir);
-      const id = stdout.trim();
-
-      const { stdout: showOut } = await run(["show", id, "--json"], testDir);
-      const task = JSON.parse(showOut);
-      expect(task.due_date).toBe("2026-01-15");
-    });
-
-    test("creates task with relative due date", async () => {
-      const { stdout } = await run(["add", "Task", "--due", "+7d"], testDir);
-      const id = stdout.trim();
-
-      const { stdout: showOut } = await run(["show", id, "--json"], testDir);
-      const task = JSON.parse(showOut);
-      expect(task.due_date).not.toBeNull();
-    });
-
-    test("creates task with custom project", async () => {
-      const { stdout } = await run(["add", "Task", "-P", "api"], testDir);
-      expect(stdout).toMatch(/^api-[a-z0-9]{4}$/);
-    });
-
-    test("errors without title", async () => {
-      const { stderr, exitCode } = await run(["add"], testDir);
-      expect(exitCode).toBe(1);
-      expect(stderr).toContain("Title required");
-    });
-
-    test("errors with whitespace-only title", async () => {
-      const { stderr, exitCode } = await run(["add", "   "], testDir);
-      expect(exitCode).toBe(1);
-      expect(stderr).toContain("Title required");
-    });
-
-    test("errors with non-existent parent", async () => {
-      const { stderr, exitCode } = await run(["add", "Task", "--parent", "tk-999"], testDir);
-      expect(exitCode).toBe(1);
-      expect(stderr).toContain("Parent task not found");
-    });
-
-    test("resolves parent by ref only", async () => {
-      const { stdout: parentId } = await run(["add", "Parent task"], testDir);
-      const ref = parentId.trim().split("-")[1] ?? "";
-
-      const { stdout: childId, exitCode } = await run(
-        ["add", "Child task", "--parent", ref],
-        testDir,
-      );
-      expect(exitCode).toBe(0);
-
-      const { stdout } = await run(["show", childId.trim()], testDir);
-      expect(stdout).toContain("Parent:");
-      expect(stdout).toContain(parentId.trim());
-    });
-
-    test("errors with invalid project name", async () => {
-      const { stderr, exitCode } = await run(["add", "Task", "-P", "Invalid-Name!"], testDir);
-      expect(exitCode).toBe(1);
-      expect(stderr).toContain("Invalid project name");
-    });
-  });
-
-  describe("ls", () => {
-    test("lists tasks", async () => {
-      await run(["add", "Task 1"], testDir);
-      await run(["add", "Task 2"], testDir);
-
-      const { stdout } = await run(["ls"], testDir);
-      expect(stdout).toContain("Task 1");
-      expect(stdout).toContain("Task 2");
-    });
-
-    test("filters by status", async () => {
-      await run(["add", "Open task"], testDir);
-      const { stdout: id2 } = await run(["add", "Done task"], testDir);
-      await run(["done", id2.trim()], testDir);
-
-      const { stdout } = await run(["ls", "-s", "open"], testDir);
-      expect(stdout).toContain("Open task");
-      expect(stdout).not.toContain("Done task");
-    });
-
-    test("filters by project", async () => {
-      await run(["add", "API task", "-P", "api"], testDir);
-      await run(["add", "Web task", "-P", "web"], testDir);
-
-      const { stdout } = await run(["ls", "-P", "api"], testDir);
-      expect(stdout).toContain("API task");
-      expect(stdout).not.toContain("Web task");
-    });
-
-    test("filters by label", async () => {
-      await run(["add", "Bug task", "-l", "bug"], testDir);
-      await run(["add", "Feature task", "-l", "feature"], testDir);
-
-      const { stdout } = await run(["ls", "-l", "bug"], testDir);
-      expect(stdout).toContain("Bug task");
-      expect(stdout).not.toContain("Feature task");
-    });
-
-    test("--json outputs JSON array", async () => {
-      await run(["add", "Task"], testDir);
-
-      const { stdout } = await run(["ls", "--json"], testDir);
-      const tasks = JSON.parse(stdout);
-      expect(Array.isArray(tasks)).toBe(true);
-      expect(tasks.length).toBe(1);
-    });
-
-    test("empty list shows message", async () => {
-      const { stdout } = await run(["ls"], testDir);
-      expect(stdout).toContain("No tasks found");
-    });
-
-    test("sorts by status (active > open > done)", async () => {
-      const { stdout: idDone } = await run(["add", "Done task"], testDir);
-      await run(["done", idDone.trim()], testDir);
-      const { stdout: idActive } = await run(["add", "Active task"], testDir);
-      await run(["start", idActive.trim()], testDir);
-      await run(["add", "Open task"], testDir);
-
-      const { stdout } = await run(["ls"], testDir);
-      const lines = stdout
-        .trim()
-        .split("\n")
-        .filter((l) => l.includes("task"));
-      expect(lines[0]).toContain("Active task");
-      expect(lines[1]).toContain("Open task");
-      expect(lines[2]).toContain("Done task");
-    });
-
-    test("sorts by priority (p1-4, then p0/none)", async () => {
-      await run(["add", "Medium", "-p", "3"], testDir);
-      await run(["add", "Urgent", "-p", "1"], testDir);
-      await run(["add", "None", "-p", "0"], testDir);
-      await run(["add", "Low", "-p", "4"], testDir);
-
-      const { stdout } = await run(["ls"], testDir);
-      const lines = stdout
-        .trim()
-        .split("\n")
-        .filter((l) => /Medium|Urgent|None|Low/.test(l));
-      expect(lines[0]).toContain("Urgent");
-      expect(lines[1]).toContain("Medium");
-      expect(lines[2]).toContain("Low");
-      expect(lines[3]).toContain("None");
-    });
-
-    test("hoists overdue tasks to the top of their status group", async () => {
-      await run(["add", "Urgent Future", "-p", "1", "--due", "2099-01-01"], testDir);
-      await run(["add", "Low Overdue", "-p", "4", "--due", "2020-01-01"], testDir);
-
-      const { stdout } = await run(["ls"], testDir);
-      const lines = stdout
-        .trim()
-        .split("\n")
-        .filter((l) => /Future|Overdue/.test(l));
-      expect(lines[0]).toContain("Low Overdue");
-      expect(lines[1]).toContain("Urgent Future");
-    });
-
-    test("sorts by due date when priority is equal", async () => {
-      await run(["add", "Later", "-p", "3", "--due", "2099-01-02"], testDir);
-      await run(["add", "Earlier", "-p", "3", "--due", "2099-01-01"], testDir);
-
-      const { stdout } = await run(["ls"], testDir);
-      const lines = stdout
-        .trim()
-        .split("\n")
-        .filter((l) => /Earlier|Later/.test(l));
-      expect(lines[0]).toContain("Earlier");
-      expect(lines[1]).toContain("Later");
-    });
-
-    test("sorts done tasks by completion time (newest first)", async () => {
-      const { stdout: id1 } = await run(["add", "Done First"], testDir);
-      const { stdout: id2 } = await run(["add", "Done Second"], testDir);
-      await run(["done", id1.trim()], testDir);
-      // Ensure time difference
-      await new Promise((r) => setTimeout(r, 10));
-      await run(["done", id2.trim()], testDir);
-
-      const { stdout } = await run(["ls", "-s", "done"], testDir);
-      const lines = stdout
-        .trim()
-        .split("\n")
-        .filter((l) => l.includes("Done"));
-      expect(lines[0]).toContain("Done Second");
-      expect(lines[1]).toContain("Done First");
-    });
-  });
-
-  describe("ready", () => {
-    test("shows active and unblocked open tasks", async () => {
-      const { stdout: id1 } = await run(["add", "Active task"], testDir);
-      await run(["start", id1.trim()], testDir);
-      await run(["add", "Open task"], testDir);
-      const { stdout: id2 } = await run(["add", "Blocked task"], testDir);
-      await run(["block", id2.trim(), id1.trim()], testDir);
-
-      const { stdout } = await run(["ready"], testDir);
-      expect(stdout).toContain("Active task");
-      expect(stdout).toContain("Open task");
-      expect(stdout).not.toContain("Blocked task");
-    });
-
-    test("shows blocked task after blocker is done", async () => {
-      const { stdout: id1 } = await run(["add", "Blocker"], testDir);
-      const { stdout: id2 } = await run(["add", "Blocked"], testDir);
-      await run(["block", id2.trim(), id1.trim()], testDir);
-      await run(["done", id1.trim()], testDir);
-
-      const { stdout } = await run(["ready"], testDir);
-      expect(stdout).toContain("Blocked");
-    });
-  });
-
-  describe("status transitions", () => {
-    test("start: open -> active", async () => {
-      const { stdout: id } = await run(["add", "Task"], testDir);
-      await run(["start", id.trim()], testDir);
-
-      const { stdout } = await run(["show", id.trim(), "--json"], testDir);
-      const task = JSON.parse(stdout);
-      expect(task.status).toBe("active");
-    });
-
-    test("done: any -> done", async () => {
-      const { stdout: id } = await run(["add", "Task"], testDir);
-      await run(["done", id.trim()], testDir);
-
-      const { stdout } = await run(["show", id.trim(), "--json"], testDir);
-      const task = JSON.parse(stdout);
-      expect(task.status).toBe("done");
-      expect(task.completed_at).not.toBeNull();
-    });
-
-    test("reopen: done -> open", async () => {
-      const { stdout: id } = await run(["add", "Task"], testDir);
-      await run(["done", id.trim()], testDir);
-      await run(["reopen", id.trim()], testDir);
-
-      const { stdout } = await run(["show", id.trim(), "--json"], testDir);
-      const task = JSON.parse(stdout);
-      expect(task.status).toBe("open");
-      expect(task.completed_at).toBeNull();
-    });
-
-    test("start errors if already active", async () => {
-      const { stdout: id } = await run(["add", "Task"], testDir);
-      await run(["start", id.trim()], testDir);
-
-      const { stderr, exitCode } = await run(["start", id.trim()], testDir);
-      expect(exitCode).toBe(1);
-      expect(stderr).toContain("already active");
-      expect(stderr).toContain("tk done"); // suggests next action
-    });
-
-    test("start errors if already done", async () => {
-      const { stdout: id } = await run(["add", "Task"], testDir);
-      await run(["done", id.trim()], testDir);
-
-      const { stderr, exitCode } = await run(["start", id.trim()], testDir);
-      expect(exitCode).toBe(1);
-      expect(stderr).toContain("already done");
-      expect(stderr).toContain("tk reopen"); // suggests next action
-    });
-  });
-
-  describe("edit", () => {
-    test("updates title", async () => {
-      const { stdout: id } = await run(["add", "Original"], testDir);
-      await run(["edit", id.trim(), "-t", "Updated"], testDir);
-
-      const { stdout } = await run(["show", id.trim(), "--json"], testDir);
-      const task = JSON.parse(stdout);
-      expect(task.title).toBe("Updated");
-    });
-
-    test("updates priority", async () => {
-      const { stdout: id } = await run(["add", "Task", "-p", "3"], testDir);
-      await run(["edit", id.trim(), "-p", "1"], testDir);
-
-      const { stdout } = await run(["show", id.trim(), "--json"], testDir);
-      const task = JSON.parse(stdout);
-      expect(task.priority).toBe(1);
-    });
-
-    test("adds label with +", async () => {
-      const { stdout: id } = await run(["add", "Task", "-l", "bug"], testDir);
-      await run(["edit", id.trim(), "-l", "+urgent"], testDir);
-
-      const { stdout } = await run(["show", id.trim(), "--json"], testDir);
-      const task = JSON.parse(stdout);
-      expect(task.labels).toContain("bug");
-      expect(task.labels).toContain("urgent");
-    });
-
-    test("removes label with -", async () => {
-      const { stdout: id } = await run(["add", "Task", "-l", "bug,urgent"], testDir);
-      // Use --labels= format to avoid -bug being parsed as flag
-      await run(["edit", id.trim(), "--labels=-bug"], testDir);
-
-      const { stdout } = await run(["show", id.trim(), "--json"], testDir);
-      const task = JSON.parse(stdout);
-      expect(task.labels).not.toContain("bug");
-      expect(task.labels).toContain("urgent");
-    });
-
-    test("prevents duplicate labels with +", async () => {
-      const { stdout: id } = await run(["add", "Task", "-l", "bug"], testDir);
-      await run(["edit", id.trim(), "-l", "+bug"], testDir);
-
-      const { stdout } = await run(["show", id.trim(), "--json"], testDir);
-      const task = JSON.parse(stdout);
-      expect(task.labels).toEqual(["bug"]);
-    });
-
-    test("errors on self-referential parent", async () => {
-      const { stdout: id } = await run(["add", "Task"], testDir);
-      const { stderr, exitCode } = await run(["edit", id.trim(), "--parent", id.trim()], testDir);
-      expect(exitCode).toBe(1);
-      expect(stderr).toContain("cannot be its own parent");
-    });
-
-    test("errors on parent cycle", async () => {
-      const { stdout: id1 } = await run(["add", "Parent"], testDir);
-      const { stdout: id2 } = await run(["add", "Child", "--parent", id1.trim()], testDir);
-      const { stderr, exitCode } = await run(["edit", id1.trim(), "--parent", id2.trim()], testDir);
-      expect(exitCode).toBe(1);
-      expect(stderr).toContain("circular parent");
-    });
-  });
-
-  describe("log", () => {
-    test("adds log entry", async () => {
-      const { stdout: id } = await run(["add", "Task"], testDir);
-      await run(["log", id.trim(), "First entry"], testDir);
-      await run(["log", id.trim(), "Second entry"], testDir);
-
-      const { stdout } = await run(["show", id.trim(), "--json"], testDir);
-      const task = JSON.parse(stdout);
-      expect(task.logs.length).toBe(2);
-      expect(task.logs[0].msg).toBe("First entry");
-      expect(task.logs[1].msg).toBe("Second entry");
-    });
-  });
-
-  describe("block/unblock", () => {
-    test("block prevents task from being ready", async () => {
-      const { stdout: id1 } = await run(["add", "Blocker"], testDir);
-      const { stdout: id2 } = await run(["add", "Blocked"], testDir);
-      await run(["block", id2.trim(), id1.trim()], testDir);
-
-      const { stdout } = await run(["show", id2.trim(), "--json"], testDir);
-      const task = JSON.parse(stdout);
-      expect(task.blocked_by).toContain(id1.trim());
-      expect(task.blocked_by_incomplete).toBe(true);
-    });
-
-    test("unblock removes dependency", async () => {
-      const { stdout: id1 } = await run(["add", "Blocker"], testDir);
-      const { stdout: id2 } = await run(["add", "Blocked"], testDir);
-      await run(["block", id2.trim(), id1.trim()], testDir);
-      await run(["unblock", id2.trim(), id1.trim()], testDir);
-
-      const { stdout } = await run(["show", id2.trim(), "--json"], testDir);
-      const task = JSON.parse(stdout);
-      expect(task.blocked_by).not.toContain(id1.trim());
-    });
-
-    test("cannot block self", async () => {
-      const { stdout: id } = await run(["add", "Task"], testDir);
-      const { stderr, exitCode } = await run(["block", id.trim(), id.trim()], testDir);
-      expect(exitCode).toBe(1);
-      expect(stderr).toContain("cannot block itself");
-    });
-
-    test("validates blocker exists", async () => {
-      const { stdout: id } = await run(["add", "Task"], testDir);
-      const { stderr, exitCode } = await run(["block", id.trim(), "tk-999"], testDir);
-      expect(exitCode).toBe(1);
-      expect(stderr).toContain("not found");
-    });
-
-    test("detects circular dependencies", async () => {
-      const { stdout: id1 } = await run(["add", "Task A"], testDir);
-      const { stdout: id2 } = await run(["add", "Task B"], testDir);
-      const { stdout: id3 } = await run(["add", "Task C"], testDir);
-
-      await run(["block", id1.trim(), id2.trim()], testDir);
-      await run(["block", id2.trim(), id3.trim()], testDir);
-
-      const { stderr, exitCode } = await run(["block", id3.trim(), id1.trim()], testDir);
-      expect(exitCode).toBe(1);
-      expect(stderr).toContain("circular");
-    });
-  });
-
-  describe("rm", () => {
-    test("deletes task", async () => {
-      const { stdout: id } = await run(["add", "Task"], testDir);
-      await run(["rm", id.trim()], testDir);
-
-      const { stderr, exitCode } = await run(["show", id.trim()], testDir);
-      expect(exitCode).toBe(1);
-      expect(stderr).toContain("not found");
-    });
-
-    test("removes associated blocks", async () => {
-      const { stdout: id1 } = await run(["add", "Blocker"], testDir);
-      const { stdout: id2 } = await run(["add", "Blocked"], testDir);
-      await run(["block", id2.trim(), id1.trim()], testDir);
-      await run(["rm", id1.trim()], testDir);
-
-      const { stdout } = await run(["show", id2.trim(), "--json"], testDir);
-      const task = JSON.parse(stdout);
-      expect(task.blocked_by).not.toContain(id1.trim());
-    });
-
-    test("clears parent references on child tasks", async () => {
-      const { stdout: parentId } = await run(["add", "Parent"], testDir);
-      const { stdout: childId } = await run(["add", "Child", "--parent", parentId.trim()], testDir);
-
-      // Verify child has parent
-      const { stdout: before } = await run(["show", childId.trim(), "--json"], testDir);
-      expect(JSON.parse(before).parent).toBe(parentId.trim());
-
-      // Delete parent
-      await run(["rm", parentId.trim()], testDir);
-
-      // Child's parent should be cleared
-      const { stdout: after } = await run(["show", childId.trim(), "--json"], testDir);
-      expect(JSON.parse(after).parent).toBeNull();
-    });
-  });
-
-  describe("clean", () => {
-    test("removes completed tasks", async () => {
-      const { stdout: id } = await run(["add", "Task"], testDir);
-      await run(["done", id.trim()], testDir);
-      await run(["clean", "--force"], testDir);
-
-      const { exitCode } = await run(["show", id.trim()], testDir);
-      expect(exitCode).toBe(1);
-    });
-
-    test("keeps open tasks", async () => {
-      const { stdout: id } = await run(["add", "Open task"], testDir);
-      await run(["clean", "--force"], testDir);
-
-      const { exitCode } = await run(["show", id.trim()], testDir);
-      expect(exitCode).toBe(0);
-    });
-
-    test("--older-than respects age threshold", async () => {
-      const { stdout: id } = await run(["add", "Task"], testDir);
-      await run(["done", id.trim()], testDir);
-
-      // Task was just completed, so --older-than 1 should keep it
-      await run(["clean", "--older-than", "1"], testDir);
-      const { exitCode: stillExists } = await run(["show", id.trim()], testDir);
-      expect(stillExists).toBe(0);
-
-      // --older-than 0 should remove it (0 days = remove all)
-      await run(["clean", "--older-than", "0"], testDir);
-      const { exitCode: gone } = await run(["show", id.trim()], testDir);
-      expect(gone).toBe(1);
-    });
-  });
-
-  describe("init", () => {
-    test("creates .tasks directory", async () => {
-      const newDir = mkdtempSync(join(tmpdir(), "tk-init-"));
-      Bun.spawnSync(["git", "init"], { cwd: newDir });
-
-      const { stdout, exitCode } = await run(["init"], newDir);
-      expect(exitCode).toBe(0);
-      expect(stdout).toContain("Initialized");
-      expect(existsSync(join(newDir, ".tasks"))).toBe(true);
-
-      rmSync(newDir, { recursive: true, force: true });
-    });
-
-    test("creates .tasks with custom project", async () => {
-      const newDir = mkdtempSync(join(tmpdir(), "tk-init-"));
-      Bun.spawnSync(["git", "init"], { cwd: newDir });
-
-      await run(["init", "-P", "api"], newDir);
-      const { stdout } = await run(["add", "Task"], newDir);
-      expect(stdout).toMatch(/^api-[a-z0-9]{4}$/);
-
-      rmSync(newDir, { recursive: true, force: true });
-    });
-
-    test("reports already initialized", async () => {
-      await run(["init"], testDir);
-      const { stdout } = await run(["init"], testDir);
-      expect(stdout).toContain("Already initialized");
-    });
-  });
-
-  describe("config", () => {
-    test("shows config", async () => {
-      await run(["init"], testDir);
-      const { stdout } = await run(["config"], testDir);
-      expect(stdout).toContain("Version:");
-      expect(stdout).toContain("Project:");
-    });
-
-    test("shows default project derived from directory", async () => {
-      await run(["init"], testDir);
-      const { stdout } = await run(["config", "project"], testDir);
-      // Project is derived from directory name (tktest... from temp dir)
-      expect(stdout).toMatch(/^tktest[a-z0-9]+$/);
-    });
-
-    test("respects explicit project name", async () => {
-      await run(["init", "--project", "myapp"], testDir);
-      const { stdout } = await run(["config", "project"], testDir);
-      expect(stdout).toBe("myapp");
-    });
-
-    test("sets default project", async () => {
-      await run(["init"], testDir);
-      await run(["config", "project", "api"], testDir);
-
-      const { stdout } = await run(["add", "Task"], testDir);
-      expect(stdout).toMatch(/^api-[a-z0-9]{4}$/);
-    });
-
-    test("manages aliases", async () => {
-      await run(["init"], testDir);
-      await run(["config", "alias", "api", "packages/api"], testDir);
-
-      const { stdout } = await run(["config", "alias"], testDir);
-      expect(stdout).toContain("api");
-      expect(stdout).toContain("packages/api");
-    });
-
-    test("renames project and updates references", async () => {
-      await run(["init", "-P", "old"], testDir);
-
-      // Create tasks with references
-      const { stdout: id1 } = await run(["add", "Task 1"], testDir);
-      const { stdout: id2 } = await run(["add", "Task 2"], testDir);
-      await run(["block", id2.trim(), id1.trim()], testDir);
-
-      // Rename project
-      const { stdout, exitCode } = await run(
-        ["config", "project", "new", "--rename", "old"],
-        testDir,
-      );
-      expect(exitCode).toBe(0);
-      expect(stdout).toContain("Renamed 2 tasks");
-      expect(stdout).toContain("old-*");
-      expect(stdout).toContain("new-*");
-
-      // Verify new IDs work
-      const newId1 = id1.trim().replace("old-", "new-");
-      const { exitCode: showCode } = await run(["show", newId1], testDir);
-      expect(showCode).toBe(0);
-
-      // Verify references updated
-      const { stdout: showOut } = await run(
-        ["show", id2.trim().replace("old-", "new-"), "--json"],
-        testDir,
-      );
-      const task = JSON.parse(showOut);
-      expect(task.blocked_by[0]).toBe(newId1);
-    });
-  });
-
-  describe("error handling", () => {
-    describe("validation errors", () => {
-      test("invalid status shows valid options", async () => {
-        const { stderr, exitCode } = await run(["ls", "-s", "invalid"], testDir);
-        expect(exitCode).toBe(1);
-        expect(stderr).toContain("Invalid status");
-        expect(stderr).toContain("open");
-        expect(stderr).toContain("active");
-        expect(stderr).toContain("done");
-      });
-
-      test("invalid priority shows valid formats", async () => {
-        const { stderr, exitCode } = await run(["add", "Task", "-p", "p9"], testDir);
-        expect(exitCode).toBe(1);
-        expect(stderr).toContain("Invalid priority");
-      });
-    });
-
-    describe("missing arguments", () => {
-      test("show without ID", async () => {
-        const { stderr, exitCode } = await run(["show"], testDir);
-        expect(exitCode).toBe(1);
-        expect(stderr).toContain("ID required");
-      });
-
-      test("log without message", async () => {
-        const { stdout: id } = await run(["add", "Task"], testDir);
-        const { stderr, exitCode } = await run(["log", id.trim()], testDir);
-        expect(exitCode).toBe(1);
-        expect(stderr).toContain("Message required");
-      });
-    });
-
-    describe("invalid ID format", () => {
-      test("rejects invalid ID format", async () => {
-        const { stderr, exitCode } = await run(["show", "invalid"], testDir);
-        expect(exitCode).toBe(1);
-        expect(stderr).toContain("not found");
-      });
-    });
-
-    describe("not found errors", () => {
-      test("show non-existent task", async () => {
-        const { stderr, exitCode } = await run(["show", "tk-999"], testDir);
-        expect(exitCode).toBe(1);
-        expect(stderr).toContain("Task not found");
-      });
-    });
-  });
-
-  describe("flag position flexibility", () => {
-    test("--json works after command", async () => {
-      await run(["add", "Task"], testDir);
-      const { stdout, exitCode } = await run(["ls", "--json"], testDir);
-      expect(exitCode).toBe(0);
-      const tasks = JSON.parse(stdout);
-      expect(Array.isArray(tasks)).toBe(true);
-    });
-
-    test("--json works before command", async () => {
-      await run(["add", "Task"], testDir);
-      const { stdout, exitCode } = await run(["--json", "ls"], testDir);
-      expect(exitCode).toBe(0);
-      const tasks = JSON.parse(stdout);
-      expect(Array.isArray(tasks)).toBe(true);
-    });
-
-    test("log requires quoted message", async () => {
-      const { stdout: id } = await run(["add", "Task"], testDir);
-      const taskId = id.trim();
-
-      // Unquoted multiple words should error
-      const { stderr, exitCode } = await run(["log", taskId, "word1", "word2"], testDir);
-      expect(exitCode).toBe(1);
-      expect(stderr).toContain("must be quoted");
-
-      // Quoted message works (shell passes as single arg)
-      await run(["log", taskId, "Quoted message works"], testDir);
-      const { stdout } = await run(["show", "--json", taskId], testDir);
-      const task = JSON.parse(stdout);
-      expect(task.logs[0].msg).toBe("Quoted message works");
-    });
-  });
-
-  describe("ID resolution", () => {
-    test("can use just ref if unambiguous", async () => {
-      const { stdout: id } = await run(["add", "Task"], testDir);
-      const ref = id.trim().split("-")[1] ?? "";
-
-      const { exitCode } = await run(["show", ref], testDir);
-      expect(exitCode).toBe(0);
-    });
-
-    test("full ID always works", async () => {
-      const { stdout: id } = await run(["add", "Task"], testDir);
-
-      const { exitCode } = await run(["show", id.trim()], testDir);
-      expect(exitCode).toBe(0);
-    });
-
-    test("ambiguous ID shows matching tasks", async () => {
-      // Create tasks with same ref prefix in different projects
-      const { stdout: id1 } = await run(["add", "Task 1", "-P", "api"], testDir);
-      const { stdout: id2 } = await run(["add", "Task 2", "-P", "web"], testDir);
-      const ref1 = id1.trim().split("-")[1] ?? "";
-      const ref2 = id2.trim().split("-")[1] ?? "";
-
-      // Use first char which might match both
-      const prefix = ref1[0] ?? "";
-
-      // Only test if both refs start with same char (otherwise not ambiguous)
-      if (ref2.startsWith(prefix)) {
-        const { stderr, exitCode } = await run(["show", prefix], testDir);
-        expect(exitCode).toBe(1);
-        expect(stderr).toContain("Ambiguous");
-        expect(stderr).toContain("matches");
-      }
-    });
-
-    test("not found shows clear error", async () => {
-      const { stderr, exitCode } = await run(["show", "zzzz"], testDir);
-      expect(exitCode).toBe(1);
-      expect(stderr).toContain("not found");
-    });
-  });
-
-  describe("tk check", () => {
-    test("reports all OK when no issues", async () => {
-      await run(["add", "Task 1"], testDir);
-      await run(["add", "Task 2"], testDir);
-
-      const { stdout, exitCode } = await run(["check"], testDir);
-      expect(exitCode).toBe(0);
-      expect(stdout).toContain("2 tasks OK");
-    });
-
-    test("auto-fixes orphaned blocker reference", async () => {
-      // Create two tasks and block one by the other
-      const { stdout: id1 } = await run(["add", "Blocker"], testDir);
-      const { stdout: id2 } = await run(["add", "Blocked"], testDir);
-      const blockerId = id1.trim();
-      const blockedId = id2.trim();
-
-      await run(["block", blockedId, blockerId], testDir);
-
-      // Manually delete blocker file to simulate merge
-      const fs = await import("fs");
-      const path = await import("path");
-      const blockerFile = path.join(testDir, ".tasks", `${blockerId}.json`);
-      fs.unlinkSync(blockerFile);
-
-      // Check should fix it
-      const { stdout } = await run(["check"], testDir);
-      expect(stdout).toContain("cleaned");
-      expect(stdout).toContain("orphaned");
-
-      // Verify the blocked_by is now empty
-      const { stdout: showOut } = await run(["show", "--json", blockedId], testDir);
-      const task = JSON.parse(showOut);
-      expect(task.blocked_by).toEqual([]);
-    });
-
-    test("auto-fixes orphaned parent reference", async () => {
-      // Create parent and child
-      const { stdout: parentId } = await run(["add", "Parent"], testDir);
-      const parent = parentId.trim();
-      const { stdout: childId } = await run(["add", "Child", "--parent", parent], testDir);
-      const child = childId.trim();
-
-      // Manually delete parent file
-      const fs = await import("fs");
-      const path = await import("path");
-      const parentFile = path.join(testDir, ".tasks", `${parent}.json`);
-      fs.unlinkSync(parentFile);
-
-      // Check should fix it
-      const { stdout } = await run(["check"], testDir);
-      expect(stdout).toContain("cleaned");
-      expect(stdout).toContain("orphaned parent");
-
-      // Verify parent is now null
-      const { stdout: showOut } = await run(["show", "--json", child], testDir);
-      const task = JSON.parse(showOut);
-      expect(task.parent).toBeNull();
-    });
-
-    test("auto-fix happens on show command", async () => {
-      // Create two tasks and block one
-      const { stdout: id1 } = await run(["add", "Blocker"], testDir);
-      const { stdout: id2 } = await run(["add", "Blocked"], testDir);
-      const blockerId = id1.trim();
-      const blockedId = id2.trim();
-
-      await run(["block", blockedId, blockerId], testDir);
-
-      // Manually delete blocker file
-      const fs = await import("fs");
-      const path = await import("path");
-      const blockerFile = path.join(testDir, ".tasks", `${blockerId}.json`);
-      fs.unlinkSync(blockerFile);
-
-      // Show should auto-fix and output cleanup message
-      const { stderr } = await run(["show", blockedId], testDir);
-      expect(stderr).toContain("cleaned");
-      expect(stderr).toContain("orphaned");
-    });
-
-    test("reports unfixable corrupted JSON", async () => {
-      await run(["add", "Good task"], testDir);
-
-      // Create a corrupted JSON file
-      const fs = await import("fs");
-      const path = await import("path");
-      const corruptFile = path.join(testDir, ".tasks", "test-bad1.json");
-      fs.writeFileSync(corruptFile, "{ invalid json");
-
-      const { stdout } = await run(["check"], testDir);
-      expect(stdout).toContain("Unfixable");
-      expect(stdout).toContain("test-bad1.json");
-    });
-
-    test("reports unfixable invalid task structure", async () => {
-      await run(["add", "Good task"], testDir);
-
-      // Create valid JSON but invalid task structure
-      const fs = await import("fs");
-      const path = await import("path");
-      const badFile = path.join(testDir, ".tasks", "test-bad2.json");
-      fs.writeFileSync(badFile, '{"foo": "bar"}');
-
-      const { stdout } = await run(["check"], testDir);
-      expect(stdout).toContain("Unfixable");
-      expect(stdout).toContain("test-bad2.json");
-      expect(stdout).toContain("Invalid task structure");
-    });
-
-    test("auto-fixes ID mismatch (filename vs content)", async () => {
-      // Create a task
-      const { stdout: id } = await run(["add", "Test task", "-P", "api"], testDir);
-      const taskId = id.trim();
-
-      // Manually rename the file to create a mismatch
-      const fs = await import("fs");
-      const path = await import("path");
-      const oldPath = path.join(testDir, ".tasks", `${taskId}.json`);
-      const newPath = path.join(testDir, ".tasks", "web-x1y2.json");
-      fs.renameSync(oldPath, newPath);
-
-      // Check should fix it
-      const { stdout } = await run(["check"], testDir);
-      expect(stdout).toContain("cleaned");
-      expect(stdout).toContain("ID mismatch");
-
-      // Verify the content was updated to match filename
-      const { stdout: showOut } = await run(["show", "--json", "web-x1y2"], testDir);
-      const task = JSON.parse(showOut);
-      expect(task.project).toBe("web");
-      expect(task.ref).toBe("x1y2");
-    });
-
-    test("check --json returns structured output", async () => {
-      await run(["add", "Task"], testDir);
-
-      const { stdout } = await run(["check", "--json"], testDir);
-      const result = JSON.parse(stdout);
-      expect(result).toHaveProperty("totalTasks");
-      expect(result).toHaveProperty("cleaned");
-      expect(result).toHaveProperty("unfixable");
-    });
-  });
-});