@task-mcp/cli 1.0.21 → 1.0.23

package/src/__tests__/list.test.ts

@@ -1,347 +0,0 @@
-import { describe, expect, test, mock, beforeEach, afterEach, spyOn } from "bun:test";
-import type { Task, WorkspaceInfo } 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",
-    workspace: "test-workspace",
-    createdAt: new Date().toISOString(),
-    updatedAt: new Date().toISOString(),
-    ...overrides,
-  };
-}
-
-// Helper to create test workspaces
-function createWorkspace(overrides: Partial<WorkspaceInfo> = {}): WorkspaceInfo {
-  return {
-    name: "Test Workspace",
-    taskCount: 0,
-    completedCount: 0,
-    ...overrides,
-  };
-}
-
-describe("list commands - unit tests", () => {
-  describe("task filtering logic", () => {
-    test("filters tasks by single status", () => {
-      const tasks = [
-        createTask({ id: "task_1", status: "pending" }),
-        createTask({ id: "task_2", status: "completed" }),
-        createTask({ id: "task_3", status: "in_progress" }),
-      ];
-
-      const status = "pending";
-      const statuses = status.split(",");
-      const filtered = tasks.filter((t) => statuses.includes(t.status));
-
-      expect(filtered.length).toBe(1);
-      expect(filtered[0]?.id).toBe("task_1");
-    });
-
-    test("filters tasks by multiple statuses", () => {
-      const tasks = [
-        createTask({ id: "task_1", status: "pending" }),
-        createTask({ id: "task_2", status: "completed" }),
-        createTask({ id: "task_3", status: "in_progress" }),
-        createTask({ id: "task_4", status: "blocked" }),
-      ];
-
-      const status = "pending,in_progress";
-      const statuses = status.split(",");
-      const filtered = tasks.filter((t) => statuses.includes(t.status));
-
-      expect(filtered.length).toBe(2);
-      expect(filtered.map((t) => t.id).sort()).toEqual(["task_1", "task_3"]);
-    });
-
-    test("filters tasks by priority", () => {
-      const tasks = [
-        createTask({ id: "task_1", priority: "high" }),
-        createTask({ id: "task_2", priority: "low" }),
-        createTask({ id: "task_3", priority: "high" }),
-        createTask({ id: "task_4", priority: "medium" }),
-      ];
-
-      const priority = "high";
-      const priorities = priority.split(",");
-      const filtered = tasks.filter((t) => priorities.includes(t.priority));
-
-      expect(filtered.length).toBe(2);
-      expect(filtered.map((t) => t.id).sort()).toEqual(["task_1", "task_3"]);
-    });
-
-    test("filters by multiple priorities", () => {
-      const tasks = [
-        createTask({ id: "task_1", priority: "high" }),
-        createTask({ id: "task_2", priority: "low" }),
-        createTask({ id: "task_3", priority: "critical" }),
-        createTask({ id: "task_4", priority: "medium" }),
-      ];
-
-      const priority = "high,critical";
-      const priorities = priority.split(",");
-      const filtered = tasks.filter((t) => priorities.includes(t.priority));
-
-      expect(filtered.length).toBe(2);
-      expect(filtered.map((t) => t.id).sort()).toEqual(["task_1", "task_3"]);
-    });
-
-    test("default filter hides completed and cancelled tasks", () => {
-      const tasks = [
-        createTask({ id: "task_1", status: "pending" }),
-        createTask({ id: "task_2", status: "completed" }),
-        createTask({ id: "task_3", status: "cancelled" }),
-        createTask({ id: "task_4", status: "in_progress" }),
-      ];
-
-      // Default behavior: hide completed/cancelled
-      const filtered = tasks.filter(
-        (t) => t.status !== "completed" && t.status !== "cancelled"
-      );
-
-      expect(filtered.length).toBe(2);
-      expect(filtered.map((t) => t.id).sort()).toEqual(["task_1", "task_4"]);
-    });
-
-    test("all flag includes completed and cancelled tasks", () => {
-      const tasks = [
-        createTask({ id: "task_1", status: "pending" }),
-        createTask({ id: "task_2", status: "completed" }),
-        createTask({ id: "task_3", status: "cancelled" }),
-      ];
-
-      const all = true;
-      // With --all, no filtering
-      const filtered = all ? tasks : tasks.filter(
-        (t) => t.status !== "completed" && t.status !== "cancelled"
-      );
-
-      expect(filtered.length).toBe(3);
-    });
-
-    test("combined status and priority filtering", () => {
-      const tasks = [
-        createTask({ id: "task_1", status: "pending", priority: "high" }),
-        createTask({ id: "task_2", status: "pending", priority: "low" }),
-        createTask({ id: "task_3", status: "completed", priority: "high" }),
-        createTask({ id: "task_4", status: "in_progress", priority: "high" }),
-      ];
-
-      const status = "pending,in_progress";
-      const priority = "high";
-      const statuses = status.split(",");
-      const priorities = priority.split(",");
-
-      let filtered = tasks.filter((t) => statuses.includes(t.status));
-      filtered = filtered.filter((t) => priorities.includes(t.priority));
-
-      expect(filtered.length).toBe(2);
-      expect(filtered.map((t) => t.id).sort()).toEqual(["task_1", "task_4"]);
-    });
-  });
-
-  describe("project progress calculation", () => {
-    test("calculates progress for empty project", () => {
-      const tasks: Task[] = [];
-      const completed = tasks.filter((t) => t.status === "completed").length;
-      const total = tasks.filter((t) => t.status !== "cancelled").length;
-      const progress = total > 0 ? `${completed}/${total}` : "0/0";
-
-      expect(progress).toBe("0/0");
-    });
-
-    test("calculates progress excluding cancelled tasks", () => {
-      const tasks = [
-        createTask({ status: "completed" }),
-        createTask({ status: "completed" }),
-        createTask({ status: "pending" }),
-        createTask({ status: "cancelled" }),
-        createTask({ status: "cancelled" }),
-      ];
-
-      const completed = tasks.filter((t) => t.status === "completed").length;
-      const total = tasks.filter((t) => t.status !== "cancelled").length;
-      const progress = `${completed}/${total}`;
-
-      expect(progress).toBe("2/3"); // 2 completed out of 3 non-cancelled
-    });
-
-    test("calculates 100% completion", () => {
-      const tasks = [
-        createTask({ status: "completed" }),
-        createTask({ status: "completed" }),
-        createTask({ status: "completed" }),
-      ];
-
-      const completed = tasks.filter((t) => t.status === "completed").length;
-      const total = tasks.filter((t) => t.status !== "cancelled").length;
-      const progress = `${completed}/${total}`;
-
-      expect(progress).toBe("3/3");
-    });
-
-    test("handles all cancelled tasks", () => {
-      const tasks = [
-        createTask({ status: "cancelled" }),
-        createTask({ status: "cancelled" }),
-      ];
-
-      const completed = tasks.filter((t) => t.status === "completed").length;
-      const total = tasks.filter((t) => t.status !== "cancelled").length;
-      const progress = total > 0 ? `${completed}/${total}` : "0/0";
-
-      expect(progress).toBe("0/0");
-    });
-  });
-
-  describe("formatProjectStatus", () => {
-    test("maps project statuses correctly", () => {
-      type ProjectStatus = "active" | "on_hold" | "completed" | "archived";
-
-      const formatProjectStatus = (status: ProjectStatus): string => {
-        const statusMap: Record<ProjectStatus, string> = {
-          active: "active",
-          on_hold: "on_hold",
-          completed: "completed",
-          archived: "archived",
-        };
-        return statusMap[status] ?? status;
-      };
-
-      expect(formatProjectStatus("active")).toBe("active");
-      expect(formatProjectStatus("on_hold")).toBe("on_hold");
-      expect(formatProjectStatus("completed")).toBe("completed");
-      expect(formatProjectStatus("archived")).toBe("archived");
-    });
-  });
-
-  describe("formatDate", () => {
-    test("formats valid date string", () => {
-      const formatDate = (dateStr?: string): string => {
-        if (!dateStr) return "-";
-        const date = new Date(dateStr);
-        return date.toLocaleDateString();
-      };
-
-      const result = formatDate("2024-12-25");
-      // Result depends on locale, but should be non-empty
-      expect(result).not.toBe("-");
-      expect(result.length).toBeGreaterThan(0);
-    });
-
-    test("returns dash for undefined date", () => {
-      const formatDate = (dateStr?: string): string => {
-        if (!dateStr) return "-";
-        const date = new Date(dateStr);
-        return date.toLocaleDateString();
-      };
-
-      expect(formatDate(undefined)).toBe("-");
-    });
-
-    test("returns dash for empty date string", () => {
-      const formatDate = (dateStr?: string): string => {
-        if (!dateStr) return "-";
-        const date = new Date(dateStr);
-        return date.toLocaleDateString();
-      };
-
-      expect(formatDate("")).toBe("-");
-    });
-  });
-
-  describe("table column definitions", () => {
-    test("task table has required columns", () => {
-      const columns = [
-        { header: "ID", key: "id", width: 6 },
-        { header: "Title", key: "title", width: 45 },
-        { header: "Status", key: "status", width: 14 },
-        { header: "Priority", key: "priority", width: 10 },
-        { header: "Due", key: "dueDate", width: 12 },
-      ];
-
-      expect(columns.find((c) => c.key === "id")).toBeDefined();
-      expect(columns.find((c) => c.key === "title")).toBeDefined();
-      expect(columns.find((c) => c.key === "status")).toBeDefined();
-      expect(columns.find((c) => c.key === "priority")).toBeDefined();
-      expect(columns.find((c) => c.key === "dueDate")).toBeDefined();
-    });
-
-    test("project table has required columns", () => {
-      const columns = [
-        { header: "ID", key: "id", width: 6 },
-        { header: "Name", key: "name", width: 30 },
-        { header: "Status", key: "status", width: 14 },
-        { header: "Tasks", key: "progress", width: 10 },
-        { header: "Updated", key: "updatedAt", width: 12 },
-      ];
-
-      expect(columns.find((c) => c.key === "id")).toBeDefined();
-      expect(columns.find((c) => c.key === "name")).toBeDefined();
-      expect(columns.find((c) => c.key === "status")).toBeDefined();
-      expect(columns.find((c) => c.key === "progress")).toBeDefined();
-      expect(columns.find((c) => c.key === "updatedAt")).toBeDefined();
-    });
-  });
-
-  describe("ID truncation", () => {
-    test("truncates task ID to 4 characters", () => {
-      const id = "task_abc12345";
-      const truncated = id.slice(0, 4);
-      expect(truncated).toBe("task");
-    });
-
-    test("truncates project ID to 4 characters", () => {
-      const id = "proj_xyz98765";
-      const truncated = id.slice(0, 4);
-      expect(truncated).toBe("proj");
-    });
-
-    test("handles short IDs", () => {
-      const id = "ab";
-      const truncated = id.slice(0, 4);
-      expect(truncated).toBe("ab");
-    });
-  });
-});
-
-describe("list commands - exports", () => {
-  test("listTasksCmd is exported", async () => {
-    const { listTasksCmd } = await import("../commands/list.js");
-    expect(typeof listTasksCmd).toBe("function");
-  });
-
-  test("listWorkspacesCmd is exported", async () => {
-    const { listWorkspacesCmd } = await import("../commands/list.js");
-    expect(typeof listWorkspacesCmd).toBe("function");
-  });
-
-  test("listTasksCmd accepts options object", async () => {
-    const { listTasksCmd } = await import("../commands/list.js");
-
-    // Verify the function signature accepts the expected options
-    const options = {
-      workspace: "test-workspace",
-      status: "pending",
-      priority: "high",
-      all: true,
-    };
-
-    // Type check passes if this compiles
-    expect(options.workspace).toBeDefined();
-    expect(options.status).toBeDefined();
-    expect(options.priority).toBeDefined();
-    expect(options.all).toBeDefined();
-  });
-
-  test("listWorkspacesCmd accepts no options", async () => {
-    const { listWorkspacesCmd } = await import("../commands/list.js");
-
-    // listWorkspacesCmd takes no options
-    expect(typeof listWorkspacesCmd).toBe("function");
-  });
-});

package/src/__tests__/storage.test.ts

@@ -1,271 +0,0 @@
-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",
-    workspace: "test-workspace",
-    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

@@ -1,50 +0,0 @@
-/**
- * Re-export terminal UI utilities from shared package
- * This file exists for backward compatibility
- */
-
-export {
-  // Colors and styles
-  color,
-  style,
-  styled,
-  c,
-  // Box drawing
-  BOX,
-  box,
-  drawBox,
-  hline,
-  // String utilities
-  stripAnsi,
-  displayWidth,
-  visibleLength,
-  pad,
-  padEnd,
-  padStart,
-  center,
-  truncateStr,
-  // Progress bar
-  progressBar,
-  type ProgressBarOptions,
-  // Layout
-  sideBySide,
-  sideBySideArrays,
-  type BoxOptions,
-  // Tables
-  table,
-  renderTable,
-  type TableColumn,
-  // Formatters
-  statusColors,
-  statusIcons,
-  icons,
-  formatStatus,
-  priorityColors,
-  formatPriority,
-  formatDependencies,
-  // Banner
-  banner,
-} from "@task-mcp/shared";
-
-// Alias for CLI compatibility
-export { truncateStr as truncate } from "@task-mcp/shared";