@task-mcp/cli 1.0.4 → 1.0.5

package/src/commands/dashboard.ts

@@ -1,7 +1,8 @@
 /**
- * Dashboard command - displays project overview like Taskmaster
+ * Dashboard command - displays project overview with multiple widgets
  */
 
+import { VERSION } from "../index.js";
 import {
   c,
   box,
@@ -11,6 +12,8 @@ import {
   banner,
   hline,
   pad,
+  truncate,
+  stripAnsi,
   type TableColumn,
 } from "../ansi.js";
 import {
@@ -20,10 +23,24 @@ import {
   calculateStats,
   calculateDependencyMetrics,
   suggestNextTask,
+  getTodayTasks,
+  getThisWeekTasks,
+  getOverdueTasks,
+  buildTaskTree,
+  countTreeNodes,
+  calculateCriticalPath,
+  calculateAnalysisStats,
+  listInboxItems,
   type Task,
   type Project,
+  type TaskTreeNode,
+  type InboxItem,
 } from "../storage.js";
 
+// =============================================================================
+// Formatters
+// =============================================================================
+
 function formatStatus(status: Task["status"]): string {
   const icon = icons[status] ?? icons.pending;
   return `${icon} ${status}`;
@@ -44,6 +61,323 @@ function formatDependencies(deps: Task["dependencies"]): string {
   return c.cyan(deps.map(d => d.taskId.slice(0, 4)).join(", "));
 }
 
+function formatDate(dateStr: string): string {
+  const date = new Date(dateStr);
+  const now = new Date();
+  const diffDays = Math.floor((date.getTime() - now.getTime()) / (1000 * 60 * 60 * 24));
+
+  if (diffDays < 0) return c.red(`${Math.abs(diffDays)}d overdue`);
+  if (diffDays === 0) return c.yellow("Today");
+  if (diffDays === 1) return c.yellow("Tomorrow");
+  if (diffDays <= 7) return c.blue(`${diffDays}d`);
+  return c.gray(date.toLocaleDateString());
+}
+
+// =============================================================================
+// Widget: Project Overview
+// =============================================================================
+
+function renderProjectOverview(tasks: Task[], project?: Project): string {
+  const stats = calculateStats(tasks);
+  const activeTasks = stats.total - stats.cancelled;
+
+  const lines = [
+    c.bold("Progress"),
+    progressBar(stats.completed, activeTasks, { width: 28 }),
+    "",
+    `${c.green("Done")}: ${stats.completed}  ${c.blue("In Progress")}: ${stats.inProgress}`,
+    `${c.yellow("Pending")}: ${stats.pending}  ${c.red("Blocked")}: ${stats.blocked}`,
+    stats.cancelled > 0 ? c.gray(`Cancelled: ${stats.cancelled}`) : "",
+    "",
+    c.bold("Priority"),
+    `${c.red("Critical")}: ${stats.byPriority.critical}  ${c.yellow("High")}: ${stats.byPriority.high}`,
+    `${c.blue("Medium")}: ${stats.byPriority.medium}  ${c.gray("Low")}: ${stats.byPriority.low}`,
+  ].filter(Boolean);
+
+  return box(lines.join("\n"), { title: "Overview", borderColor: "cyan" });
+}
+
+// =============================================================================
+// Widget: Time-based View
+// =============================================================================
+
+function renderTimeWidget(tasks: Task[]): string {
+  const today = getTodayTasks(tasks);
+  const overdue = getOverdueTasks(tasks);
+  const thisWeek = getThisWeekTasks(tasks);
+
+  const lines = [
+    c.bold("Due Dates"),
+    "",
+    `${c.red(icons.warning)} ${c.red("Overdue")}: ${overdue.length}`,
+    `${c.yellow("!")} ${c.yellow("Today")}: ${today.length}`,
+    `${c.blue(">")} ${c.blue("This Week")}: ${thisWeek.length}`,
+  ];
+
+  // Show up to 3 urgent tasks
+  const urgent = [...overdue, ...today.filter(t => !overdue.includes(t))].slice(0, 3);
+  if (urgent.length > 0) {
+    lines.push("", c.dim("Urgent:"));
+    for (const t of urgent) {
+      const due = t.dueDate ? formatDate(t.dueDate) : "";
+      lines.push(`  ${truncate(t.title, 20)} ${due}`);
+    }
+  }
+
+  return box(lines.join("\n"), { title: "Schedule", borderColor: "yellow" });
+}
+
+// =============================================================================
+// Widget: Dependencies & Next Task
+// =============================================================================
+
+function renderDependencyWidget(tasks: Task[]): string {
+  const depMetrics = calculateDependencyMetrics(tasks);
+  const nextTask = suggestNextTask(tasks);
+
+  const lines = [
+    c.bold("Dependencies"),
+    "",
+    `${c.green("Ready")}: ${depMetrics.readyToWork}  ${c.red("Blocked")}: ${depMetrics.blockedByDependencies}`,
+    `${c.gray("No deps")}: ${depMetrics.noDependencies}`,
+  ];
+
+  if (depMetrics.mostDependedOn) {
+    lines.push(
+      "",
+      c.dim("Bottleneck:"),
+      `  ${truncate(depMetrics.mostDependedOn.title, 18)} (${depMetrics.mostDependedOn.count})`
+    );
+  }
+
+  lines.push("", c.bold("Next Task"));
+  if (nextTask) {
+    lines.push(
+      `  ${truncate(nextTask.title, 22)}`,
+      `  ${formatPriority(nextTask.priority)}`
+    );
+  } else {
+    lines.push(c.gray("  No tasks available"));
+  }
+
+  return box(lines.join("\n"), { title: "Work Queue", borderColor: "green" });
+}
+
+// =============================================================================
+// Widget: Inbox Summary
+// =============================================================================
+
+async function renderInboxWidget(): Promise<string> {
+  const pendingItems = await listInboxItems("pending");
+
+  const lines = [
+    c.bold("Quick Capture Inbox"),
+    "",
+  ];
+
+  if (pendingItems.length === 0) {
+    lines.push(c.dim("No pending items"));
+    lines.push(c.dim("Use 'task inbox add' to capture"));
+  } else {
+    lines.push(`${c.yellow("Pending")}: ${pendingItems.length} items`);
+    lines.push("");
+
+    // Show recent items
+    const recent = pendingItems.slice(0, 4);
+    for (const item of recent) {
+      const date = new Date(item.capturedAt);
+      const ago = getTimeAgo(date);
+      const tags = item.tags?.length ? c.dim(` #${item.tags[0]}`) : "";
+      lines.push(`${c.yellow("○")} ${truncate(item.content, 22)}${tags}`);
+      lines.push(`  ${c.dim(ago)}`);
+    }
+
+    if (pendingItems.length > 4) {
+      lines.push(c.gray(`+${pendingItems.length - 4} more`));
+    }
+  }
+
+  return box(lines.join("\n"), { title: "Inbox", borderColor: "yellow" });
+}
+
+function getTimeAgo(date: Date): string {
+  const now = new Date();
+  const diffMs = now.getTime() - date.getTime();
+  const diffMins = Math.floor(diffMs / 60000);
+  const diffHours = Math.floor(diffMins / 60);
+  const diffDays = Math.floor(diffHours / 24);
+
+  if (diffMins < 60) return `${diffMins}m ago`;
+  if (diffHours < 24) return `${diffHours}h ago`;
+  if (diffDays < 7) return `${diffDays}d ago`;
+  return date.toLocaleDateString();
+}
+
+// =============================================================================
+// Widget: Critical Path
+// =============================================================================
+
+function renderCriticalPathWidget(tasks: Task[]): string {
+  const cpm = calculateCriticalPath(tasks);
+
+  const lines = [
+    c.bold("Critical Path Analysis"),
+    "",
+  ];
+
+  if (cpm.criticalPath.length === 0) {
+    lines.push(c.gray("No critical path detected."));
+    lines.push(c.dim("(Tasks have no dependencies)"));
+  } else {
+    lines.push(`${c.red("Path length")}: ${cpm.criticalPath.length} tasks`);
+    lines.push(`${c.yellow("Est. duration")}: ~${cpm.totalDuration}m`);
+    lines.push("");
+
+    // Show critical tasks
+    lines.push(c.dim("Critical tasks:"));
+    for (const task of cpm.criticalPath.slice(0, 3)) {
+      const status = icons[task.status] ?? icons.pending;
+      lines.push(`  ${status} ${truncate(task.title, 20)}`);
+    }
+    if (cpm.criticalPath.length > 3) {
+      lines.push(c.gray(`  +${cpm.criticalPath.length - 3} more`));
+    }
+  }
+
+  // Bottlenecks
+  if (cpm.bottlenecks.length > 0) {
+    lines.push("", c.dim("Bottlenecks:"));
+    for (const b of cpm.bottlenecks.slice(0, 2)) {
+      lines.push(`  ${truncate(b.task.title, 16)} ${c.red(`(${b.blocksCount})`)}`);
+    }
+  }
+
+  return box(lines.join("\n"), { title: "Critical Path", borderColor: "red" });
+}
+
+// =============================================================================
+// Widget: Hierarchy Tree
+// =============================================================================
+
+function renderHierarchyWidget(tasks: Task[]): string {
+  const activeTasks = tasks.filter(t => t.status !== "completed" && t.status !== "cancelled");
+  const tree = buildTaskTree(activeTasks);
+  const totalNodes = countTreeNodes(tree);
+  const rootCount = tree.length;
+  const subtaskCount = totalNodes - rootCount;
+
+  const lines = [
+    c.bold("Task Hierarchy"),
+    "",
+    `${c.cyan("Root tasks")}: ${rootCount}`,
+    `${c.magenta("Subtasks")}: ${subtaskCount}`,
+    "",
+  ];
+
+  // Render first few root tasks with their immediate children
+  const maxRoots = 4;
+  for (let i = 0; i < Math.min(tree.length, maxRoots); i++) {
+    const node = tree[i]!;
+    const status = icons[node.task.status] ?? icons.pending;
+    lines.push(`${status} ${truncate(node.task.title, 22)}`);
+
+    // Show up to 2 children
+    for (let j = 0; j < Math.min(node.children.length, 2); j++) {
+      const child = node.children[j]!;
+      const childStatus = icons[child.task.status] ?? icons.pending;
+      lines.push(`  ${c.gray("└")} ${childStatus} ${truncate(child.task.title, 18)}`);
+    }
+    if (node.children.length > 2) {
+      lines.push(`  ${c.gray(`  +${node.children.length - 2} more`)}`);
+    }
+  }
+
+  if (tree.length > maxRoots) {
+    lines.push(c.gray(`+${tree.length - maxRoots} more root tasks`));
+  }
+
+  return box(lines.join("\n"), { title: "Hierarchy", borderColor: "magenta" });
+}
+
+// =============================================================================
+// Widget: Complexity & Tech Stack Analysis
+// =============================================================================
+
+function renderAnalysisWidget(tasks: Task[]): string {
+  const stats = calculateAnalysisStats(tasks);
+
+  const lines = [
+    c.bold("Analysis Overview"),
+    "",
+  ];
+
+  // Complexity section
+  if (stats.complexity.analyzed > 0) {
+    lines.push(c.cyan("Complexity"));
+    lines.push(`  Analyzed: ${stats.complexity.analyzed} tasks`);
+    lines.push(`  Avg Score: ${c.yellow(String(stats.complexity.avgScore))}/10`);
+
+    const dist = stats.complexity.distribution;
+    const distBar = [
+      c.green(`■`.repeat(Math.min(dist.low, 5))),
+      c.yellow(`■`.repeat(Math.min(dist.medium, 5))),
+      c.red(`■`.repeat(Math.min(dist.high, 5))),
+    ].join("");
+    lines.push(`  ${distBar} L:${dist.low} M:${dist.medium} H:${dist.high}`);
+
+    if (stats.complexity.topFactors.length > 0) {
+      lines.push("");
+      lines.push(c.dim("Top factors:"));
+      for (const f of stats.complexity.topFactors.slice(0, 3)) {
+        lines.push(`  ${c.gray("•")} ${truncate(f.factor, 16)} (${f.count})`);
+      }
+    }
+  } else {
+    lines.push(c.gray("No complexity data"));
+    lines.push(c.dim("Use save_complexity_analysis"));
+  }
+
+  lines.push("");
+
+  // Tech Stack section
+  if (stats.techStack.analyzed > 0) {
+    lines.push(c.magenta("Tech Stack"));
+    lines.push(`  Analyzed: ${stats.techStack.analyzed} tasks`);
+
+    // Risk distribution
+    const risk = stats.techStack.byRisk;
+    const riskItems = [];
+    if (risk.critical > 0) riskItems.push(c.red(`Crit:${risk.critical}`));
+    if (risk.high > 0) riskItems.push(c.yellow(`High:${risk.high}`));
+    if (risk.medium > 0) riskItems.push(c.blue(`Med:${risk.medium}`));
+    if (risk.low > 0) riskItems.push(c.green(`Low:${risk.low}`));
+    lines.push(`  Risk: ${riskItems.join(" ")}`);
+
+    if (stats.techStack.breakingChanges > 0) {
+      lines.push(`  ${c.red(icons.warning)} ${stats.techStack.breakingChanges} breaking change(s)`);
+    }
+
+    // Top areas
+    const areas = Object.entries(stats.techStack.byArea)
+      .sort((a, b) => b[1] - a[1])
+      .slice(0, 4);
+    if (areas.length > 0) {
+      lines.push("");
+      lines.push(c.dim("Areas:"));
+      lines.push(`  ${areas.map(([a, n]) => `${a}(${n})`).join(" ")}`);
+    }
+  } else {
+    lines.push(c.gray("No tech stack data"));
+    lines.push(c.dim("Use save_tech_stack_analysis"));
+  }
+
+  return box(lines.join("\n"), { title: "Analysis", borderColor: "blue" });
+}
+
+// =============================================================================
+// Main Dashboard
+// =============================================================================
+
 export async function dashboard(projectId?: string): Promise<void> {
   // Print banner
   console.log();
@@ -77,63 +411,60 @@ export async function dashboard(projectId?: string): Promise<void> {
     tasks = await listAllTasks();
   }
 
-  // Project info
+  // Project info header
   const projectInfo = project
     ? `${c.bold("Project:")} ${project.name}`
     : `${c.bold("All Projects")} (${projects.length} projects)`;
 
-  console.log(c.dim(`Version: 1.0.4  ${projectInfo}`));
+  console.log(c.dim(`Version: ${VERSION}  ${projectInfo}`));
   console.log();
 
-  // Calculate stats
-  const stats = calculateStats(tasks);
-  const depMetrics = calculateDependencyMetrics(tasks);
-  const nextTask = suggestNextTask(tasks);
+  // Render widgets in grid layout
+  const overview = renderProjectOverview(tasks, project);
+  const timeWidget = renderTimeWidget(tasks);
+  const depWidget = renderDependencyWidget(tasks);
+  const criticalPathWidget = renderCriticalPathWidget(tasks);
+  const hierarchyWidget = renderHierarchyWidget(tasks);
+  const analysisWidget = renderAnalysisWidget(tasks);
+  const inboxWidget = await renderInboxWidget();
 
-  // Left panel: Project Dashboard
-  const dashboardContent = `${c.bold("Project Dashboard")}
-Tasks Progress: ${progressBar(stats.completed, stats.total - stats.cancelled, { width: 30 })}
-${c.green(`Done: ${stats.completed}`)}  ${c.blue(`In Progress: ${stats.inProgress}`)}  ${c.yellow(`Pending: ${stats.pending}`)}  ${c.red(`Blocked: ${stats.blocked}`)}
-${stats.cancelled > 0 ? c.gray(`Cancelled: ${stats.cancelled}`) : ""}
-
-${c.bold("Priority Breakdown")}
-${c.red("•")} Critical: ${stats.byPriority.critical}
-${c.yellow("•")} High: ${stats.byPriority.high}
-${c.blue("•")} Medium: ${stats.byPriority.medium}
-${c.gray("•")} Low: ${stats.byPriority.low}`;
-
-  // Right panel: Dependency Status
-  const depContent = `${c.bold("Dependency Status & Next Task")}
-${c.cyan("Dependency Metrics:")}
-• Tasks with no dependencies: ${depMetrics.noDependencies}
-• Tasks ready to work on: ${c.green(String(depMetrics.readyToWork))}
-• Tasks blocked by dependencies: ${depMetrics.blockedByDependencies}
-${depMetrics.mostDependedOn ? `• Most depended-on task: ${c.cyan(`#${depMetrics.mostDependedOn.id.slice(0, 4)}`)} (${depMetrics.mostDependedOn.count} dependents)` : ""}
-• Avg dependencies per task: ${depMetrics.avgDependencies}
-
-${c.yellow("Next Task to Work On:")}
-${nextTask
-    ? `ID: ${c.cyan(nextTask.id.slice(0, 4))} - ${c.bold(nextTask.title)}
-Priority: ${formatPriority(nextTask.priority)}  Dependencies: ${formatDependencies(nextTask.dependencies)}`
-    : c.gray("No actionable tasks available")}`;
-
-  // Print boxes side by side (simplified: stacked for now)
-  console.log(box(dashboardContent, { title: "Dashboard", borderColor: "cyan" }));
+  // Print widgets (2 column layout simulation)
+  console.log(overview);
+  console.log();
+  console.log(timeWidget);
+  console.log();
+  console.log(inboxWidget);
+  console.log();
+  console.log(depWidget);
   console.log();
-  console.log(box(depContent, { title: "Dependencies", borderColor: "yellow" }));
+  console.log(criticalPathWidget);
+  console.log();
+  console.log(analysisWidget);
+  console.log();
+  console.log(hierarchyWidget);
   console.log();
 
   // Task table
   if (tasks.length > 0) {
+    const activeTasks = tasks.filter(t => t.status !== "completed" && t.status !== "cancelled");
+    const displayTasks = activeTasks.slice(0, 15); // Limit to 15 rows
+
+    console.log(c.bold(`Active Tasks (${activeTasks.length})`));
+    console.log();
+
     const columns: TableColumn[] = [
       { header: "ID", key: "id", width: 6, format: (v) => c.cyan(String(v).slice(0, 4)) },
-      { header: "Title", key: "title", width: 50 },
+      { 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: "Dependencies", key: "dependencies", width: 16, format: (v) => formatDependencies(v as Task["dependencies"]) },
+      { header: "Due", key: "dueDate", width: 12, format: (v) => v ? formatDate(String(v)) : c.gray("-") },
     ];
 
-    console.log(table(tasks, columns));
+    console.log(table(displayTasks as unknown as Record<string, unknown>[], columns));
+
+    if (activeTasks.length > 15) {
+      console.log(c.gray(`\n(Showing 15 of ${activeTasks.length} active tasks)`));
+    }
   } else {
     console.log(c.gray("No tasks found."));
   }