@task-mcp/cli 1.0.4 → 1.0.6

package/src/__tests__/storage.test.ts

@@ -0,0 +1,271 @@
+import { describe, expect, test } from "bun:test";
+import {
+  calculateStats,
+  calculateDependencyMetrics,
+  suggestNextTask,
+  type Task,
+} from "../storage.js";
+
+// Helper to create test tasks
+function createTask(overrides: Partial<Task> = {}): Task {
+  return {
+    id: `task_${Math.random().toString(36).slice(2, 10)}`,
+    title: "Test Task",
+    status: "pending",
+    priority: "medium",
+    projectId: "proj_test",
+    createdAt: new Date().toISOString(),
+    updatedAt: new Date().toISOString(),
+    ...overrides,
+  };
+}
+
+describe("storage", () => {
+  describe("calculateStats", () => {
+    test("calculates stats for empty task list", () => {
+      const stats = calculateStats([]);
+      expect(stats.total).toBe(0);
+      expect(stats.completed).toBe(0);
+      expect(stats.pending).toBe(0);
+      expect(stats.completionPercent).toBe(0);
+    });
+
+    test("counts tasks by status", () => {
+      const tasks = [
+        createTask({ status: "pending" }),
+        createTask({ status: "pending" }),
+        createTask({ status: "in_progress" }),
+        createTask({ status: "completed" }),
+        createTask({ status: "blocked" }),
+        createTask({ status: "cancelled" }),
+      ];
+
+      const stats = calculateStats(tasks);
+      expect(stats.total).toBe(6);
+      expect(stats.pending).toBe(2);
+      expect(stats.inProgress).toBe(1);
+      expect(stats.completed).toBe(1);
+      expect(stats.blocked).toBe(1);
+      expect(stats.cancelled).toBe(1);
+    });
+
+    test("counts tasks by priority", () => {
+      const tasks = [
+        createTask({ priority: "critical" }),
+        createTask({ priority: "high" }),
+        createTask({ priority: "high" }),
+        createTask({ priority: "medium" }),
+        createTask({ priority: "low" }),
+      ];
+
+      const stats = calculateStats(tasks);
+      expect(stats.byPriority.critical).toBe(1);
+      expect(stats.byPriority.high).toBe(2);
+      expect(stats.byPriority.medium).toBe(1);
+      expect(stats.byPriority.low).toBe(1);
+    });
+
+    test("calculates completion percent excluding cancelled", () => {
+      const tasks = [
+        createTask({ status: "completed" }),
+        createTask({ status: "completed" }),
+        createTask({ status: "pending" }),
+        createTask({ status: "pending" }),
+        createTask({ status: "cancelled" }), // Should be excluded from calculation
+      ];
+
+      const stats = calculateStats(tasks);
+      // 2 completed out of 4 non-cancelled = 50%
+      expect(stats.completionPercent).toBe(50);
+    });
+
+    test("handles all cancelled tasks", () => {
+      const tasks = [
+        createTask({ status: "cancelled" }),
+        createTask({ status: "cancelled" }),
+      ];
+
+      const stats = calculateStats(tasks);
+      expect(stats.completionPercent).toBe(0);
+    });
+  });
+
+  describe("calculateDependencyMetrics", () => {
+    test("calculates metrics for tasks without dependencies", () => {
+      const tasks = [
+        createTask({ status: "pending" }),
+        createTask({ status: "pending" }),
+        createTask({ status: "in_progress" }),
+      ];
+
+      const metrics = calculateDependencyMetrics(tasks);
+      expect(metrics.noDependencies).toBe(3);
+      expect(metrics.readyToWork).toBe(3);
+      expect(metrics.blockedByDependencies).toBe(0);
+      expect(metrics.avgDependencies).toBe(0);
+    });
+
+    test("identifies tasks blocked by dependencies", () => {
+      const task1 = createTask({ id: "task_1", status: "pending" });
+      const task2 = createTask({
+        id: "task_2",
+        status: "pending",
+        dependencies: [{ taskId: "task_1", type: "blocks" }],
+      });
+
+      const metrics = calculateDependencyMetrics([task1, task2]);
+      expect(metrics.noDependencies).toBe(1);
+      expect(metrics.readyToWork).toBe(1); // Only task1 is ready
+      expect(metrics.blockedByDependencies).toBe(1);
+    });
+
+    test("ready to work includes tasks with completed dependencies", () => {
+      const task1 = createTask({ id: "task_1", status: "completed" });
+      const task2 = createTask({
+        id: "task_2",
+        status: "pending",
+        dependencies: [{ taskId: "task_1", type: "blocks" }],
+      });
+
+      const metrics = calculateDependencyMetrics([task1, task2]);
+      expect(metrics.readyToWork).toBe(1); // task2 is ready because task1 is completed
+    });
+
+    test("finds most depended-on task", () => {
+      const task1 = createTask({ id: "task_1", title: "Base Task", status: "pending" });
+      const task2 = createTask({
+        id: "task_2",
+        status: "pending",
+        dependencies: [{ taskId: "task_1", type: "blocks" }],
+      });
+      const task3 = createTask({
+        id: "task_3",
+        status: "pending",
+        dependencies: [{ taskId: "task_1", type: "blocks" }],
+      });
+
+      const metrics = calculateDependencyMetrics([task1, task2, task3]);
+      expect(metrics.mostDependedOn).not.toBeNull();
+      expect(metrics.mostDependedOn?.id).toBe("task_1");
+      expect(metrics.mostDependedOn?.count).toBe(2);
+    });
+
+    test("calculates average dependencies", () => {
+      const task1 = createTask({ id: "task_1", status: "pending" });
+      const task2 = createTask({
+        id: "task_2",
+        status: "pending",
+        dependencies: [
+          { taskId: "task_1", type: "blocks" },
+          { taskId: "task_x", type: "blocks" },
+        ],
+      });
+
+      const metrics = calculateDependencyMetrics([task1, task2]);
+      expect(metrics.avgDependencies).toBe(1); // 2 deps / 2 tasks = 1
+    });
+
+    test("excludes completed and cancelled tasks from active count", () => {
+      const tasks = [
+        createTask({ status: "completed" }),
+        createTask({ status: "cancelled" }),
+        createTask({ status: "pending" }),
+      ];
+
+      const metrics = calculateDependencyMetrics(tasks);
+      expect(metrics.noDependencies).toBe(1); // Only the pending task
+      expect(metrics.readyToWork).toBe(1);
+    });
+  });
+
+  describe("suggestNextTask", () => {
+    test("returns null for empty task list", () => {
+      expect(suggestNextTask([])).toBeNull();
+    });
+
+    test("returns null when no actionable tasks", () => {
+      const tasks = [
+        createTask({ status: "completed" }),
+        createTask({ status: "cancelled" }),
+        createTask({ status: "blocked" }),
+      ];
+      expect(suggestNextTask(tasks)).toBeNull();
+    });
+
+    test("suggests task with highest priority", () => {
+      const lowTask = createTask({ id: "low", priority: "low", status: "pending" });
+      const highTask = createTask({ id: "high", priority: "high", status: "pending" });
+      const mediumTask = createTask({ id: "medium", priority: "medium", status: "pending" });
+
+      const suggestion = suggestNextTask([lowTask, highTask, mediumTask]);
+      expect(suggestion?.id).toBe("high");
+    });
+
+    test("critical priority comes first", () => {
+      const tasks = [
+        createTask({ id: "high", priority: "high", status: "pending" }),
+        createTask({ id: "critical", priority: "critical", status: "pending" }),
+      ];
+
+      const suggestion = suggestNextTask(tasks);
+      expect(suggestion?.id).toBe("critical");
+    });
+
+    test("suggests in_progress tasks", () => {
+      const tasks = [
+        createTask({ id: "pending", priority: "high", status: "pending" }),
+        createTask({ id: "in_progress", priority: "medium", status: "in_progress" }),
+      ];
+
+      // Both should be considered, high priority wins
+      const suggestion = suggestNextTask(tasks);
+      expect(suggestion?.id).toBe("pending");
+    });
+
+    test("excludes tasks with uncompleted dependencies", () => {
+      const task1 = createTask({ id: "task_1", priority: "low", status: "pending" });
+      const task2 = createTask({
+        id: "task_2",
+        priority: "critical",
+        status: "pending",
+        dependencies: [{ taskId: "task_1", type: "blocks" }],
+      });
+
+      const suggestion = suggestNextTask([task1, task2]);
+      // task2 has higher priority but is blocked, so task1 should be suggested
+      expect(suggestion?.id).toBe("task_1");
+    });
+
+    test("includes tasks when dependencies are completed", () => {
+      const task1 = createTask({ id: "task_1", priority: "low", status: "completed" });
+      const task2 = createTask({
+        id: "task_2",
+        priority: "critical",
+        status: "pending",
+        dependencies: [{ taskId: "task_1", type: "blocks" }],
+      });
+
+      const suggestion = suggestNextTask([task1, task2]);
+      // task1 is completed, so task2 is now actionable
+      expect(suggestion?.id).toBe("task_2");
+    });
+
+    test("same priority uses creation date (older first)", () => {
+      const older = createTask({
+        id: "older",
+        priority: "high",
+        status: "pending",
+        createdAt: "2024-01-01T00:00:00Z",
+      });
+      const newer = createTask({
+        id: "newer",
+        priority: "high",
+        status: "pending",
+        createdAt: "2024-12-01T00:00:00Z",
+      });
+
+      const suggestion = suggestNextTask([newer, older]);
+      expect(suggestion?.id).toBe("older");
+    });
+  });
+});

package/src/ansi.ts

@@ -120,7 +120,7 @@ export const BOX = {
 /**
  * Create a horizontal line
  */
-export function hline(width: number, char = BOX.horizontal): string {
+export function hline(width: number, char: string = BOX.horizontal): string {
   return char.repeat(width);
 }
 
@@ -407,16 +407,3 @@ export function banner(text: string): string {
   return lines.map(l => c.cyan(l)).join("\n");
 }
 
-/**
- * Clear screen
- */
-export function clearScreen(): void {
-  process.stdout.write("\x1b[2J\x1b[H");
-}
-
-/**
- * Move cursor
- */
-export function moveCursor(row: number, col: number): void {
-  process.stdout.write(`\x1b[${row};${col}H`);
-}