@task-mcp/cli 1.0.20 → 1.0.22

package/package.json

@@ -1,16 +1,18 @@
 {
   "name": "@task-mcp/cli",
-  "version": "1.0.20",
+  "version": "1.0.22",
   "description": "Zero-dependency CLI for task-mcp with Bun native visualization",
   "type": "module",
   "bin": {
-    "task": "./src/index.ts"
+    "task": "./dist/index.js"
   },
+  "main": "./dist/index.js",
   "files": [
-    "src",
+    "dist",
     "README.md"
   ],
   "scripts": {
+    "build": "bun build ./src/index.ts --outdir ./dist --target bun --external @task-mcp/shared --external @task-mcp/mcp-server",
     "dev": "bun run ./src/index.ts",
     "dashboard": "bun run ./src/index.ts dashboard",
     "typecheck": "bun --bun tsc --noEmit"
@@ -30,8 +32,8 @@
     "directory": "packages/cli"
   },
   "dependencies": {
-    "@task-mcp/mcp-server": "^1.0.12",
-    "@task-mcp/shared": "^1.0.13"
+    "@task-mcp/mcp-server": "1.0.11",
+    "@task-mcp/shared": "1.0.10"
   },
   "devDependencies": {
     "@types/bun": "^1.1.14",

package/src/__tests__/ansi.test.ts

@@ -1,221 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import {
-  color,
-  style,
-  styled,
-  stripAnsi,
-  displayWidth,
-  pad,
-  truncate,
-  progressBar,
-  hline,
-  c,
-} from "../ansi.js";
-
-describe("ansi", () => {
-  describe("color", () => {
-    test("applies color code to text", () => {
-      const result = color("hello", "red");
-      expect(result).toContain("hello");
-      expect(result).toContain("\x1b[31m"); // red color code
-      expect(result).toContain("\x1b[0m"); // reset code
-    });
-
-    test("applies different colors", () => {
-      expect(color("test", "green")).toContain("\x1b[32m");
-      expect(color("test", "blue")).toContain("\x1b[34m");
-      expect(color("test", "cyan")).toContain("\x1b[36m");
-    });
-  });
-
-  describe("style", () => {
-    test("applies bold style", () => {
-      const result = style("hello", "bold");
-      expect(result).toContain("hello");
-      expect(result).toContain("\x1b[1m"); // bold code
-    });
-
-    test("applies dim style", () => {
-      const result = style("hello", "dim");
-      expect(result).toContain("\x1b[2m"); // dim code
-    });
-  });
-
-  describe("styled", () => {
-    test("combines color and style", () => {
-      const result = styled("hello", "red", "bold");
-      expect(result).toContain("hello");
-      expect(result).toContain("1;31m"); // bold + red
-    });
-
-    test("works without style", () => {
-      const result = styled("hello", "green");
-      expect(result).toContain("\x1b[32m");
-    });
-  });
-
-  describe("c convenience functions", () => {
-    test("c.red applies red color", () => {
-      expect(c.red("test")).toContain("\x1b[31m");
-    });
-
-    test("c.green applies green color", () => {
-      expect(c.green("test")).toContain("\x1b[32m");
-    });
-
-    test("c.bold applies bold style", () => {
-      expect(c.bold("test")).toContain("\x1b[1m");
-    });
-
-    test("semantic colors work", () => {
-      expect(c.success("ok")).toContain("\x1b[32m"); // green
-      expect(c.error("fail")).toContain("\x1b[31m"); // red
-      expect(c.warning("warn")).toContain("\x1b[33m"); // yellow
-    });
-  });
-
-  describe("stripAnsi", () => {
-    test("removes ANSI codes from string", () => {
-      const colored = "\x1b[31mhello\x1b[0m";
-      expect(stripAnsi(colored)).toBe("hello");
-    });
-
-    test("handles multiple ANSI codes", () => {
-      const styled = "\x1b[1;31mhello\x1b[0m \x1b[32mworld\x1b[0m";
-      expect(stripAnsi(styled)).toBe("hello world");
-    });
-
-    test("returns original string if no ANSI codes", () => {
-      expect(stripAnsi("hello world")).toBe("hello world");
-    });
-
-    test("handles empty string", () => {
-      expect(stripAnsi("")).toBe("");
-    });
-  });
-
-  describe("displayWidth", () => {
-    test("returns correct width for ASCII", () => {
-      expect(displayWidth("hello")).toBe(5);
-      expect(displayWidth("test")).toBe(4);
-    });
-
-    test("returns correct width for Korean (2 per char)", () => {
-      expect(displayWidth("안녕")).toBe(4); // 2 chars * 2 width
-      expect(displayWidth("테스트")).toBe(6); // 3 chars * 2 width
-    });
-
-    test("handles mixed ASCII and Korean", () => {
-      expect(displayWidth("hello안녕")).toBe(9); // 5 + 4
-    });
-
-    test("strips ANSI codes before calculating", () => {
-      const colored = c.red("hello");
-      expect(displayWidth(colored)).toBe(5);
-    });
-
-    test("handles empty string", () => {
-      expect(displayWidth("")).toBe(0);
-    });
-  });
-
-  describe("pad", () => {
-    test("pads string to width (left align)", () => {
-      expect(pad("hi", 5)).toBe("hi   ");
-    });
-
-    test("pads string to width (right align)", () => {
-      expect(pad("hi", 5, "right")).toBe("   hi");
-    });
-
-    test("pads string to width (center align)", () => {
-      expect(pad("hi", 6, "center")).toBe("  hi  ");
-    });
-
-    test("returns original string if already at width", () => {
-      expect(pad("hello", 5)).toBe("hello");
-    });
-
-    test("returns original string if longer than width", () => {
-      expect(pad("hello world", 5)).toBe("hello world");
-    });
-
-    test("handles ANSI codes correctly", () => {
-      const colored = c.red("hi");
-      const padded = pad(colored, 5);
-      expect(stripAnsi(padded)).toBe("hi   ");
-    });
-  });
-
-  describe("truncate", () => {
-    test("truncates long string with suffix", () => {
-      expect(truncate("hello world", 8)).toBe("hello...");
-    });
-
-    test("returns original string if within limit", () => {
-      expect(truncate("hello", 10)).toBe("hello");
-    });
-
-    test("uses custom suffix", () => {
-      expect(truncate("hello world", 8, "~")).toBe("hello w~");
-    });
-
-    test("handles Korean characters", () => {
-      const result = truncate("안녕하세요", 6);
-      expect(displayWidth(result)).toBeLessThanOrEqual(6);
-    });
-
-    test("handles empty string", () => {
-      expect(truncate("", 5)).toBe("");
-    });
-  });
-
-  describe("progressBar", () => {
-    test("creates progress bar at 0%", () => {
-      const bar = progressBar(0, 10);
-      expect(bar).toContain("0%");
-      expect(stripAnsi(bar)).toContain("░░░░░░░░░░░░░░░░░░░░");
-    });
-
-    test("creates progress bar at 50%", () => {
-      const bar = progressBar(5, 10);
-      expect(bar).toContain("50%");
-    });
-
-    test("creates progress bar at 100%", () => {
-      const bar = progressBar(10, 10);
-      expect(bar).toContain("100%");
-      expect(stripAnsi(bar)).toContain("████████████████████");
-    });
-
-    test("handles custom width", () => {
-      const bar = progressBar(5, 10, { width: 10, showPercent: false });
-      const stripped = stripAnsi(bar);
-      expect(stripped.length).toBe(10);
-    });
-
-    test("handles zero total", () => {
-      const bar = progressBar(0, 0);
-      expect(bar).toContain("0%");
-    });
-
-    test("hides percent when showPercent is false", () => {
-      const bar = progressBar(5, 10, { showPercent: false });
-      expect(bar).not.toContain("%");
-    });
-  });
-
-  describe("hline", () => {
-    test("creates horizontal line of specified width", () => {
-      expect(hline(5)).toBe("─────");
-    });
-
-    test("uses custom character", () => {
-      expect(hline(3, "=")).toBe("===");
-    });
-
-    test("handles zero width", () => {
-      expect(hline(0)).toBe("");
-    });
-  });
-});

package/src/__tests__/dashboard.test.ts

@@ -1,226 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import type { Task, InboxItem, 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,
-  };
-}
-
-// 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("workspace lookup logic", () => {
-    test("finds workspace by exact name", () => {
-      const workspaces = [
-        createWorkspace({ name: "workspace-a" }),
-        createWorkspace({ name: "workspace-b" }),
-      ];
-
-      const workspaceName = "workspace-a";
-      const workspace = workspaces.find((w) => w.name === workspaceName || w.name.startsWith(workspaceName));
-
-      expect(workspace).toBeDefined();
-      expect(workspace?.name).toBe("workspace-a");
-    });
-
-    test("finds workspace by partial name prefix", () => {
-      const workspaces = [
-        createWorkspace({ name: "workspace-abc123" }),
-        createWorkspace({ name: "workspace-xyz789" }),
-      ];
-
-      const workspaceName = "workspace-abc";
-      const workspace = workspaces.find((w) => w.name === workspaceName || w.name.startsWith(workspaceName));
-
-      expect(workspace).toBeDefined();
-      expect(workspace?.name).toBe("workspace-abc123");
-    });
-
-    test("returns undefined for non-matching name", () => {
-      const workspaces = [
-        createWorkspace({ name: "workspace-a" }),
-        createWorkspace({ name: "workspace-b" }),
-      ];
-
-      const workspaceName = "workspace-nonexistent";
-      const workspace = workspaces.find((w) => w.name === workspaceName || w.name.startsWith(workspaceName));
-
-      expect(workspace).toBeUndefined();
-    });
-
-    test("returns first match when multiple workspaces share prefix", () => {
-      const workspaces = [
-        createWorkspace({ name: "workspace-abc111" }),
-        createWorkspace({ name: "workspace-abc222" }),
-      ];
-
-      const workspaceName = "workspace-abc";
-      const workspace = workspaces.find((w) => w.name === workspaceName || w.name.startsWith(workspaceName));
-
-      expect(workspace).toBeDefined();
-      expect(workspace?.name).toBe("workspace-abc111");
-    });
-  });
-
-  describe("dashboard mode selection", () => {
-    test("single workspace mode when only one workspace exists", () => {
-      const workspaces = [createWorkspace({ name: "only-workspace" })];
-
-      const hasSingleWorkspace = workspaces.length === 1;
-      const shouldShowGlobal = workspaces.length > 1;
-
-      expect(hasSingleWorkspace).toBe(true);
-      expect(shouldShowGlobal).toBe(false);
-    });
-
-    test("global mode when multiple workspaces exist", () => {
-      const workspaces = [
-        createWorkspace({ name: "workspace-1" }),
-        createWorkspace({ name: "workspace-2" }),
-      ];
-
-      const hasSingleWorkspace = workspaces.length === 1;
-      const shouldShowGlobal = workspaces.length > 1;
-
-      expect(hasSingleWorkspace).toBe(false);
-      expect(shouldShowGlobal).toBe(true);
-    });
-
-    test("workspace mode when specific workspace provided", () => {
-      const workspaces = [
-        createWorkspace({ name: "workspace-1" }),
-        createWorkspace({ name: "workspace-2" }),
-      ];
-
-      const workspaceName = "workspace-1";
-      const targetWorkspace = workspaces.find((w) => w.name === workspaceName || w.name.startsWith(workspaceName));
-
-      expect(targetWorkspace).toBeDefined();
-      expect(targetWorkspace?.name).toBe("workspace-1");
-    });
-  });
-
-  describe("task grouping by workspace", () => {
-    test("builds task map for each workspace", () => {
-      const workspaces = [
-        createWorkspace({ name: "workspace-1" }),
-        createWorkspace({ name: "workspace-2" }),
-      ];
-
-      const allTasks = [
-        createTask({ id: "task_1", workspace: "workspace-1" }),
-        createTask({ id: "task_2", workspace: "workspace-1" }),
-        createTask({ id: "task_3", workspace: "workspace-2" }),
-      ];
-
-      const tasksByWorkspace = new Map<string, Task[]>();
-      for (const ws of workspaces) {
-        tasksByWorkspace.set(
-          ws.name,
-          allTasks.filter((t) => t.workspace === ws.name)
-        );
-      }
-
-      expect(tasksByWorkspace.get("workspace-1")?.length).toBe(2);
-      expect(tasksByWorkspace.get("workspace-2")?.length).toBe(1);
-    });
-
-    test("returns empty array for workspace with no tasks", () => {
-      const tasksByWorkspace = new Map<string, Task[]>();
-      tasksByWorkspace.set("workspace-1", []);
-
-      const getWorkspaceTasks = (name: string) => tasksByWorkspace.get(name) ?? [];
-
-      expect(getWorkspaceTasks("workspace-1")).toEqual([]);
-      expect(getWorkspaceTasks("workspace-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 workspaces exist", () => {
-      const workspaces: WorkspaceInfo[] = [];
-
-      const hasWorkspaces = workspaces.length > 0;
-
-      expect(hasWorkspaces).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");
-  });
-});