@task-mcp/cli 1.0.15 → 1.0.16

package/README.md

@@ -65,8 +65,6 @@ Interactive mode provides a menu-driven interface:
 - **d** - Dashboard view
 - **p** - Projects management
 - **t** - Tasks with filters
-- **a** - Analysis tools
-- **q** - Quick actions
 - **x** - Exit
 
 ### Task List

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@task-mcp/cli",
-  "version": "1.0.15",
+  "version": "1.0.16",
   "description": "Zero-dependency CLI for task-mcp with Bun native visualization",
   "type": "module",
   "bin": {

package/src/__tests__/dashboard.test.ts

@@ -0,0 +1,228 @@
+import { describe, expect, test } from "bun:test";
+import type { Task, Project, InboxItem } 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,
+  };
+}
+
+// Helper to create inbox items
+function createInboxItem(overrides: Partial<InboxItem> = {}): InboxItem {
+  return {
+    id: `inbox_${Math.random().toString(36).slice(2, 10)}`,
+    content: "Test inbox item",
+    status: "pending",
+    capturedAt: new Date().toISOString(),
+    source: "cli",
+    ...overrides,
+  };
+}
+
+describe("dashboard command - unit tests", () => {
+  describe("project lookup logic", () => {
+    test("finds project by exact ID", () => {
+      const projects = [
+        createProject({ id: "proj_abc123", name: "Project A" }),
+        createProject({ id: "proj_xyz789", name: "Project B" }),
+      ];
+
+      const projectId = "proj_abc123";
+      const project = projects.find((p) => p.id === projectId || p.id.startsWith(projectId));
+
+      expect(project).toBeDefined();
+      expect(project?.name).toBe("Project A");
+    });
+
+    test("finds project by partial ID prefix", () => {
+      const projects = [
+        createProject({ id: "proj_abc123456789", name: "Project A" }),
+        createProject({ id: "proj_xyz789012345", name: "Project B" }),
+      ];
+
+      const projectId = "proj_abc";
+      const project = projects.find((p) => p.id === projectId || p.id.startsWith(projectId));
+
+      expect(project).toBeDefined();
+      expect(project?.name).toBe("Project A");
+    });
+
+    test("returns undefined for non-matching ID", () => {
+      const projects = [
+        createProject({ id: "proj_abc123", name: "Project A" }),
+        createProject({ id: "proj_xyz789", name: "Project B" }),
+      ];
+
+      const projectId = "proj_nonexistent";
+      const project = projects.find((p) => p.id === projectId || p.id.startsWith(projectId));
+
+      expect(project).toBeUndefined();
+    });
+
+    test("returns first match when multiple projects share prefix", () => {
+      const projects = [
+        createProject({ id: "proj_abc111", name: "Project First" }),
+        createProject({ id: "proj_abc222", name: "Project Second" }),
+      ];
+
+      const projectId = "proj_abc";
+      const project = projects.find((p) => p.id === projectId || p.id.startsWith(projectId));
+
+      expect(project).toBeDefined();
+      expect(project?.name).toBe("Project First");
+    });
+  });
+
+  describe("dashboard mode selection", () => {
+    test("single project mode when only one project exists", () => {
+      const projects = [createProject({ id: "proj_only", name: "Only Project" })];
+
+      const hasSingleProject = projects.length === 1;
+      const shouldShowGlobal = projects.length > 1;
+
+      expect(hasSingleProject).toBe(true);
+      expect(shouldShowGlobal).toBe(false);
+    });
+
+    test("global mode when multiple projects exist", () => {
+      const projects = [
+        createProject({ id: "proj_1", name: "Project 1" }),
+        createProject({ id: "proj_2", name: "Project 2" }),
+      ];
+
+      const hasSingleProject = projects.length === 1;
+      const shouldShowGlobal = projects.length > 1;
+
+      expect(hasSingleProject).toBe(false);
+      expect(shouldShowGlobal).toBe(true);
+    });
+
+    test("project mode when specific projectId provided", () => {
+      const projects = [
+        createProject({ id: "proj_1", name: "Project 1" }),
+        createProject({ id: "proj_2", name: "Project 2" }),
+      ];
+
+      const projectId = "proj_1";
+      const targetProject = projects.find((p) => p.id === projectId || p.id.startsWith(projectId));
+
+      expect(targetProject).toBeDefined();
+      expect(targetProject?.name).toBe("Project 1");
+    });
+  });
+
+  describe("task grouping by project", () => {
+    test("builds task map for each project", () => {
+      const projects = [
+        createProject({ id: "proj_1" }),
+        createProject({ id: "proj_2" }),
+      ];
+
+      const allTasks = [
+        createTask({ id: "task_1", projectId: "proj_1" }),
+        createTask({ id: "task_2", projectId: "proj_1" }),
+        createTask({ id: "task_3", projectId: "proj_2" }),
+      ];
+
+      const tasksByProject = new Map<string, Task[]>();
+      for (const project of projects) {
+        tasksByProject.set(
+          project.id,
+          allTasks.filter((t) => t.projectId === project.id)
+        );
+      }
+
+      expect(tasksByProject.get("proj_1")?.length).toBe(2);
+      expect(tasksByProject.get("proj_2")?.length).toBe(1);
+    });
+
+    test("returns empty array for project with no tasks", () => {
+      const tasksByProject = new Map<string, Task[]>();
+      tasksByProject.set("proj_1", []);
+
+      const getProjectTasks = (pid: string) => tasksByProject.get(pid) ?? [];
+
+      expect(getProjectTasks("proj_1")).toEqual([]);
+      expect(getProjectTasks("proj_nonexistent")).toEqual([]);
+    });
+  });
+
+  describe("inbox filtering", () => {
+    test("filters inbox items by pending status", () => {
+      const items = [
+        createInboxItem({ id: "inbox_1", status: "pending" }),
+        createInboxItem({ id: "inbox_2", status: "promoted" }),
+        createInboxItem({ id: "inbox_3", status: "pending" }),
+        createInboxItem({ id: "inbox_4", status: "discarded" }),
+      ];
+
+      const pendingItems = items.filter((i) => i.status === "pending");
+
+      expect(pendingItems.length).toBe(2);
+      expect(pendingItems.map((i) => i.id).sort()).toEqual(["inbox_1", "inbox_3"]);
+    });
+  });
+
+  describe("empty state handling", () => {
+    test("detects when no projects exist", () => {
+      const projects: Project[] = [];
+
+      const hasProjects = projects.length > 0;
+
+      expect(hasProjects).toBe(false);
+    });
+
+    test("detects when tasks are empty", () => {
+      const tasks: Task[] = [];
+
+      const hasTasks = tasks.length > 0;
+
+      expect(hasTasks).toBe(false);
+    });
+  });
+});
+
+describe("dashboard command - exports", () => {
+  test("dashboard function is exported", async () => {
+    const { dashboard } = await import("../commands/dashboard.js");
+    expect(typeof dashboard).toBe("function");
+  });
+
+  test("dashboard accepts optional projectId parameter", async () => {
+    const { dashboard } = await import("../commands/dashboard.js");
+
+    // Verify function signature allows optional string parameter
+    // This is a type-level check, doesn't execute the function
+    const fn: (projectId?: string) => Promise<void> = dashboard;
+    expect(typeof fn).toBe("function");
+  });
+});
+
+describe("dashboard rendering options", () => {
+  test("version option structure", () => {
+    const options = { version: "1.0.0" };
+
+    expect(options.version).toBe("1.0.0");
+    expect(typeof options.version).toBe("string");
+  });
+});

