@task-mcp/cli 1.0.15 → 1.0.16

package/src/__tests__/list.test.ts

@@ -0,0 +1,352 @@
+import { describe, expect, test, mock, beforeEach, afterEach, spyOn } from "bun:test";
+import type { Task, Project } 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,
+  };
+}
+
+// Helper to create test projects
+function createProject(overrides: Partial<Project> = {}): Project {
+  return {
+    id: `proj_${Math.random().toString(36).slice(2, 10)}`,
+    name: "Test Project",
+    status: "active",
+    createdAt: new Date().toISOString(),
+    updatedAt: new Date().toISOString(),
+    ...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("listProjectsCmd is exported", async () => {
+    const { listProjectsCmd } = await import("../commands/list.js");
+    expect(typeof listProjectsCmd).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 = {
+      projectId: "proj_123",
+      status: "pending",
+      priority: "high",
+      all: true,
+    };
+
+    // Type check passes if this compiles
+    expect(options.projectId).toBeDefined();
+    expect(options.status).toBeDefined();
+    expect(options.priority).toBeDefined();
+    expect(options.all).toBeDefined();
+  });
+
+  test("listProjectsCmd accepts options object", async () => {
+    const { listProjectsCmd } = await import("../commands/list.js");
+
+    const options = {
+      all: true,
+    };
+
+    expect(options.all).toBeDefined();
+  });
+});

package/src/commands/dashboard.ts

@@ -16,6 +16,7 @@ import {
   listTasks,
   listAllTasks,
   listInboxItems,
+  getActiveTag,
   type Task,
   type Project,
 } from "../storage.js";
