@nijaru/tk 0.0.3 → 0.0.5

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@nijaru/tk",
-	"version": "0.0.3",
+	"version": "0.0.5",
 	"description": "Minimal task tracker",
 	"type": "module",
 	"bin": {

package/src/cli.test.ts

@@ -57,6 +57,19 @@ describe("tk CLI", () => {
     expect(lsHelp).toContain("--status");
   });
 
+  test("tk mv --help shows mv help", async () => {
+    const { stdout, exitCode } = await run(["mv", "--help"], testDir);
+    expect(exitCode).toBe(0);
+    expect(stdout).toContain("tk mv");
+    expect(stdout).toContain("<project>");
+  });
+
+  test("tk move --help shows move help", async () => {
+    const { stdout, exitCode } = await run(["move", "--help"], testDir);
+    expect(exitCode).toBe(0);
+    expect(stdout).toContain("tk move");
+  });
+
   test("help <command> shows command-specific help", async () => {
     const { stdout, exitCode } = await run(["help", "add"], testDir);
     expect(exitCode).toBe(0);
@@ -320,6 +333,62 @@ describe("tk CLI", () => {
       expect(lines[0]).toContain("Done Second");
       expect(lines[1]).toContain("Done First");
     });
+
+    test("shows [due today] annotation for task due today", async () => {
+      await run(["add", "Due Today Task", "--due", "+0d"], testDir);
+
+      const { stdout } = await run(["ls"], testDir);
+      expect(stdout).toContain("[due today]");
+    });
+
+    test("shows [due Nd] annotation for task due within threshold", async () => {
+      await run(["add", "Due Soon Task", "--due", "+3d"], testDir);
+
+      const { stdout } = await run(["ls"], testDir);
+      expect(stdout).toContain("[due 3d]");
+    });
+
+    test("no due-soon annotation for task due beyond threshold", async () => {
+      await run(["add", "Far Future Task", "--due", "2099-01-01"], testDir);
+
+      const { stdout } = await run(["ls"], testDir);
+      expect(stdout).not.toContain("[due ");
+    });
+
+    test("no due-soon annotation for overdue task (shows [OVERDUE] instead)", async () => {
+      await run(["add", "Overdue Task", "--due", "2020-01-01"], testDir);
+
+      const { stdout } = await run(["ls"], testDir);
+      expect(stdout).toContain("[OVERDUE]");
+      expect(stdout).not.toContain("[due today]");
+    });
+
+    test("--json includes days_until_due field", async () => {
+      await run(["add", "Due Today", "--due", "+0d"], testDir);
+
+      const { stdout } = await run(["ls", "--json"], testDir);
+      const tasks = JSON.parse(stdout);
+      expect(tasks[0]).toHaveProperty("days_until_due");
+      expect(tasks[0].days_until_due).toBe(0);
+    });
+  });
+
+  describe("show (due-soon)", () => {
+    test("shows [due today] in detail view", async () => {
+      const { stdout: idOut } = await run(["add", "Due Today", "--due", "+0d"], testDir);
+      const id = idOut.trim();
+
+      const { stdout } = await run(["show", id], testDir);
+      expect(stdout).toContain("[due today]");
+    });
+
+    test("shows [due Nd] in detail view", async () => {
+      const { stdout: idOut } = await run(["add", "Due Soon", "--due", "+4d"], testDir);
+      const id = idOut.trim();
+
+      const { stdout } = await run(["show", id], testDir);
+      expect(stdout).toContain("[due 4d]");
+    });
   });
 
   describe("ready", () => {
@@ -604,25 +673,29 @@ describe("tk CLI", () => {
   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 });
+      try {
+        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);
+      } finally {
+        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 });
+      try {
+        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}$/);
+      } finally {
+        rmSync(newDir, { recursive: true, force: true });
+      }
     });
 
     test("reports already initialized", async () => {
@@ -661,15 +734,6 @@ describe("tk CLI", () => {
       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);
 
@@ -804,22 +868,14 @@ describe("tk CLI", () => {
     });
 
     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");
-      }
+      // Two tasks in the same project share the "api-" prefix — guaranteed ambiguous
+      await run(["add", "Task 1", "-P", "api"], testDir);
+      await run(["add", "Task 2", "-P", "api"], testDir);
+
+      const { stderr, exitCode } = await run(["show", "api"], testDir);
+      expect(exitCode).toBe(1);
+      expect(stderr).toContain("Ambiguous");
+      expect(stderr).toContain("matches");
     });
 
     test("not found shows clear error", async () => {
@@ -973,4 +1029,144 @@ describe("tk CLI", () => {
       expect(result).toHaveProperty("unfixable");
     });
   });
