@nijaru/tk 0.0.2 → 0.0.3

package/README.md

@@ -33,9 +33,9 @@ myapp-x9k2
 $ tk block x9k2 a7b3                # tests blocked by auth (just use ref)
 
 $ tk ready                          # what can I work on?
-ID          | PRIO | 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
@@ -47,9 +47,9 @@ $ tk done a7b3
 Completed: myapp-a7b3
 
 $ tk ready                          # tests now unblocked
-ID          | PRIO | STATUS  | TITLE
-------------------------------------------------------------
-myapp-x9k2  | p2   | open    | Write tests
+ID          | PRIO | STATUS       | TITLE
+-----------------------------------------------------------------
+myapp-x9k2  | p2   | open         | Write tests
 ```
 
 ## Commands
@@ -59,7 +59,7 @@ 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                              |
@@ -130,7 +130,7 @@ tk clean --force               # Force clean even if disabled in config
 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

package/package.json

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

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");
     });
 

package/src/cli.ts

@@ -4,6 +4,7 @@ import { version } from "../package.json";
 
 import * as storage from "./db/storage";
 import { parsePriority } from "./lib/priority";
+import { parseDueDate, parseEstimate } from "./lib/time";
 import {
   formatTaskList,
   formatTaskDetail,
@@ -15,12 +16,27 @@ import {
 } from "./lib/format";
 import { findRoot, setWorkingDir } from "./lib/root";
 import { parseId } from "./types";
-import type { Status } from "./types";
+import type { Status, TaskWithMeta } from "./types";
 import { BASH_COMPLETION, ZSH_COMPLETION, FISH_COMPLETION } from "./lib/completions";
 
 const VALID_STATUSES: Status[] = ["open", "active", "done"];
 const PROJECT_PATTERN = /^[a-z][a-z0-9]*$/;
 
+const COMMON_OPTIONS = {
+  project: { type: "string", short: "P" },
+  priority: { type: "string", short: "p" },
+  labels: { type: "string", short: "l" },
+} as const;
+
+const TASK_MUTATION_OPTIONS = {
+  ...COMMON_OPTIONS,
+  description: { type: "string", short: "d" },
+  assignees: { type: "string", short: "A" },
+  parent: { type: "string" },
+  estimate: { type: "string" },
+  due: { type: "string" },
+} as const;
+
 function validateProject(name: string): void {
   if (!PROJECT_PATTERN.test(name)) {
     throw new Error(
@@ -39,74 +55,16 @@ function parseStatus(input: string | undefined): Status | undefined {
 
 function parseLimit(input: string | undefined): number | undefined {
   if (!input) return undefined;
-  const n = parseInt(input, 10);
-  if (isNaN(n) || n < 1) {
+  if (!/^\d+$/.test(input)) {
     throw new Error(`Invalid limit: ${input}. Must be a positive number.`);
   }
-  return n;
-}
-
-function parseEstimate(input: string | undefined): number | undefined {
-  if (!input) return undefined;
-  const n = parseInt(input, 10);
-  if (isNaN(n) || n < 0) {
-    throw new Error(`Invalid estimate: ${input}. Must be a non-negative number.`);
+  const n = Number(input);
+  if (n < 1) {
+    throw new Error(`Invalid limit: ${input}. Must be a positive number.`);
   }
   return n;
 }
 
-function formatLocalDate(date: Date): string {
-  const year = date.getFullYear();
-  const month = String(date.getMonth() + 1).padStart(2, "0");
-  const day = String(date.getDate()).padStart(2, "0");
-  return `${year}-${month}-${day}`;
-}
-
-function parseDueDate(input: string | undefined): string | undefined {
-  if (!input) return undefined;
-  if (input === "-") return undefined; // clear
-
-  // Handle relative dates like +7d
-  if (input.startsWith("+")) {
-    const match = input.match(/^\+(\d+)([dwmh])$/);
-    if (match && match[1] && match[2]) {
-      const num = match[1];
-      const unit = match[2];
-      const n = parseInt(num, 10);
-      const now = new Date();
-      switch (unit) {
-        case "h":
-          now.setHours(now.getHours() + n);
-          break;
-        case "d":
-          now.setDate(now.getDate() + n);
-          break;
-        case "w":
-          now.setDate(now.getDate() + n * 7);
-          break;
-        case "m":
-          now.setMonth(now.getMonth() + n);
-          break;
-      }
-      return formatLocalDate(now);
-    }
-    throw new Error(`Invalid relative date: ${input}. Use format like +7d, +2w, +1m`);
-  }
-
-  // Validate YYYY-MM-DD format - return as-is to avoid timezone issues
-  const dateMatch = input.match(/^(\d{4})-(\d{2})-(\d{2})$/);
-  if (dateMatch) {
-    const [, , month, day] = dateMatch;
-    const m = parseInt(month!, 10);
-    const d = parseInt(day!, 10);
-    // Basic validation: month 1-12, day 1-31
-    if (m >= 1 && m <= 12 && d >= 1 && d <= 31) {
-      return input; // Return as-is, already in correct format
-    }
-  }
-  throw new Error(`Invalid date: ${input}. Use YYYY-MM-DD or +Nd format.`);
-}
-
 function parseLabels(input: string | undefined): string[] | undefined {
   if (!input) return undefined;
   return input
@@ -146,9 +104,6 @@ function resolveId(input: string | undefined, context: string): string {
   const resolved = storage.resolveId(input);
   if (resolved) return resolved;
 
-  // Check if it's a valid full ID format
-  if (parseId(input)) return input;
-
   // Check for ambiguous matches
   const matches = storage.findMatchingIds(input);
   if (matches.length > 1) {
@@ -157,9 +112,26 @@ function resolveId(input: string | undefined, context: string): string {
     );
   }
 
+  // If it's a valid full ID format but doesn't exist, we still return it
+  // and let getTask handle the "not found" error consistently.
+  if (parseId(input)) return input;
+
   throw new Error(`Task not found: ${input}`);
 }
 
+/**
+ * Resolves an ID and fetches the task.
+ * Handles "Task not found" and cleanup output automatically.
+ */
+function resolveTask(input: string | undefined, context: string): TaskWithMeta {
+  const id = resolveId(input, context);
+  const result = storage.getTask(id);
+  if (!result) error(`Task not found: ${id}`);
+
+  outputCleanup(id, result.cleanup);
+  return result.task;
+}
+
 const rawArgs = process.argv.slice(2);
 
 function isFlag(arg: string): boolean {
@@ -233,7 +205,7 @@ COMMANDS:
   init         Initialize .tasks/ directory
   add          Create task
   ls, list     List tasks
-  ready        List ready tasks (open + unblocked)
+  ready        List ready tasks (active/open + unblocked)
   show         Show task details
   start        Start working (open -> active)
   done         Complete task
@@ -314,12 +286,12 @@ EXAMPLES:
 
 Run 'tk ls --help' for options.
 `,