package/src/__tests__/inbox.test.ts

@@ -0,0 +1,307 @@
+import { describe, expect, test } from "bun:test";
+
+describe("inbox commands - unit tests", () => {
+  describe("inbox item status handling", () => {
+    type InboxStatus = "pending" | "promoted" | "discarded";
+
+    test("pending is the default status", () => {
+      const defaultStatus: InboxStatus = "pending";
+      expect(defaultStatus).toBe("pending");
+    });
+
+    test("all valid statuses are supported", () => {
+      const validStatuses: InboxStatus[] = ["pending", "promoted", "discarded"];
+
+      expect(validStatuses).toContain("pending");
+      expect(validStatuses).toContain("promoted");
+      expect(validStatuses).toContain("discarded");
+    });
+  });
+
+  describe("content parsing", () => {
+    // Test the tag extraction logic from parseInboxInput
+    test("extracts hashtags from content", () => {
+      const content = "Test idea #tag1 with #tag2 multiple tags";
+      const tagRegex = /#(\w+)/g;
+      const tags: string[] = [];
+      let match;
+      while ((match = tagRegex.exec(content)) !== null) {
+        tags.push(match[1]!);
+      }
+
+      expect(tags).toContain("tag1");
+      expect(tags).toContain("tag2");
+      expect(tags.length).toBe(2);
+    });
+
+    test("handles content without tags", () => {
+      const content = "Simple idea without any tags";
+      const tagRegex = /#(\w+)/g;
+      const tags: string[] = [];
+      let match;
+      while ((match = tagRegex.exec(content)) !== null) {
+        tags.push(match[1]!);
+      }
+
+      expect(tags.length).toBe(0);
+    });
+
+    test("handles empty content", () => {
+      const content = "";
+      const tagRegex = /#(\w+)/g;
+      const tags: string[] = [];
+      let match;
+      while ((match = tagRegex.exec(content)) !== null) {
+        tags.push(match[1]!);
+      }
+
+      expect(tags.length).toBe(0);
+    });
+
+    test("extracts tags with alphanumeric characters", () => {
+      const content = "Idea #feature123 and #bug456";
+      const tagRegex = /#(\w+)/g;
+      const tags: string[] = [];
+      let match;
+      while ((match = tagRegex.exec(content)) !== null) {
+        tags.push(match[1]!);
+      }
+
+      expect(tags).toContain("feature123");
+      expect(tags).toContain("bug456");
+    });
+  });
+
+  describe("title truncation for promote", () => {
+    test("truncates long content to 100 characters for title", () => {
+      const longContent = "A".repeat(150);
+      const title = longContent.slice(0, 100);
+
+      expect(title.length).toBe(100);
+    });
+
+    test("keeps short content as-is for title", () => {
+      const shortContent = "Short inbox idea";
+      const title = shortContent.slice(0, 100);
+
+      expect(title).toBe(shortContent);
+    });
+  });
+
+  describe("priority validation", () => {
+    type Priority = "critical" | "high" | "medium" | "low";
+
+    test("all valid priorities are recognized", () => {
+      const priorities: Priority[] = ["critical", "high", "medium", "low"];
+
+      expect(priorities.length).toBe(4);
+      expect(priorities).toContain("critical");
+      expect(priorities).toContain("high");
+      expect(priorities).toContain("medium");
+      expect(priorities).toContain("low");
+    });
+
+    test("default priority is medium", () => {
+      const defaultPriority: Priority = "medium";
+      expect(defaultPriority).toBe("medium");
+    });
+  });
+
+  describe("date formatting", () => {
+    test("formats ISO date string for display", () => {
+      const isoDate = "2024-12-25T10:30:00Z";
+      const date = new Date(isoDate);
+      const formatted = date.toLocaleDateString();
+
+      expect(formatted.length).toBeGreaterThan(0);
+    });
+
+    test("formats full timestamp for detailed view", () => {
+      const isoDate = "2024-12-25T10:30:00Z";
+      const date = new Date(isoDate);
+      const formatted = date.toLocaleString();
+
+      expect(formatted.length).toBeGreaterThan(0);
+      // Should include both date and time components
+    });
+  });
+
+  describe("filtering logic", () => {
+    interface InboxItem {
+      id: string;
+      status: "pending" | "promoted" | "discarded";
+    }
+
+    test("filters by pending status", () => {
+      const items: InboxItem[] = [
+        { id: "1", status: "pending" },
+        { id: "2", status: "promoted" },
+        { id: "3", status: "pending" },
+      ];
+
+      const filtered = items.filter((i) => i.status === "pending");
+
+      expect(filtered.length).toBe(2);
+    });
+
+    test("filters by promoted status", () => {
+      const items: InboxItem[] = [
+        { id: "1", status: "pending" },
+        { id: "2", status: "promoted" },
+        { id: "3", status: "promoted" },
+      ];
+
+      const filtered = items.filter((i) => i.status === "promoted");
+
+      expect(filtered.length).toBe(2);
+    });
+
+    test("returns all items when no filter applied", () => {
+      const items: InboxItem[] = [
+        { id: "1", status: "pending" },
+        { id: "2", status: "promoted" },
+        { id: "3", status: "discarded" },
+      ];
+
+      expect(items.length).toBe(3);
+    });
+  });
+
+  describe("promoted item handling", () => {
+    test("tracks promotedToTaskId when promoted", () => {
+      const item = {
+        id: "inbox_123",
+        status: "promoted" as const,
+        promotedToTaskId: "task_456",
+      };
+
+      expect(item.promotedToTaskId).toBe("task_456");
+      expect(item.status).toBe("promoted");
+    });
+
+    test("prevents double promotion", () => {
+      const item = {
+        id: "inbox_123",
+        status: "promoted" as const,
+        promotedToTaskId: "task_456",
+      };
+
+      const canPromote = item.status !== "promoted";
+
+      expect(canPromote).toBe(false);
+    });
+
+    test("allows promotion of pending items", () => {
+      const item: {
+        id: string;
+        status: "pending" | "promoted" | "discarded";
+        promotedToTaskId?: string;
+      } = {
+        id: "inbox_123",
+        status: "pending",
+        promotedToTaskId: undefined,
+      };
+
+      const canPromote = item.status !== "promoted";
+
+      expect(canPromote).toBe(true);
+    });
+  });
+});
+
+describe("inbox commands - exports", () => {
+  test("inboxAddCmd is exported", async () => {
+    const { inboxAddCmd } = await import("../commands/inbox.js");
+    expect(typeof inboxAddCmd).toBe("function");
+  });
+
+  test("inboxListCmd is exported", async () => {
+    const { inboxListCmd } = await import("../commands/inbox.js");
+    expect(typeof inboxListCmd).toBe("function");
+  });
+
+  test("inboxGetCmd is exported", async () => {
+    const { inboxGetCmd } = await import("../commands/inbox.js");
+    expect(typeof inboxGetCmd).toBe("function");
+  });
+
+  test("inboxPromoteCmd is exported", async () => {
+    const { inboxPromoteCmd } = await import("../commands/inbox.js");
+    expect(typeof inboxPromoteCmd).toBe("function");
+  });
+
+  test("inboxDiscardCmd is exported", async () => {
+    const { inboxDiscardCmd } = await import("../commands/inbox.js");
+    expect(typeof inboxDiscardCmd).toBe("function");
+  });
+
+  test("inboxDeleteCmd is exported", async () => {
+    const { inboxDeleteCmd } = await import("../commands/inbox.js");
+    expect(typeof inboxDeleteCmd).toBe("function");
+  });
+
+  test("inboxCountCmd is exported", async () => {
+    const { inboxCountCmd } = await import("../commands/inbox.js");
+    expect(typeof inboxCountCmd).toBe("function");
+  });
+});
+
+describe("inbox options interfaces", () => {
+  test("InboxAddOptions structure", () => {
+    const options: { content: string; source?: string } = {
+      content: "Test content #tag",
+      source: "cli",
+    };
+
+    expect(options.content).toBeDefined();
+    expect(options.source).toBe("cli");
+  });
+
+  test("InboxListOptions structure", () => {
+    const options: {
+      all?: boolean;
+      status?: "pending" | "promoted" | "discarded";
+    } = {
+      all: false,
+      status: "pending",
+    };
+
+    expect(options.all).toBe(false);
+    expect(options.status).toBe("pending");
+  });
+
+  test("InboxPromoteOptions structure", () => {
+    const options: {
+      itemId: string;
+      projectId?: string;
+      title?: string;
+      priority?: "critical" | "high" | "medium" | "low";
+    } = {
+      itemId: "inbox_123",
+      projectId: "proj_abc",
+      title: "Promoted Task",
+      priority: "high",
+    };
+
+    expect(options.itemId).toBe("inbox_123");
+    expect(options.projectId).toBe("proj_abc");
+    expect(options.title).toBe("Promoted Task");
+    expect(options.priority).toBe("high");
+  });
+
+  test("InboxPromoteOptions with minimal fields", () => {
+    const options: {
+      itemId: string;
+      projectId?: string;
+      title?: string;
+      priority?: "critical" | "high" | "medium" | "low";
+    } = {
+      itemId: "inbox_123",
+    };
+
+    expect(options.itemId).toBe("inbox_123");
+    expect(options.projectId).toBeUndefined();
+    expect(options.title).toBeUndefined();
+    expect(options.priority).toBeUndefined();
+  });
+});