@nijaru/tk 0.0.1

package/src/cli.test.ts

@@ -0,0 +1,636 @@
+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");
+    });
+  });
+
+  describe("ready", () => {
+    test("shows only unblocked open tasks", async () => {
+      const { stdout: id1 } = await run(["add", "Ready 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("Ready 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 not open", 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("not open");
+    });
+  });
+
+  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());
+    });
+  });
+
+  describe("clean", () => {
+    test("removes completed tasks", async () => {
+      const { stdout: id } = await run(["add", "Task"], testDir);
+      await run(["done", id.trim()], testDir);
+      await run(["clean", "--all"], 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", "--all"], testDir);
+
+      const { exitCode } = await run(["show", id.trim()], testDir);
+      expect(exitCode).toBe(0);
+    });
+  });
+
+  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");
+    });
+  });
+
+  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("Invalid task ID");
+      });
+    });
+
+    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);
+    });
+  });
+
+  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);
+    });
+  });
+});