-    ready: `tk ready - List ready tasks (open + unblocked)
+    ready: `tk ready - List ready tasks (active/open + unblocked)
 
 USAGE:
   tk ready
 
-Shows open tasks that are not blocked by any incomplete task.
+Shows active or open tasks that are not blocked by any incomplete task.
 `,
     show: `tk show - Show task details
 
@@ -538,16 +510,7 @@ function main() {
     case "add": {
       const { values, positionals } = parseArgs({
         args,
-        options: {
-          description: { type: "string", short: "d" },
-          priority: { type: "string", short: "p" },
-          project: { type: "string", short: "P" },
-          labels: { type: "string", short: "l" },
-          assignees: { type: "string", short: "A" },
-          parent: { type: "string" },
-          estimate: { type: "string" },
-          due: { type: "string" },
-        },
+        options: TASK_MUTATION_OPTIONS,
         allowPositionals: true,
       });
       const title = positionals[0]?.trim();
@@ -588,10 +551,9 @@ function main() {
       const { values } = parseArgs({
         args,
         options: {
+          ...COMMON_OPTIONS,
+          label: COMMON_OPTIONS.labels, // alias for consistency
           status: { type: "string", short: "s" },
-          priority: { type: "string", short: "p" },
-          project: { type: "string", short: "P" },
-          label: { type: "string", short: "l" },
           assignee: { type: "string" },
           parent: { type: "string" },
           roots: { type: "boolean" },
@@ -617,7 +579,7 @@ function main() {
         status,
         priority,
         project: values.project,
-        label: values.label,
+        label: values.label ?? values.labels,
         assignee: values.assignee,
         parent: parentFilter,
         roots: values.roots,
@@ -635,44 +597,32 @@ function main() {
     }
 
     case "show": {
-      const id = resolveId(args[0], "show");
-      const result = storage.getTaskWithMeta(id);
-      if (!result) error(`Task not found: ${id}`);
-      outputCleanup(id, result.cleanup);
-      output(result.task, formatTaskDetail(result.task, result.task.logs));
+      const task = resolveTask(args[0], "show");
+      output(task, formatTaskDetail(task, task.logs));
       break;
     }
 
     case "start": {
-      const id = resolveId(args[0], "start");
-      const result = storage.getTask(id);
-      if (!result) error(`Task not found: ${id}`);
-      outputCleanup(id, result.cleanup);
-      if (result.task.status === "active")
-        error(`Task already active. Use 'tk done ${id}' to complete it.`);
-      if (result.task.status === "done") error(`Task already done. Use 'tk reopen ${id}' first.`);
-      const updated = storage.updateTaskStatus(id, "active");
-      output(updated, green(`Started: ${id}`));
+      const task = resolveTask(args[0], "start");
+      if (task.status === "active")
+        error(`Task already active. Use 'tk done ${task.id}' to complete it.`);
+      if (task.status === "done") error(`Task already done. Use 'tk reopen ${task.id}' first.`);
+      const updated = storage.updateTaskStatus(task.id, "active");
+      output(updated, green(`Started: ${task.id}`));
       break;
     }
 
     case "done": {
-      const id = resolveId(args[0], "done");
-      const result = storage.getTask(id);
-      if (!result) error(`Task not found: ${id}`);
-      outputCleanup(id, result.cleanup);
-      const updated = storage.updateTaskStatus(id, "done");
-      output(updated, green(`Completed: ${id}`));
+      const task = resolveTask(args[0], "done");
+      const updated = storage.updateTaskStatus(task.id, "done");
+      output(updated, green(`Completed: ${task.id}`));
       break;
     }
 
     case "reopen": {
-      const id = resolveId(args[0], "reopen");
-      const result = storage.getTask(id);
-      if (!result) error(`Task not found: ${id}`);
-      outputCleanup(id, result.cleanup);
-      const updated = storage.updateTaskStatus(id, "open");
-      output(updated, green(`Reopened: ${id}`));
+      const task = resolveTask(args[0], "reopen");
+      const updated = storage.updateTaskStatus(task.id, "open");
+      output(updated, green(`Reopened: ${task.id}`));
       break;
     }
 
@@ -680,21 +630,12 @@ function main() {
       const { values, positionals } = parseArgs({
         args,
         options: {
+          ...TASK_MUTATION_OPTIONS,
           title: { type: "string", short: "t" },
-          description: { type: "string", short: "d" },
-          priority: { type: "string", short: "p" },
-          labels: { type: "string", short: "l" },
-          assignees: { type: "string", short: "A" },
-          parent: { type: "string" },
-          estimate: { type: "string" },
-          due: { type: "string" },
         },
         allowPositionals: true,
       });
-      const id = resolveId(positionals[0], "edit");
-      const result = storage.getTask(id);
-      if (!result) error(`Task not found: ${id}`);
-      outputCleanup(id, result.cleanup);
+      const task = resolveTask(positionals[0], "edit");
 
       // Handle label modifications (+tag, -tag)
       let labels: string[] | undefined;
@@ -702,13 +643,11 @@ function main() {
         if (values.labels.startsWith("+")) {
           // Add label (avoid duplicates)
           const newLabel = values.labels.slice(1);
-          labels = result.task.labels.includes(newLabel)
-            ? result.task.labels
-            : [...result.task.labels, newLabel];
+          labels = task.labels.includes(newLabel) ? task.labels : [...task.labels, newLabel];
         } else if (values.labels.startsWith("-")) {
           // Remove label
           const removeLabel = values.labels.slice(1);
-          labels = result.task.labels.filter((l) => l !== removeLabel);
+          labels = task.labels.filter((l: string) => l !== removeLabel);
         } else {
           // Replace labels
           labels = parseLabels(values.labels);
@@ -723,11 +662,11 @@ function main() {
         const resolved = storage.resolveId(values.parent);
         if (!resolved) error(`Parent task not found: ${values.parent}`);
         resolvedParent = resolved;
-        const parentResult = storage.validateParent(resolvedParent, id);
+        const parentResult = storage.validateParent(resolvedParent, task.id);
         if (!parentResult.ok) error(parentResult.error!);
       }
 
-      const updated = storage.updateTask(id, {
+      const updated = storage.updateTask(task.id, {
         title: values.title?.trim() || undefined,
         description: values.description,
         priority: values.priority ? parsePriority(values.priority) : undefined,
@@ -737,12 +676,12 @@ function main() {
         estimate: values.estimate === "-" ? null : (parseEstimate(values.estimate) ?? undefined),
         due_date: values.due === "-" ? null : (parseDueDate(values.due) ?? undefined),
       });
-      output(updated, green(`Updated: ${id}`));
+      output(updated, green(`Updated: ${task.id}`));
       break;
     }
 
     case "log": {
-      const id = resolveId(args[0], "log");
+      const task = resolveTask(args[0], "log");
       const message = args[1]?.trim();
       if (!message) error('Message required: tk log <id> "<message>"');
       if (args.length > 2) {
@@ -751,11 +690,8 @@ function main() {
             `  Got ${args.length - 1} arguments instead of 1`,
         );
       }
-      const result = storage.getTask(id);
-      if (!result) error(`Task not found: ${id}`);
-      outputCleanup(id, result.cleanup);
-      const entry = storage.addLogEntry(id, message);
-      output(entry, green(`Logged: ${id}`));
+      const entry = storage.addLogEntry(task.id, message);
+      output(entry, green(`Logged: ${task.id}`));
       break;
     }
 
@@ -809,11 +745,10 @@ function main() {
       // Get days from CLI or config
       let days: number | false;
       if (values["older-than"] !== undefined) {
-        const n = parseInt(values["older-than"], 10);
-        if (isNaN(n) || n < 0) {
+        if (!/^\d+$/.test(values["older-than"])) {
           error(`Invalid --older-than: ${values["older-than"]}. Use a number of days.`);
         }
-        days = n;
+        days = Number(values["older-than"]);
       } else {
         days = config.clean_after;
         // Validate config value at runtime