+
+  describe("mv", () => {
+    test("moves task to a different project", async () => {
+      await run(["init"], testDir);
+      const { stdout: idOut } = await run(["add", "Move me", "-P", "src"], testDir);
+      const oldId = idOut.trim();
+      const ref = oldId.split("-")[1];
+
+      const { stdout, exitCode } = await run(["mv", oldId, "dst"], testDir);
+      expect(exitCode).toBe(0);
+      const newId = `dst-${ref}`;
+      expect(stdout).toContain(oldId);
+      expect(stdout).toContain(newId);
+
+      // Old ID gone, new ID exists with same content
+      const { exitCode: notFound } = await run(["show", oldId], testDir);
+      expect(notFound).toBe(1);
+
+      const { stdout: showOut } = await run(["show", newId, "--json"], testDir);
+      const task = JSON.parse(showOut);
+      expect(task.project).toBe("dst");
+      expect(task.title).toBe("Move me");
+    });
+
+    test("updates blocked_by and parent references", async () => {
+      await run(["init"], testDir);
+      const { stdout: idA } = await run(["add", "A", "-P", "src"], testDir);
+      const { stdout: idB } = await run(["add", "B", "-P", "src"], testDir);
+      const aId = idA.trim();
+      const bId = idB.trim();
+
+      // B is blocked by A, and B has A as parent
+      await run(["block", bId, aId], testDir);
+      await run(["edit", bId, "--parent", aId], testDir);
+
+      const ref = aId.split("-")[1];
+      await run(["mv", aId, "dst"], testDir);
+      const newAId = `dst-${ref}`;
+
+      const { stdout: showB } = await run(["show", bId, "--json"], testDir);
+      const bTask = JSON.parse(showB);
+      expect(bTask.blocked_by).toContain(newAId);
+      expect(bTask.parent).toBe(newAId);
+    });
+
+    test("errors when moving to same project", async () => {
+      await run(["init"], testDir);
+      const { stdout: idOut } = await run(["add", "Task", "-P", "api"], testDir);
+      const id = idOut.trim();
+
+      const { stderr, exitCode } = await run(["mv", id, "api"], testDir);
+      expect(exitCode).toBe(1);
+      expect(stderr).toContain("already in project");
+    });
+
+    test("errors on ref collision", async () => {
+      await run(["init"], testDir);
+      const { stdout: idOut } = await run(["add", "Task A", "-P", "src"], testDir);
+      const id = idOut.trim();
+      const ref = id.split("-")[1]!;
+
+      // Manually create a collision in dst project
+      const fs = await import("fs");
+      const path = await import("path");
+      const collisionPath = path.join(testDir, ".tasks", `dst-${ref}.json`);
+      fs.writeFileSync(
+        collisionPath,
+        JSON.stringify({
+          project: "dst",
+          ref,
+          title: "Collision",
+          status: "open",
+          priority: 3,
+          labels: [],
+          assignees: [],
+          parent: null,
+          blocked_by: [],
+          estimate: null,
+          due_date: null,
+          logs: [],
+          description: null,
+          created_at: new Date().toISOString(),
+          updated_at: new Date().toISOString(),
+          completed_at: null,
+          external: {},
+        }),
+      );
+
+      const { stderr, exitCode } = await run(["mv", id, "dst"], testDir);
+      expect(exitCode).toBe(1);
+      expect(stderr).toContain("already exists");
+    });
+
+    test("errors on missing arguments", async () => {
+      await run(["init"], testDir);
+      const { stdout: idOut } = await run(["add", "Task"], testDir);
+      const id = idOut.trim();
+
+      const { stderr: noProject } = await run(["mv", id], testDir);
+      expect(noProject).toContain("Project required");
+    });
+
+    test("errors on invalid project name", async () => {
+      await run(["init"], testDir);
+      const { stdout: idOut } = await run(["add", "Task", "-P", "src"], testDir);
+      const id = idOut.trim();
+
+      const { stderr, exitCode } = await run(["mv", id, "Bad-Project"], testDir);
+      expect(exitCode).toBe(1);
+      expect(stderr).toContain("Invalid project name");
+    });
+
+    test("--json output structure", async () => {
+      await run(["init"], testDir);
+      const { stdout: idOut } = await run(["add", "Task", "-P", "src"], testDir);
+      const id = idOut.trim();
+
+      const { stdout, exitCode } = await run(["mv", id, "dst", "--json"], testDir);
+      expect(exitCode).toBe(0);
+      const result = JSON.parse(stdout);
+      expect(result).toHaveProperty("old_id");
+      expect(result).toHaveProperty("new_id");
+      expect(result).toHaveProperty("referencesUpdated");
+    });
+
+    test("partial ID resolution", async () => {
+      await run(["init"], testDir);
+      const { stdout: idOut } = await run(["add", "Task", "-P", "src"], testDir);
+      const id = idOut.trim();
+      const ref = id.split("-")[1]!;
+
+      // Use just the ref as partial ID
+      const { exitCode } = await run(["mv", ref, "dst"], testDir);
+      expect(exitCode).toBe(0);
+
+      // Verify moved
+      const { exitCode: found } = await run(["show", `dst-${ref}`], testDir);
+      expect(found).toBe(0);
+    });
+  });
 });