@@ -25,8 +26,9 @@ import {
 // =============================================================================
 
 export async function dashboard(projectId?: string): Promise<void> {
-  // Get projects and tasks
+  // Get projects, tasks, and active tag
   const projects = await listProjects();
+  const activeTag = await getActiveTag();
 
   if (projects.length === 0) {
     console.log(c.yellow("No projects found. Create a project first using the MCP server."));
@@ -55,10 +57,13 @@ export async function dashboard(projectId?: string): Promise<void> {
   // Get inbox items
   const inboxItems = await listInboxItems("pending");
 
-  // Create task lookup for projects table
+  // Create task lookup for projects table (batch query to avoid N+1)
+  const allTasksForLookup = await listAllTasks();
   const tasksByProject = new Map<string, Task[]>();
-  for (const p of projects) {
-    tasksByProject.set(p.id, await listTasks(p.id));
+  for (const task of allTasksForLookup) {
+    const projectTasks = tasksByProject.get(task.projectId) ?? [];
+    projectTasks.push(task);
+    tasksByProject.set(task.projectId, projectTasks);
   }
   const getProjectTasks = (pid: string) => tasksByProject.get(pid) ?? [];
 
@@ -69,7 +74,7 @@ export async function dashboard(projectId?: string): Promise<void> {
     output = renderProjectDashboard(
       project as SharedProject,
       tasks as SharedTask[],
-      { version: VERSION }
+      { version: VERSION, activeTag }
     );
   } else {
     output = renderGlobalDashboard(
@@ -77,7 +82,7 @@ export async function dashboard(projectId?: string): Promise<void> {
       tasks as SharedTask[],
       inboxItems,
       (pid) => (getProjectTasks(pid) as SharedTask[]),
-      { version: VERSION }
+      { version: VERSION, activeTag }
     );
   }
 

package/src/commands/inbox.ts

@@ -3,9 +3,15 @@
  * Quick capture and management of ideas
  */
 
-import { c } from "../ansi.js";
+import { c, formatStatus, formatPriority } from "../ansi.js";
 import { InboxStore, TaskStore, ProjectStore } from "@task-mcp/mcp-server/storage";
 import { parseInboxInput } from "@task-mcp/shared";
+import {
+  LIST_SEPARATOR_WIDTH,
+  MENU_SEPARATOR_WIDTH,
+  INBOX_PROMOTE_TITLE_MAX_LENGTH,
+  INBOX_DISCARD_PREVIEW_LENGTH,
+} from "../constants.js";
 
 const inboxStore = new InboxStore();
 const taskStore = new TaskStore();
@@ -246,22 +252,3 @@ export async function inboxCountCmd(): Promise<void> {
   console.log();
 }
 
-// Helper functions
-function formatStatus(status: string): string {
-  switch (status) {
-    case "pending": return c.yellow("pending");
-    case "promoted": return c.green("promoted");
-    case "discarded": return c.dim("discarded");
-    default: return status;
-  }
-}
-
-function formatPriority(priority: string): string {
-  switch (priority) {
-    case "critical": return c.red("critical");
-    case "high": return c.yellow("high");
-    case "medium": return c.blue("medium");
-    case "low": return c.dim("low");
-    default: return priority;
-  }
-}

package/src/commands/list.ts

@@ -2,7 +2,7 @@
  * List commands - list tasks and projects
  */
 
-import { c, table, icons, type TableColumn } from "../ansi.js";
+import { c, table, formatStatus, formatPriority, type TableColumn } from "../ansi.js";
 import {
   listProjects,
   listTasks,
@@ -10,21 +10,14 @@ import {
   type Task,
   type Project,
 } from "../storage.js";
-
-function formatStatus(status: Task["status"]): string {
-  const icon = icons[status] ?? icons.pending;
-  return `${icon} ${status}`;
-}
-
-function formatPriority(priority: Task["priority"]): string {
-  const colors: Record<string, (s: string) => string> = {
-    critical: c.red,
-    high: c.yellow,
-    medium: c.blue,
-    low: c.gray,
-  };
-  return (colors[priority] ?? c.gray)(priority);
-}
+import {
+  COLUMN_WIDTH_ID,
+  COLUMN_WIDTH_TITLE,
+  COLUMN_WIDTH_PROJECT_NAME,
+  COLUMN_WIDTH_STATUS,
+  COLUMN_WIDTH_PRIORITY,
+  COLUMN_WIDTH_DATE,
+} from "../constants.js";
 
 function formatProjectStatus(status: Project["status"]): string {
   const statusMap: Record<string, string> = {
@@ -78,11 +71,11 @@ export async function listTasksCmd(options: {
   console.log(c.bold(`\nTasks (${tasks.length})\n`));
 
   const columns: TableColumn[] = [
-    { header: "ID", key: "id", width: 6, format: (v) => c.cyan(String(v).slice(0, 4)) },
-    { header: "Title", key: "title", width: 45 },
-    { header: "Status", key: "status", width: 14, format: (v) => formatStatus(v as Task["status"]) },
-    { header: "Priority", key: "priority", width: 10, format: (v) => formatPriority(v as Task["priority"]) },
-    { header: "Due", key: "dueDate", width: 12, format: (v) => formatDate(v as string) },
+    { header: "ID", key: "id", width: COLUMN_WIDTH_ID, format: (v) => c.cyan(String(v).slice(0, 4)) },
+    { header: "Title", key: "title", width: COLUMN_WIDTH_TITLE },
+    { header: "Status", key: "status", width: COLUMN_WIDTH_STATUS, format: (v) => formatStatus(v as Task["status"]) },
+    { header: "Priority", key: "priority", width: COLUMN_WIDTH_PRIORITY, format: (v) => formatPriority(v as Task["priority"]) },
+    { header: "Due", key: "dueDate", width: COLUMN_WIDTH_DATE, format: (v) => formatDate(v as string) },
   ];
 
   console.log(table(tasks as unknown as Record<string, unknown>[], columns));
@@ -116,11 +109,11 @@ export async function listProjectsCmd(options: {
   );
 
   const columns: TableColumn[] = [
-    { header: "ID", key: "id", width: 6, format: (v) => c.cyan(String(v).slice(0, 4)) },
-    { header: "Name", key: "name", width: 30 },
-    { header: "Status", key: "status", width: 14, format: (v) => formatProjectStatus(v as Project["status"]) },
-    { header: "Tasks", key: "progress", width: 10 },
-    { header: "Updated", key: "updatedAt", width: 12, format: (v) => formatDate(v as string) },
+    { header: "ID", key: "id", width: COLUMN_WIDTH_ID, format: (v) => c.cyan(String(v).slice(0, 4)) },
+    { header: "Name", key: "name", width: COLUMN_WIDTH_PROJECT_NAME },
+    { header: "Status", key: "status", width: COLUMN_WIDTH_STATUS, format: (v) => formatProjectStatus(v as Project["status"]) },
+    { header: "Tasks", key: "progress", width: COLUMN_WIDTH_PRIORITY },
+    { header: "Updated", key: "updatedAt", width: COLUMN_WIDTH_DATE, format: (v) => formatDate(v as string) },
   ];
 
   console.log(table(projectsWithStats, columns));

package/src/constants.ts

@@ -0,0 +1,56 @@
+/**
+ * CLI Constants
+ * Centralized magic numbers for column widths, limits, and UI settings
+ */
+
+// =============================================================================
+// UI Layout
+// =============================================================================
+
+/** Width for horizontal separators in menus */
+export const MENU_SEPARATOR_WIDTH = 40;
+
+/** Width for horizontal separators in lists */
+export const LIST_SEPARATOR_WIDTH = 50;
+
+// =============================================================================
+// Timing
+// =============================================================================
+
+/** Delay in ms after showing error message */
+export const ERROR_MESSAGE_DELAY_MS = 1000;
+
+/** Delay in ms for welcome screen display */
+export const WELCOME_SCREEN_DELAY_MS = 1000;
+
+// =============================================================================
+// Table Column Widths
+// =============================================================================
+
+/** ID column width (shows truncated ID) */
+export const COLUMN_WIDTH_ID = 6;
+
+/** Task title column width */
+export const COLUMN_WIDTH_TITLE = 45;
+
+/** Project name column width */
+export const COLUMN_WIDTH_PROJECT_NAME = 30;
+
+/** Status column width */
+export const COLUMN_WIDTH_STATUS = 14;
+
+/** Priority column width */
+export const COLUMN_WIDTH_PRIORITY = 10;
+
+/** Date column width */
+export const COLUMN_WIDTH_DATE = 12;
+
+// =============================================================================
+// Text Limits
+// =============================================================================
+
+/** Maximum length for task title when promoting from inbox */
+export const INBOX_PROMOTE_TITLE_MAX_LENGTH = 100;
+
+/** Maximum length for content preview when discarding inbox item */
+export const INBOX_DISCARD_PREVIEW_LENGTH = 50;