@nijaru/tk 0.0.1 → 0.0.3

package/README.md

@@ -1,22 +1,20 @@
 # tk
 
-Task tracker for AI agents. Simple, fast, git-friendly.
+Minimal task tracker. Simple, fast, git-friendly.
 
-**Requires [Bun](https://bun.sh) runtime.**
+- Plain JSON files in `.tasks/`
+- No daemons, no merge conflicts, no viruses
 
 ## Install
 
+Requires [Bun](https://bun.sh) runtime.
+
 ```bash
 # Install Bun first (if not installed)
 curl -fsSL https://bun.sh/install | bash
 
 # Then install tk globally
 bun add -g @nijaru/tk
-
-# Or run from source
-git clone https://github.com/nijaru/tk.git
-cd tk && bun install
-bun run src/cli.ts --help
 ```
 
 ## Quick Start
@@ -35,9 +33,9 @@ myapp-x9k2
 $ tk block x9k2 a7b3                # tests blocked by auth (just use ref)
 
 $ tk ready                          # what can I work on?
-ID           PRI STATUS     TITLE
-------------------------------------------------------------
-myapp-a7b3   p1  open       Implement auth
+ID          | PRIO | STATUS       | TITLE
+-----------------------------------------------------------------
+myapp-a7b3  | p1   | open         | Implement auth
 
 $ tk start a7b3                     # just the ref works everywhere
 Started: myapp-a7b3
@@ -49,9 +47,9 @@ $ tk done a7b3
 Completed: myapp-a7b3
 
 $ tk ready                          # tests now unblocked
-ID           PRI STATUS     TITLE
-------------------------------------------------------------
-myapp-x9k2   p2  open       Write tests
+ID          | PRIO | STATUS       | TITLE
+-----------------------------------------------------------------
+myapp-x9k2  | p2   | open         | Write tests
 ```
 
 ## Commands
@@ -61,17 +59,18 @@ myapp-x9k2   p2  open       Write tests
 | `tk init`                   | Initialize (project name from directory)   |
 | `tk add <title>`            | Create task                                |
 | `tk ls` / `tk list`         | List tasks                                 |
-| `tk ready`                  | List open + unblocked tasks                |
+| `tk ready`                  | List active/open + unblocked tasks         |
 | `tk show <id>`              | Show task details                          |
 | `tk start <id>`             | Start working (open → active)              |
 | `tk done <id>`              | Complete task                              |
 | `tk reopen <id>`            | Reopen task                                |
 | `tk edit <id>`              | Edit task                                  |
-| `tk log <id> <msg>`         | Add log entry                              |
+| `tk log <id> "<msg>"`       | Add log entry                              |
 | `tk block <id> <blocker>`   | Add dependency (id blocked by blocker)     |
 | `tk unblock <id> <blocker>` | Remove dependency                          |
 | `tk rm` / `tk remove <id>`  | Delete task                                |
-| `tk clean`                  | Remove old done tasks (default: 7d)        |
+| `tk clean`                  | Remove old done tasks (default: 14 days)   |
+| `tk check`                  | Check task integrity                       |
 | `tk config`                 | Show/set configuration                     |
 | `tk completions <shell>`    | Output shell completions (bash, zsh, fish) |
 | `tk help [command]`         | Show help (or command-specific help)       |
@@ -120,9 +119,9 @@ tk edit a7b3 --parent -        # Clear parent
 ## Clean Options
 
 ```bash
-tk clean                       # Remove done tasks older than 7 days
-tk clean --older-than 30d      # Custom retention (Nd/Nw/Nm/Nh)
-tk clean -a                    # Remove all done tasks (ignore age)
+tk clean                       # Remove done tasks older than config (default: 14 days)
+tk clean --older-than 30       # Custom threshold (days)
+tk clean --force               # Force clean even if disabled in config
 ```
 
 ## Config
@@ -131,12 +130,26 @@ tk clean -a                    # Remove all done tasks (ignore age)
 tk config                                       # Show all config
 tk config project                               # Show default project
 tk config project api                           # Set default project
-tk config project lsmvec --rename cloudlsmvec   # Rename all cloudlsmvec-* → lsmvec-*
+tk config project lsmvec --rename cloudlsmvec   # Rename cloudlsmvec-* → lsmvec-*
 tk config alias                                 # List aliases
 tk config alias web src/web                     # Add alias
 tk config alias --rm web                        # Remove alias
 ```
 
+Config file (`.tasks/config.json`):
+
+```json
+{
+  "version": 1,
+  "project": "myapp",
+  "clean_after": 14,
+  "defaults": { "priority": 3, "labels": [], "assignees": [] },
+  "aliases": {}
+}
+```
+
+- `clean_after`: Days to keep done tasks (default: 14). Set to `false` to disable cleaning.
+
 ## Task IDs
 
 Format: `project-ref` (e.g., `myapp-a7b3`, `api-x9k2`, `web-3m8p`)
@@ -226,4 +239,4 @@ tk completions fish | source
 
 ## License
 
-MIT
+[MIT](LICENSE)

package/package.json

@@ -1,10 +1,10 @@
 {
 	"name": "@nijaru/tk",
-	"version": "0.0.1",
-	"description": "Task tracker for AI agents",
+	"version": "0.0.3",
+	"description": "Minimal task tracker",
 	"type": "module",
 	"bin": {
-		"tk": "./src/cli.ts"
+		"tk": "src/cli.ts"
 	},
 	"files": [
 		"src",
@@ -37,7 +37,7 @@
 	"license": "MIT",
 	"repository": {
 		"type": "git",
-		"url": "https://github.com/nijaru/tk"
+		"url": "git+https://github.com/nijaru/tk.git"
 	},
 	"author": "nijaru",
 	"homepage": "https://github.com/nijaru/tk#readme",

package/src/cli.test.ts

@@ -243,16 +243,96 @@ describe("tk CLI", () => {
       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 only unblocked open tasks", async () => {
-      const { stdout: id1 } = await run(["add", "Ready task"], testDir);
+    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("Ready task");
+      expect(stdout).toContain("Active task");
+      expect(stdout).toContain("Open task");
       expect(stdout).not.toContain("Blocked task");
     });
 
@@ -298,13 +378,24 @@ describe("tk CLI", () => {
       expect(task.completed_at).toBeNull();
     });
 
-    test("start errors if not open", async () => {
+    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("not open");
+      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
     });
   });
 
@@ -458,13 +549,29 @@ describe("tk CLI", () => {
       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", "--all"], testDir);
+      await run(["clean", "--force"], testDir);
 
       const { exitCode } = await run(["show", id.trim()], testDir);
       expect(exitCode).toBe(1);
@@ -472,11 +579,26 @@ describe("tk CLI", () => {
 
     test("keeps open tasks", async () => {
       const { stdout: id } = await run(["add", "Open task"], testDir);
-      await run(["clean", "--all"], 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", () => {
@@ -547,6 +669,38 @@ describe("tk CLI", () => {
       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", () => {
@@ -586,7 +740,7 @@ describe("tk CLI", () => {
       test("rejects invalid ID format", async () => {
         const { stderr, exitCode } = await run(["show", "invalid"], testDir);
         expect(exitCode).toBe(1);
-        expect(stderr).toContain("Invalid task ID");
+        expect(stderr).toContain("not found");
       });
     });
 
@@ -615,6 +769,22 @@ describe("tk CLI", () => {
       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", () => {
@@ -632,5 +802,175 @@ describe("tk CLI", () => {
       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");
+    });
   });
 });