@task-mcp/shared 1.0.14 → 1.0.16

package/src/utils/dashboard-renderer.test.ts

@@ -15,16 +15,21 @@ import {
 } from "./dashboard-renderer.js";
 import { stripAnsi } from "./terminal-ui.js";
 import type { Task } from "../schemas/task.js";
-import type { Project } from "../schemas/project.js";
 import type { InboxItem } from "../schemas/inbox.js";
 
+interface WorkspaceInfo {
+  name: string;
+  taskCount: number;
+  completedCount: number;
+}
+
 // =============================================================================
 // Test Fixtures
 // =============================================================================
 
 const createTask = (overrides: Partial<Task> = {}): Task => ({
   id: "task-1",
-  projectId: "project-1",
+  workspace: "test-workspace",
   title: "Test Task",
   status: "pending",
   priority: "medium",
@@ -33,12 +38,10 @@ const createTask = (overrides: Partial<Task> = {}): Task => ({
   ...overrides,
 });
 
-const createProject = (overrides: Partial<Project> = {}): Project => ({
-  id: "proj-1",
-  name: "Test Project",
-  status: "active",
-  createdAt: "2025-01-01T00:00:00.000Z",
-  updatedAt: "2025-01-01T00:00:00.000Z",
+const createWorkspaceInfo = (overrides: Partial<WorkspaceInfo> = {}): WorkspaceInfo => ({
+  name: "test-workspace",
+  taskCount: 10,
+  completedCount: 5,
   ...overrides,
 });
 
@@ -251,9 +254,8 @@ describe("renderStatusWidget", () => {
       createTask({ id: "t2", status: "pending" }),
       createTask({ id: "t3", status: "in_progress" }),
     ];
-    const projects = [createProject()];
 
-    const widget = renderStatusWidget(tasks, projects);
+    const widget = renderStatusWidget(tasks);
     const plain = stripAnsi(widget);
 
     expect(plain).toContain("Status");
@@ -270,7 +272,7 @@ describe("renderStatusWidget", () => {
       createTask({ id: "t4", status: "pending" }),
     ];
 
-    const widget = renderStatusWidget(tasks, []);
+    const widget = renderStatusWidget(tasks);
     const plain = stripAnsi(widget);
 
     expect(plain).toContain("50%");
@@ -283,7 +285,7 @@ describe("renderStatusWidget", () => {
       createTask({ id: "t2", priority: "high" }),
     ];
 
-    const widget = renderStatusWidget(tasks, []);
+    const widget = renderStatusWidget(tasks);
     const plain = stripAnsi(widget);
 
     expect(plain).toContain("Critical");
@@ -302,7 +304,7 @@ describe("renderStatusWidget", () => {
       }),
     ];
 
-    const widget = renderStatusWidget(tasks, []);
+    const widget = renderStatusWidget(tasks);
     const plain = stripAnsi(widget);
 
     expect(plain).toContain("Ready");
@@ -316,7 +318,7 @@ describe("renderStatusWidget", () => {
       createTask({ id: "t3", status: "pending" }),
     ];
 
-    const widget = renderStatusWidget(tasks, []);
+    const widget = renderStatusWidget(tasks);
     const plain = stripAnsi(widget);
 
     // 1 completed out of 2 active = 50%
@@ -510,73 +512,73 @@ describe("renderInboxWidget", () => {
 // =============================================================================
 
 describe("renderProjectsTable", () => {
-  test("returns message for empty projects", () => {
+  test("returns message for empty workspaces", () => {
     const result = renderProjectsTable([], () => []);
     const plain = stripAnsi(result);
 
-    expect(plain).toContain("No projects found");
+    expect(plain).toContain("No workspaces found");
   });
 
-  test("renders project names", () => {
-    const projects = [
-      createProject({ id: "p1", name: "Project Alpha" }),
-      createProject({ id: "p2", name: "Project Beta" }),
+  test("renders workspace names", () => {
+    const workspaces = [
+      createWorkspaceInfo({ name: "workspace-alpha" }),
+      createWorkspaceInfo({ name: "workspace-beta" }),
     ];
 
-    const result = renderProjectsTable(projects, () => []);
+    const result = renderProjectsTable(workspaces, () => []);
     const plain = stripAnsi(result);
 
-    expect(plain).toContain("Project Alpha");
-    expect(plain).toContain("Project Beta");
+    expect(plain).toContain("workspace-alpha");
+    expect(plain).toContain("workspace-beta");
   });
 
   test("renders progress percentage", () => {
-    const projects = [createProject({ id: "p1", name: "Half Done" })];
+    const workspaces = [createWorkspaceInfo({ name: "half-done", taskCount: 2, completedCount: 1 })];
     const tasks = [
-      createTask({ id: "t1", projectId: "p1", status: "completed" }),
-      createTask({ id: "t2", projectId: "p1", status: "pending" }),
+      createTask({ id: "t1", workspace: "half-done", status: "completed" }),
+      createTask({ id: "t2", workspace: "half-done", status: "pending" }),
     ];
 
-    const result = renderProjectsTable(projects, () => tasks);
+    const result = renderProjectsTable(workspaces, () => tasks);
     const plain = stripAnsi(result);
 
     expect(plain).toContain("50%");
   });
 
   test("renders ready and blocked counts", () => {
-    const projects = [createProject({ id: "p1", name: "Test" })];
+    const workspaces = [createWorkspaceInfo({ name: "test-workspace" })];
     const tasks = [
-      createTask({ id: "t1", projectId: "p1", status: "pending" }),
+      createTask({ id: "t1", workspace: "test-workspace", status: "pending" }),
       createTask({
         id: "t2",
-        projectId: "p1",
+        workspace: "test-workspace",
         status: "pending",
         dependencies: [{ taskId: "t1", type: "blocked_by" }],
       }),
     ];
 
-    const result = renderProjectsTable(projects, () => tasks);
+    const result = renderProjectsTable(workspaces, () => tasks);
     const plain = stripAnsi(result);
 
     // Table headers should be present
-    expect(plain).toContain("Project");
+    expect(plain).toContain("Workspace");
     expect(plain).toContain("Progress");
     expect(plain).toContain("Tasks");
     expect(plain).toContain("Ready");
     expect(plain).toContain("Blocked");
   });
 
-  test("limits to 10 projects", () => {
-    const projects = Array.from({ length: 15 }, (_, i) =>
-      createProject({ id: `p${i}`, name: `Project ${i}` })
+  test("limits to 10 workspaces", () => {
+    const workspaces = Array.from({ length: 15 }, (_, i) =>
+      createWorkspaceInfo({ name: `workspace-${i}` })
     );
 
-    const result = renderProjectsTable(projects, () => []);
+    const result = renderProjectsTable(workspaces, () => []);
     const plain = stripAnsi(result);
 
-    expect(plain).toContain("Project 0");
-    expect(plain).toContain("Project 9");
-    expect(plain).not.toContain("Project 10");
+    expect(plain).toContain("workspace-0");
+    expect(plain).toContain("workspace-9");
+    expect(plain).not.toContain("workspace-10");
   });
 });
 
@@ -674,7 +676,7 @@ describe("renderTasksTable", () => {
 describe("renderDashboard", () => {
   const defaultData = {
     tasks: [createTask({ status: "pending" })],
-    projects: [createProject()],
+    workspaces: [createWorkspaceInfo()],
   };
 
   test("renders banner by default", () => {
@@ -701,28 +703,28 @@ describe("renderDashboard", () => {
     expect(plain).toContain("v1.2.3");
   });
 
-  test("shows current project name when provided", () => {
+  test("shows current workspace name when provided", () => {
     const data = {
       ...defaultData,
-      currentProject: createProject({ name: "My Project" }),
+      currentWorkspace: "my-workspace",
     };
     const result = renderDashboard(data, () => []);
     const plain = stripAnsi(result);
 
-    expect(plain).toContain("Project:");
-    expect(plain).toContain("My Project");
+    expect(plain).toContain("Workspace:");
+    expect(plain).toContain("my-workspace");
   });
 
-  test("shows all projects count when no current project", () => {
+  test("shows all workspaces count when no current workspace", () => {
     const data = {
       tasks: [],
-      projects: [createProject({ id: "p1" }), createProject({ id: "p2" })],
+      workspaces: [createWorkspaceInfo({ name: "ws1" }), createWorkspaceInfo({ name: "ws2" })],
     };
     const result = renderDashboard(data, () => []);
     const plain = stripAnsi(result);
 
-    expect(plain).toContain("All Projects");
-    expect(plain).toContain("2 projects");
+    expect(plain).toContain("All Workspaces");
+    expect(plain).toContain("2 workspaces");
   });
 
   test("renders inbox widget when items present", () => {
@@ -748,20 +750,20 @@ describe("renderDashboard", () => {
     expect(plain).not.toContain("Test inbox item");
   });
 
-  test("renders projects table for multi-project view", () => {
+  test("renders workspaces table for multi-workspace view", () => {
     const data = {
       tasks: [],
-      projects: [
-        createProject({ id: "p1", name: "Project One" }),
-        createProject({ id: "p2", name: "Project Two" }),
+      workspaces: [
+        createWorkspaceInfo({ name: "workspace-one" }),
+        createWorkspaceInfo({ name: "workspace-two" }),
       ],
     };
-    const result = renderDashboard(data, () => [], { showProjects: true });
+    const result = renderDashboard(data, () => [], { showWorkspaces: true });
     const plain = stripAnsi(result);
 
-    expect(plain).toContain("Projects");
-    expect(plain).toContain("Project One");
-    expect(plain).toContain("Project Two");
+    expect(plain).toContain("Workspaces");
+    expect(plain).toContain("workspace-one");
+    expect(plain).toContain("workspace-two");
   });
 
   test("strips ANSI codes when stripAnsiCodes is true", () => {
@@ -777,42 +779,42 @@ describe("renderDashboard", () => {
 // =============================================================================
 
 describe("renderProjectDashboard", () => {
-  test("renders single project dashboard", () => {
-    const project = createProject({ name: "My Project" });
+  test("renders single workspace dashboard", () => {
+    const workspace = "my-workspace";
     const tasks = [
       createTask({ id: "t1", title: "Task 1", status: "pending" }),
       createTask({ id: "t2", title: "Task 2", status: "completed" }),
     ];
 
-    const result = renderProjectDashboard(project, tasks);
+    const result = renderProjectDashboard(workspace, tasks);
     const plain = stripAnsi(result);
 
-    expect(plain).toContain("My Project");
+    expect(plain).toContain("my-workspace");
     expect(plain).toContain("Task 1");
   });
 
   test("includes version when provided", () => {
-    const project = createProject({ name: "Test" });
-    const result = renderProjectDashboard(project, [], { version: "2.0.0" });
+    const workspace = "test-workspace";
+    const result = renderProjectDashboard(workspace, [], { version: "2.0.0" });
     const plain = stripAnsi(result);
 
     expect(plain).toContain("v2.0.0");
   });
 
   test("strips ANSI when requested", () => {
-    const project = createProject();
-    const result = renderProjectDashboard(project, [], { stripAnsiCodes: true });
+    const workspace = "test-workspace";
+    const result = renderProjectDashboard(workspace, [], { stripAnsiCodes: true });
 
     expect(result).not.toMatch(/\x1b\[/);
   });
 
   test("shows tasks table", () => {
-    const project = createProject();
+    const workspace = "test-workspace";
     const tasks = [
       createTask({ id: "t1", title: "Active Task", status: "pending" }),
     ];
 
-    const result = renderProjectDashboard(project, tasks);
+    const result = renderProjectDashboard(workspace, tasks);
     const plain = stripAnsi(result);
 
     expect(plain).toContain("Tasks");
@@ -826,30 +828,30 @@ describe("renderProjectDashboard", () => {
 
 describe("renderGlobalDashboard", () => {
   test("renders global dashboard with all components", () => {
-    const projects = [
-      createProject({ id: "p1", name: "Project A" }),
-      createProject({ id: "p2", name: "Project B" }),
+    const workspaces = [
+      createWorkspaceInfo({ name: "workspace-a" }),
+      createWorkspaceInfo({ name: "workspace-b" }),
     ];
     const tasks = [
-      createTask({ id: "t1", projectId: "p1", status: "pending" }),
-      createTask({ id: "t2", projectId: "p2", status: "completed" }),
+      createTask({ id: "t1", workspace: "workspace-a", status: "pending" }),
+      createTask({ id: "t2", workspace: "workspace-b", status: "completed" }),
     ];
     const inboxItems = [
       createInboxItem({ content: "Inbox note", status: "pending" }),
     ];
 
     const result = renderGlobalDashboard(
-      projects,
+      workspaces,
       tasks,
       inboxItems,
-      (projectId) => tasks.filter((t) => t.projectId === projectId)
+      (workspace) => tasks.filter((t) => t.workspace === workspace)
     );
     const plain = stripAnsi(result);
 
     // Banner is rendered as ASCII art blocks
     expect(plain).toMatch(/████/);
-    expect(plain).toContain("Project A");
-    expect(plain).toContain("Project B");
+    expect(plain).toContain("workspace-a");
+    expect(plain).toContain("workspace-b");
     expect(plain).toContain("Inbox note");
   });
 
@@ -868,39 +870,39 @@ describe("renderGlobalDashboard", () => {
     expect(result).not.toMatch(/\x1b\[/);
   });
 
-  test("shows tasks table for single project", () => {
-    const projects = [createProject({ id: "p1", name: "Solo Project" })];
+  test("shows tasks table for single workspace", () => {
+    const workspaces = [createWorkspaceInfo({ name: "solo-workspace" })];
     const tasks = [
-      createTask({ id: "t1", projectId: "p1", title: "Solo Task", status: "pending" }),
+      createTask({ id: "t1", workspace: "solo-workspace", title: "Solo Task", status: "pending" }),
     ];
 
-    const result = renderGlobalDashboard(projects, tasks, [], () => tasks);
+    const result = renderGlobalDashboard(workspaces, tasks, [], () => tasks);
     const plain = stripAnsi(result);
 
     expect(plain).toContain("Tasks");
     expect(plain).toContain("Solo Task");
   });
 
-  test("uses getProjectTasks callback correctly", () => {
-    const projects = [
-      createProject({ id: "p1", name: "Project One" }),
-      createProject({ id: "p2", name: "Project Two" }),
+  test("uses getWorkspaceTasks callback correctly", () => {
+    const workspaces = [
+      createWorkspaceInfo({ name: "workspace-one" }),
+      createWorkspaceInfo({ name: "workspace-two" }),
     ];
     const allTasks = [
-      createTask({ id: "t1", projectId: "p1", status: "completed" }),
-      createTask({ id: "t2", projectId: "p1", status: "pending" }),
-      createTask({ id: "t3", projectId: "p2", status: "pending" }),
+      createTask({ id: "t1", workspace: "workspace-one", status: "completed" }),
+      createTask({ id: "t2", workspace: "workspace-one", status: "pending" }),
+      createTask({ id: "t3", workspace: "workspace-two", status: "pending" }),
     ];
 
     let callCount = 0;
-    const getProjectTasks = (projectId: string) => {
+    const getWorkspaceTasks = (workspace: string) => {
       callCount++;
-      return allTasks.filter((t) => t.projectId === projectId);
+      return allTasks.filter((t) => t.workspace === workspace);
     };
 
-    renderGlobalDashboard(projects, allTasks, [], getProjectTasks);
+    renderGlobalDashboard(workspaces, allTasks, [], getWorkspaceTasks);
 
-    // Should be called for each project in the table
+    // Should be called for each workspace in the table
     expect(callCount).toBeGreaterThan(0);
   });
 });

package/src/utils/dashboard-renderer.ts

@@ -3,7 +3,7 @@
  * Provides consistent dashboard layout across all interfaces
  */
 
-import type { Task, Project, InboxItem } from "../schemas/index.js";
+import type { Task, InboxItem } from "../schemas/index.js";
 import {
   c,
   box,
@@ -48,11 +48,17 @@ export interface DependencyMetrics {
   } | undefined;
 }
 
+export interface WorkspaceInfo {
+  name: string;
+  taskCount: number;
+  completedCount: number;
+}
+
 export interface DashboardData {
   tasks: Task[];
-  projects: Project[];
+  workspaces: WorkspaceInfo[];
   inboxItems?: InboxItem[] | undefined;
-  currentProject?: Project | undefined;
+  currentWorkspace?: string | undefined;
   version?: string | undefined;
   activeTag?: string | undefined;
 }
@@ -180,10 +186,7 @@ function getTimeAgo(date: Date): string {
 /**
  * Render Status widget (progress, counts, priorities, dependencies)
  */
-export function renderStatusWidget(
-  tasks: Task[],
-  _projects: Project[]
-): string {
+export function renderStatusWidget(tasks: Task[]): string {
   const stats = calculateStats(tasks);
   const depMetrics = calculateDependencyMetrics(tasks);
   const today = getTodayTasks(tasks);
@@ -315,14 +318,14 @@ export function renderInboxWidget(inboxItems: InboxItem[]): string | null {
 }
 
 /**
- * Render Projects table
+ * Render Workspaces table
  */
-export function renderProjectsTable(
-  projects: Project[],
-  getProjectTasks: (projectId: string) => Task[]
+export function renderWorkspacesTable(
+  workspaces: WorkspaceInfo[],
+  getWorkspaceTasks: (workspace: string) => Task[]
 ): string {
-  if (projects.length === 0) {
-    return c.gray("No projects found.");
+  if (workspaces.length === 0) {
+    return c.gray("No workspaces found.");
   }
 
   const rows: {
@@ -333,8 +336,8 @@ export function renderProjectsTable(
     total: number;
   }[] = [];
 
-  for (const project of projects.slice(0, 10)) {
-    const tasks = getProjectTasks(project.id);
+  for (const ws of workspaces.slice(0, 10)) {
+    const tasks = getWorkspaceTasks(ws.name);
     const stats = calculateStats(tasks);
     const depMetrics = calculateDependencyMetrics(tasks);
     const activeTasks = stats.total - stats.cancelled;
@@ -351,7 +354,7 @@ export function renderProjectsTable(
       c.green("█".repeat(filled)) + c.gray("░".repeat(empty));
 
     rows.push({
-      name: truncateStr(project.name, 20),
+      name: truncateStr(ws.name, 20),
       progress: `${miniBar} ${pad(String(percent) + "%", 4, "right")}`,
       ready: depMetrics.readyToWork,
       blocked: depMetrics.blockedByDependencies,
@@ -360,7 +363,7 @@ export function renderProjectsTable(
   }
 
   const columns: TableColumn[] = [
-    { key: "name", header: "Project", width: 22 },
+    { key: "name", header: "Workspace", width: 22 },
     { key: "progress", header: "Progress", width: 16 },
     { key: "total", header: "Tasks", width: 6, align: "right" },
     {
@@ -382,8 +385,11 @@ export function renderProjectsTable(
   return table(rows as unknown as Record<string, unknown>[], columns);
 }
 
+// Legacy export for backwards compatibility
+export const renderProjectsTable = renderWorkspacesTable;
+
 /**
- * Render Tasks table for single project view
+ * Render Tasks table for single workspace view
  */
 export function renderTasksTable(tasks: Task[], limit: number = 10): string {
   const activeTasks = tasks.filter(
@@ -459,7 +465,7 @@ function getOverdueTasks(tasks: Task[]): Task[] {
 export interface RenderDashboardOptions {
   showBanner?: boolean | undefined;
   showInbox?: boolean | undefined;
-  showProjects?: boolean | undefined;
+  showWorkspaces?: boolean | undefined;
   showTasks?: boolean | undefined;
   stripAnsiCodes?: boolean | undefined;
 }
@@ -469,18 +475,18 @@ export interface RenderDashboardOptions {
  */
 export function renderDashboard(
   data: DashboardData,
-  getProjectTasks: (projectId: string) => Task[],
+  getWorkspaceTasks: (workspace: string) => Task[],
   options: RenderDashboardOptions = {}
 ): string {
   const {
     showBanner = true,
     showInbox = true,
-    showProjects = true,
+    showWorkspaces = true,
     showTasks = true,
     stripAnsiCodes = false,
   } = options;
 
-  const { tasks, projects, inboxItems = [], currentProject, version, activeTag } = data;
+  const { tasks, workspaces, inboxItems = [], currentWorkspace, version, activeTag } = data;
   const lines: string[] = [];
 
   // Banner
@@ -490,10 +496,10 @@ export function renderDashboard(
     lines.push("");
   }
 
-  // Project info header
-  const projectInfo = currentProject
-    ? `${c.bold("Project:")} ${currentProject.name}`
-    : `${c.bold("All Projects")} (${projects.length} projects)`;
+  // Workspace info header
+  const workspaceInfo = currentWorkspace
+    ? `${c.bold("Workspace:")} ${currentWorkspace}`
+    : `${c.bold("All Workspaces")} (${workspaces.length} workspaces)`;
 
   // Build header line with version and tag
   const headerParts: string[] = [];
@@ -501,14 +507,14 @@ export function renderDashboard(
   if (activeTag) headerParts.push(`#${activeTag}`);
 
   if (headerParts.length > 0) {
-    lines.push(c.dim(`${headerParts.join("  ")}  ${projectInfo}`));
+    lines.push(c.dim(`${headerParts.join("  ")}  ${workspaceInfo}`));
   } else {
-    lines.push(projectInfo);
+    lines.push(workspaceInfo);
   }
   lines.push("");
 
   // Status + Actions widgets side by side
-  const statusWidget = renderStatusWidget(tasks, projects);
+  const statusWidget = renderStatusWidget(tasks);
   const actionsWidget = renderActionsWidget(tasks);
   lines.push(sideBySide([statusWidget, actionsWidget], 2));
   lines.push("");
@@ -522,16 +528,16 @@ export function renderDashboard(
     }
   }
 
-  // Projects table (only for all-projects view)
-  if (showProjects && !currentProject && projects.length > 1) {
-    lines.push(c.bold("Projects"));
+  // Workspaces table (only for all-workspaces view)
+  if (showWorkspaces && !currentWorkspace && workspaces.length > 1) {
+    lines.push(c.bold("Workspaces"));
     lines.push("");
-    lines.push(renderProjectsTable(projects, getProjectTasks));
+    lines.push(renderWorkspacesTable(workspaces, getWorkspaceTasks));
     lines.push("");
   }
 
-  // Tasks table (for single project view)
-  if (showTasks && (currentProject || projects.length === 1)) {
+  // Tasks table (for single workspace view)
+  if (showTasks && (currentWorkspace || workspaces.length === 1)) {
     const activeTasks = tasks.filter(
       (t) => t.status !== "completed" && t.status !== "cancelled"
     );
@@ -549,17 +555,23 @@ export function renderDashboard(
 }
 
 /**
- * Render single project dashboard
+ * Render single workspace dashboard
  */
-export function renderProjectDashboard(
-  project: Project,
+export function renderWorkspaceDashboard(
+  workspace: string,
   tasks: Task[],
   options: { stripAnsiCodes?: boolean; version?: string; activeTag?: string } = {}
 ): string {
+  const wsInfo: WorkspaceInfo = {
+    name: workspace,
+    taskCount: tasks.length,
+    completedCount: tasks.filter(t => t.status === "completed").length,
+  };
+
   const data: DashboardData = {
     tasks,
-    projects: [project],
-    currentProject: project,
+    workspaces: [wsInfo],
+    currentWorkspace: workspace,
     version: options.version,
     activeTag: options.activeTag,
   };
@@ -570,36 +582,39 @@ export function renderProjectDashboard(
     {
       showBanner: true,
       showInbox: false,
-      showProjects: false,
+      showWorkspaces: false,
       showTasks: true,
       stripAnsiCodes: options.stripAnsiCodes,
     }
   );
 }
 
+// Legacy export for backwards compatibility
+export const renderProjectDashboard = renderWorkspaceDashboard;
+
 /**
- * Render global dashboard (all projects)
+ * Render global dashboard (all workspaces)
  */
 export function renderGlobalDashboard(
-  projects: Project[],
+  workspaces: WorkspaceInfo[],
   allTasks: Task[],
   inboxItems: InboxItem[],
-  getProjectTasks: (projectId: string) => Task[],
+  getWorkspaceTasks: (workspace: string) => Task[],
   options: { stripAnsiCodes?: boolean; version?: string; activeTag?: string } = {}
 ): string {
   const data: DashboardData = {
     tasks: allTasks,
-    projects,
+    workspaces,
     inboxItems,
     version: options.version,
     activeTag: options.activeTag,
   };
 
-  return renderDashboard(data, getProjectTasks, {
+  return renderDashboard(data, getWorkspaceTasks, {
     showBanner: true,
     showInbox: true,
-    showProjects: true,
-    showTasks: projects.length === 1,
+    showWorkspaces: true,
+    showTasks: workspaces.length === 1,
     stripAnsiCodes: options.stripAnsiCodes,
   });
 }