@task-mcp/cli 1.0.29 → 1.0.31

package/dist/index.js

@@ -31,7 +31,17 @@ import {
   priorityColors,
   formatPriority,
   formatDependencies,
-  banner
+  banner,
+  STATUS_SYMBOLS,
+  formatStatusSymbol,
+  PRIORITY_LEVELS,
+  formatPriorityBadge,
+  renderSection,
+  renderSections,
+  renderAlert,
+  renderStats,
+  formatDueDate,
+  formatTaskLine
 } from "@task-mcp/shared";
 import { truncateStr as truncateStr2 } from "@task-mcp/shared";
 
@@ -42,10 +52,17 @@ import {
 } from "@task-mcp/shared";
 
 // src/storage.ts
-import { TaskStore, InboxStore, StateStore } from "@task-mcp/mcp-server/storage";
+import {
+  TaskStore,
+  InboxStore,
+  StateStore,
+  SessionStore,
+  getDefaultTasksDir
+} from "@task-mcp/mcp-server/storage";
 var _taskStore = null;
 var _inboxStore = null;
 var _stateStore = null;
+var _sessionStore = null;
 function getTaskStore() {
   if (!_taskStore) {
     _taskStore = new TaskStore;
@@ -64,6 +81,13 @@ function getStateStore() {
   }
   return _stateStore;
 }
+function getSessionStore() {
+  if (!_sessionStore) {
+    const taskStore = getTaskStore();
+    _sessionStore = new SessionStore(getDefaultTasksDir(), taskStore.currentWorkspace);
+  }
+  return _sessionStore;
+}
 function getCurrentWorkspace() {
   return getTaskStore().currentWorkspace;
 }
@@ -93,6 +117,149 @@ async function listInboxItems(status) {
 async function getActiveTag() {
   return getStateStore().getActiveTag();
 }
+function calculateStats(tasks) {
+  const stats = {
+    total: tasks.length,
+    completed: 0,
+    inProgress: 0,
+    pending: 0,
+    blocked: 0,
+    cancelled: 0,
+    byPriority: { critical: 0, high: 0, medium: 0, low: 0 },
+    completionPercent: 0
+  };
+  for (const task of tasks) {
+    switch (task.status) {
+      case "completed":
+        stats.completed++;
+        break;
+      case "in_progress":
+        stats.inProgress++;
+        break;
+      case "pending":
+        stats.pending++;
+        break;
+      case "blocked":
+        stats.blocked++;
+        break;
+      case "cancelled":
+        stats.cancelled++;
+        break;
+    }
+    stats.byPriority[task.priority]++;
+  }
+  const nonCancelled = stats.total - stats.cancelled;
+  stats.completionPercent = nonCancelled > 0 ? Math.round(stats.completed / nonCancelled * 100) : 0;
+  return stats;
+}
+function calculateDependencyMetrics(tasks) {
+  const activeTasks = tasks.filter((t) => t.status !== "completed" && t.status !== "cancelled");
+  const completedIds = new Set(tasks.filter((t) => t.status === "completed").map((t) => t.id));
+  const dependentCounts = {};
+  for (const task of activeTasks) {
+    for (const dep of task.dependencies ?? []) {
+      dependentCounts[dep.taskId] = (dependentCounts[dep.taskId] ?? 0) + 1;
+    }
+  }
+  let mostDependedOn = null;
+  let maxCount = 0;
+  for (const [id, count] of Object.entries(dependentCounts)) {
+    if (count > maxCount) {
+      maxCount = count;
+      const task = tasks.find((t) => t.id === id);
+      if (task) {
+        mostDependedOn = { id, title: task.title, count };
+      }
+    }
+  }
+  const noDependencies = activeTasks.filter((t) => (t.dependencies?.length ?? 0) === 0).length;
+  const readyToWork = activeTasks.filter((t) => {
+    const deps = t.dependencies ?? [];
+    if (deps.length === 0)
+      return true;
+    return deps.every((d) => completedIds.has(d.taskId));
+  }).length;
+  const blockedByDependencies = activeTasks.length - readyToWork;
+  const totalDeps = activeTasks.reduce((sum, t) => sum + (t.dependencies?.length ?? 0), 0);
+  const avgDependencies = activeTasks.length > 0 ? totalDeps / activeTasks.length : 0;
+  return {
+    noDependencies,
+    readyToWork,
+    blockedByDependencies,
+    mostDependedOn,
+    avgDependencies: Math.round(avgDependencies * 10) / 10
+  };
+}
+function suggestNextTask(tasks) {
+  const completedIds = new Set(tasks.filter((t) => t.status === "completed").map((t) => t.id));
+  const actionable = tasks.filter((t) => {
+    if (t.status !== "pending" && t.status !== "in_progress")
+      return false;
+    const deps = t.dependencies ?? [];
+    return deps.every((d) => completedIds.has(d.taskId));
+  });
+  if (actionable.length === 0)
+    return null;
+  const priorityOrder = { critical: 0, high: 1, medium: 2, low: 3 };
+  actionable.sort((a, b) => {
+    const pDiff = priorityOrder[a.priority] - priorityOrder[b.priority];
+    if (pDiff !== 0)
+      return pDiff;
+    return new Date(a.createdAt).getTime() - new Date(b.createdAt).getTime();
+  });
+  return actionable[0] ?? null;
+}
+function formatTimeSince(isoTimestamp) {
+  const then = new Date(isoTimestamp).getTime();
+  const nowMs = Date.now();
+  const diffMs = nowMs - then;
+  const minutes = Math.floor(diffMs / (1000 * 60));
+  const hours = Math.floor(minutes / 60);
+  const days = Math.floor(hours / 24);
+  if (days > 0) {
+    return `${days}d ago`;
+  }
+  if (hours > 0) {
+    return `${hours}h ago`;
+  }
+  if (minutes > 0) {
+    return `${minutes}m ago`;
+  }
+  return "just now";
+}
+async function getLastSessionInfo() {
+  try {
+    const sessionStore = getSessionStore();
+    const lastSession = await sessionStore.getLastSession();
+    if (!lastSession || !lastSession.endedAt) {
+      return null;
+    }
+    const tasks = await listTasks();
+    const inProgressTasks = tasks.filter((t) => t.status === "in_progress");
+    const summary = lastSession.tasksSummary;
+    let currentInProgressTask;
+    if (inProgressTasks.length > 0) {
+      const sessionTaskIds = new Set(lastSession.tasksWorked);
+      const sessionInProgress = inProgressTasks.find((t) => sessionTaskIds.has(t.id));
+      const taskToShow = sessionInProgress ?? inProgressTasks[0];
+      if (taskToShow) {
+        currentInProgressTask = {
+          id: taskToShow.id,
+          title: taskToShow.title
+        };
+      }
+    }
+    return {
+      session: lastSession,
+      timeSince: formatTimeSince(lastSession.endedAt),
+      completed: summary?.completed ?? 0,
+      inProgress: inProgressTasks.length,
+      currentInProgressTask
+    };
+  } catch {
+    return null;
+  }
+}
 
 // src/commands/dashboard.ts
 async function dashboard(workspaceName) {
@@ -141,6 +308,552 @@ async function dashboard(workspaceName) {
   console.log(output);
 }
 
+// src/commands/smart-dashboard.ts
+function getOverdueTasks(tasks) {
+  const today = new Date;
+  today.setHours(0, 0, 0, 0);
+  return tasks.filter((t) => {
+    if (t.status === "completed" || t.status === "cancelled")
+      return false;
+    if (!t.dueDate)
+      return false;
+    const due = new Date(t.dueDate);
+    due.setHours(0, 0, 0, 0);
+    return due < today;
+  });
+}
+function getStaleBlockedTasks(tasks, daysThreshold = 3) {
+  const now = Date.now();
+  const thresholdMs = daysThreshold * 24 * 60 * 60 * 1000;
+  return tasks.filter((t) => {
+    if (t.status !== "blocked")
+      return false;
+    const createdAt = new Date(t.createdAt).getTime();
+    return now - createdAt > thresholdMs;
+  });
+}
+function getDueSoonTasks(tasks) {
+  const today = new Date;
+  today.setHours(0, 0, 0, 0);
+  const tomorrow = new Date(today);
+  tomorrow.setDate(tomorrow.getDate() + 1);
+  const dayAfter = new Date(today);
+  dayAfter.setDate(dayAfter.getDate() + 2);
+  return tasks.filter((t) => {
+    if (t.status === "completed" || t.status === "cancelled")
+      return false;
+    if (!t.dueDate)
+      return false;
+    const due = new Date(t.dueDate);
+    due.setHours(0, 0, 0, 0);
+    return due >= today && due < dayAfter;
+  }).sort((a, b) => {
+    const dateA = new Date(a.dueDate).getTime();
+    const dateB = new Date(b.dueDate).getTime();
+    return dateA - dateB;
+  });
+}
+function getSuggestionReason(task, tasks) {
+  const reasons = [];
+  const blockingCount = tasks.filter((t) => t.dependencies?.some((d) => d.taskId === task.id)).length;
+  if (blockingCount > 0) {
+    reasons.push(`Unblocks ${blockingCount} task${blockingCount > 1 ? "s" : ""}`);
+  }
+  if (task.priority === "critical") {
+    reasons.push("Critical priority");
+  } else if (task.priority === "high") {
+    reasons.push("High priority");
+  }
+  if (task.dueDate) {
+    const today = new Date;
+    today.setHours(0, 0, 0, 0);
+    const due = new Date(task.dueDate);
+    due.setHours(0, 0, 0, 0);
+    const diffDays = Math.floor((due.getTime() - today.getTime()) / (1000 * 60 * 60 * 24));
+    if (diffDays < 0) {
+      reasons.push("Overdue");
+    } else if (diffDays === 0) {
+      reasons.push("Due today");
+    } else if (diffDays === 1) {
+      reasons.push("Due tomorrow");
+    }
+  }
+  if (task.status === "in_progress") {
+    reasons.push("Already started");
+  }
+  return reasons.length > 0 ? reasons.join(", ") : "Ready to start";
+}
+function taskToSectionItem(task, options = {}) {
+  const prefix = formatStatusSymbol(task.status);
+  const idStr = c.gray(task.id.slice(-4));
+  const title = truncateStr(task.title, 35);
+  const primary = `${idStr}  ${title}`;
+  const suffixParts = [];
+  if (task.priority) {
+    suffixParts.push(formatPriorityBadge(task.priority));
+  }
+  if (task.dueDate) {
+    suffixParts.push(formatDueDate(task.dueDate));
+  }
+  const details = [];
+  if (options.showReason) {
+    details.push(options.showReason);
+  }
+  return {
+    primary,
+    prefix,
+    suffix: suffixParts.join("  "),
+    details
+  };
+}
+function renderHeader(workspace, stats) {
+  const lines = [];
+  const title = `task-mcp`;
+  const wsName = c.cyan(workspace);
+  const bar = progressBar(stats.completed, stats.total - stats.cancelled, {
+    width: 10,
+    showPercent: false
+  });
+  lines.push(c.gray(BOX.rTopLeft + hline(60, BOX.horizontal) + BOX.rTopRight));
+  lines.push(c.gray(BOX.vertical) + `  ${c.bold(title)} ${c.gray("@")} ${wsName}` + " ".repeat(20) + `Health: ${bar} ${stats.completionPercent}%` + "  " + c.gray(BOX.vertical));
+  lines.push(c.gray(BOX.rBottomLeft + hline(60, BOX.horizontal) + BOX.rBottomRight));
+  return lines;
+}
+function renderNextAction(tasks) {
+  const nextTask = suggestNextTask(tasks);
+  if (!nextTask) {
+    return renderSection("Next Action", [], {
+      icon: "\uD83C\uDFAF",
+      emptyMessage: "No actionable tasks"
+    });
+  }
+  const reason = getSuggestionReason(nextTask, tasks);
+  const item = taskToSectionItem(nextTask, { showReason: reason });
+  return renderSection("Next Action", [item], { icon: "\uD83C\uDFAF" });
+}
+function renderAttention(tasks) {
+  const alerts = [];
+  const overdue = getOverdueTasks(tasks);
+  if (overdue.length > 0) {
+    alerts.push(c.red(`${overdue.length} task${overdue.length > 1 ? "s" : ""} overdue`));
+  }
+  const staleBlocked = getStaleBlockedTasks(tasks, 3);
+  if (staleBlocked.length > 0) {
+    alerts.push(c.yellow(`${staleBlocked.length} task${staleBlocked.length > 1 ? "s" : ""} blocked > 3 days`));
+  }
+  const blockedCount = tasks.filter((t) => t.status === "blocked").length;
+  if (blockedCount > 0 && staleBlocked.length === 0) {
+    alerts.push(c.yellow(`${blockedCount} task${blockedCount > 1 ? "s" : ""} blocked`));
+  }
+  const inProgressCount = tasks.filter((t) => t.status === "in_progress").length;
+  if (inProgressCount > 0) {
+    alerts.push(c.cyan(`${inProgressCount} task${inProgressCount > 1 ? "s" : ""} in progress`));
+  }
+  if (alerts.length === 0) {
+    return renderSection("Attention", [], {
+      icon: "\u26A0",
+      emptyMessage: c.green("All clear!"),
+      headerColor: "yellow"
+    });
+  }
+  const items = alerts.map((alert) => ({
+    primary: alert,
+    prefix: c.gray("\u2022")
+  }));
+  return renderSection("Attention", items, {
+    icon: "\u26A0",
+    headerColor: "yellow"
+  });
+}
+function renderDueSoon(tasks) {
+  const dueSoon = getDueSoonTasks(tasks);
+  if (dueSoon.length === 0) {
+    return renderSection("Due Soon", [], {
+      icon: "\uD83D\uDCC5",
+      emptyMessage: "No upcoming deadlines"
+    });
+  }
+  const items = dueSoon.slice(0, 5).map((task) => taskToSectionItem(task));
+  return renderSection("Due Soon", items, {
+    icon: "\uD83D\uDCC5",
+    showCount: dueSoon.length > 5
+  });
+}
+function renderQuickStats(stats) {
+  const statsRow = renderStats([
+    { label: "Total", value: stats.total },
+    { label: "Done", value: `${stats.completed} (${stats.completionPercent}%)`, color: "green" },
+    { label: "In Progress", value: stats.inProgress, color: "cyan" },
+    { label: "Blocked", value: stats.blocked, color: stats.blocked > 0 ? "red" : "gray" }
+  ]);
+  return ["", c.gray(statsRow)];
+}
+function renderLastSession(sessionInfo) {
+  if (!sessionInfo) {
+    return [];
+  }
+  const lines = [];
+  const header = `${c.gray("Last Session:")} ${c.cyan(sessionInfo.timeSince)}`;
+  lines.push(`  ${header}`);
+  const summaryParts = [];
+  if (sessionInfo.completed > 0) {
+    summaryParts.push(`${sessionInfo.completed} completed`);
+  }
+  if (sessionInfo.inProgress > 0) {
+    summaryParts.push(`${sessionInfo.inProgress} in progress`);
+  }
+  if (summaryParts.length > 0) {
+    lines.push(`  ${c.gray("->")} ${summaryParts.join(", ")}`);
+  }
+  if (sessionInfo.currentInProgressTask) {
+    const taskId = c.gray(sessionInfo.currentInProgressTask.id.slice(-8));
+    const title = truncateStr(sessionInfo.currentInProgressTask.title, 40);
+    lines.push(`  ${c.gray("->")} ${taskId}: ${title} ${c.cyan("(in_progress)")}`);
+  }
+  return lines;
+}
+async function smartDashboard() {
+  const workspaces = await listWorkspaces();
+  if (workspaces.length === 0) {
+    console.log(c.yellow("No tasks found. Create a task first using the MCP server."));
+    return;
+  }
+  const workspace = getCurrentWorkspace();
+  const tasks = await listTasks();
+  const stats = calculateStats(tasks);
+  const lastSessionInfo = await getLastSessionInfo();
+  const lines = [];
+  lines.push(...renderHeader(workspace, stats));
+  lines.push("");
+  const lastSessionLines = renderLastSession(lastSessionInfo);
+  if (lastSessionLines.length > 0) {
+    lines.push(...lastSessionLines);
+    lines.push("");
+  }
+  lines.push(...renderNextAction(tasks));
+  lines.push("");
+  const attentionLines = renderAttention(tasks);
+  if (attentionLines.length > 2) {
+    lines.push(...attentionLines);
+    lines.push("");
+  }
+  lines.push(...renderDueSoon(tasks));
+  lines.push(...renderQuickStats(stats));
+  lines.push("");
+  lines.push(c.gray("  Run: task next | task health | task blocked | task tree"));
+  console.log(lines.join(`
+`));
+}
+
+// src/commands/next.ts
+var STRATEGY_DESCRIPTIONS = {
+  balanced: "Balance priority, dependencies, and due dates",
+  quick_wins: "Focus on quick, low-effort tasks",
+  unblock: "Prioritize tasks that unblock others",
+  critical_path: "Focus on critical path tasks"
+};
+function getDependentTasks(task, tasks) {
+  return tasks.filter((t) => t.dependencies?.some((d) => d.taskId === task.id));
+}
+function suggestByStrategy(tasks, strategy) {
+  const completedIds = new Set(tasks.filter((t) => t.status === "completed").map((t) => t.id));
+  const actionable = tasks.filter((t) => {
+    if (t.status !== "pending" && t.status !== "in_progress")
+      return false;
+    const deps = t.dependencies ?? [];
+    return deps.every((d) => completedIds.has(d.taskId));
+  });
+  if (actionable.length === 0)
+    return null;
+  const priorityOrder = { critical: 0, high: 1, medium: 2, low: 3 };
+  switch (strategy) {
+    case "quick_wins":
+      actionable.sort((a, b) => {
+        const estA = a.estimate?.expected ?? 60;
+        const estB = b.estimate?.expected ?? 60;
+        if (estA !== estB)
+          return estA - estB;
+        return priorityOrder[a.priority] - priorityOrder[b.priority];
+      });
+      break;
+    case "unblock":
+      actionable.sort((a, b) => {
+        const depsA = getDependentTasks(a, tasks).length;
+        const depsB = getDependentTasks(b, tasks).length;
+        if (depsA !== depsB)
+          return depsB - depsA;
+        return priorityOrder[a.priority] - priorityOrder[b.priority];
+      });
+      break;
+    case "critical_path":
+      actionable.sort((a, b) => {
+        const pDiff = priorityOrder[a.priority] - priorityOrder[b.priority];
+        if (pDiff !== 0)
+          return pDiff;
+        const depsA = getDependentTasks(a, tasks).length;
+        const depsB = getDependentTasks(b, tasks).length;
+        return depsB - depsA;
+      });
+      break;
+    case "balanced":
+    default:
+      actionable.sort((a, b) => {
+        const pDiff = priorityOrder[a.priority] - priorityOrder[b.priority];
+        if (pDiff !== 0)
+          return pDiff;
+        const dueA = a.dueDate ? new Date(a.dueDate).getTime() : Infinity;
+        const dueB = b.dueDate ? new Date(b.dueDate).getTime() : Infinity;
+        if (dueA !== dueB)
+          return dueA - dueB;
+        return new Date(a.createdAt).getTime() - new Date(b.createdAt).getTime();
+      });
+      break;
+  }
+  return actionable[0] ?? null;
+}
+function buildReasons(task, tasks) {
+  const reasons = [];
+  if (task.priority === "critical") {
+    reasons.push("\uD83D\uDD34 Critical priority");
+  } else if (task.priority === "high") {
+    reasons.push("\uD83D\uDFE0 High priority");
+  }
+  if (task.dueDate) {
+    const today = new Date;
+    today.setHours(0, 0, 0, 0);
+    const due = new Date(task.dueDate);
+    due.setHours(0, 0, 0, 0);
+    const diffDays = Math.floor((due.getTime() - today.getTime()) / (1000 * 60 * 60 * 24));
+    if (diffDays < 0) {
+      reasons.push(`\u26A0\uFE0F  Overdue by ${Math.abs(diffDays)} day${Math.abs(diffDays) > 1 ? "s" : ""}`);
+    } else if (diffDays === 0) {
+      reasons.push("\uD83D\uDCC5 Due today");
+    } else if (diffDays === 1) {
+      reasons.push("\uD83D\uDCC5 Due tomorrow");
+    } else if (diffDays <= 3) {
+      reasons.push(`\uD83D\uDCC5 Due in ${diffDays} days`);
+    }
+  }
+  const dependents = getDependentTasks(task, tasks);
+  if (dependents.length > 0) {
+    reasons.push(`\uD83D\uDD13 Unblocks ${dependents.length} task${dependents.length > 1 ? "s" : ""}`);
+  }
+  if (task.status === "in_progress") {
+    reasons.push("\u25B6\uFE0F  Already in progress");
+  }
+  if (!task.dependencies || task.dependencies.length === 0) {
+    reasons.push("\u2705 No blockers");
+  }
+  if (reasons.length === 0) {
+    reasons.push("Ready to start");
+  }
+  return reasons;
+}
+function renderTaskDetail(task, _tasks) {
+  const lines = [];
+  const status = formatStatusSymbol(task.status);
+  const priority = formatPriorityBadge(task.priority);
+  lines.push("");
+  lines.push(`  ${status} ${c.bold(task.title)}  ${priority}`);
+  lines.push("");
+  const details = [
+    ["ID", c.gray(task.id)],
+    ["Status", task.status],
+    ["Priority", task.priority]
+  ];
+  if (task.dueDate) {
+    details.push(["Due", formatDueDate(task.dueDate)]);
+  }
+  if (task.estimate?.expected) {
+    const hours = Math.floor(task.estimate.expected / 60);
+    const mins = task.estimate.expected % 60;
+    const timeStr = hours > 0 ? `${hours}h ${mins}m` : `${mins}m`;
+    details.push(["Estimate", timeStr]);
+  }
+  if (task.tags && task.tags.length > 0) {
+    details.push(["Tags", task.tags.map((t) => c.cyan(`#${t}`)).join(" ")]);
+  }
+  for (const [label, value] of details) {
+    lines.push(`  ${c.gray(label + ":")}  ${value}`);
+  }
+  if (task.description) {
+    lines.push("");
+    lines.push(`  ${c.gray("Description:")}`);
+    const descLines = task.description.split(`
+`).slice(0, 3);
+    for (const line of descLines) {
+      lines.push(`    ${c.dim(line)}`);
+    }
+  }
+  return lines;
+}
+function renderImpact(task, tasks) {
+  const dependents = getDependentTasks(task, tasks);
+  if (dependents.length === 0) {
+    return [];
+  }
+  const items = dependents.slice(0, 5).map((t) => ({
+    primary: `${c.gray(t.id.slice(-4))}  ${t.title}`,
+    prefix: formatStatusSymbol(t.status)
+  }));
+  return [
+    "",
+    ...renderSection("Will Unblock", items, {
+      icon: "\uD83D\uDD13",
+      showCount: dependents.length > 5
+    })
+  ];
+}
+function renderAlternatives(currentStrategy) {
+  const others = Object.keys(STRATEGY_DESCRIPTIONS).filter((s) => s !== currentStrategy);
+  const lines = ["", c.gray("  Alternative strategies:")];
+  for (const strategy of others) {
+    lines.push(`    ${c.cyan(`task next --strategy ${strategy}`)}`);
+  }
+  return lines;
+}
+async function nextCmd(options = {}) {
+  const strategy = options.strategy ?? "balanced";
+  const tasks = await listTasks();
+  const nextTask = suggestByStrategy(tasks, strategy);
+  if (!nextTask) {
+    console.log(c.yellow("No actionable tasks found."));
+    console.log(c.gray("All tasks may be completed, blocked, or have unmet dependencies."));
+    return;
+  }
+  const reasons = buildReasons(nextTask, tasks);
+  const lines = [];
+  lines.push(c.cyan(c.bold("\uD83C\uDFAF Suggested Next Task")));
+  lines.push(c.gray(hline(50)));
+  lines.push(...renderTaskDetail(nextTask, tasks));
+  lines.push("");
+  lines.push(c.gray("  Why this task:"));
+  for (const reason of reasons) {
+    lines.push(`    ${reason}`);
+  }
+  lines.push(...renderImpact(nextTask, tasks));
+  lines.push("");
+  lines.push(c.gray(`  Strategy: ${strategy} - ${STRATEGY_DESCRIPTIONS[strategy]}`));
+  lines.push(...renderAlternatives(strategy));
+  console.log(lines.join(`
+`));
+}
+
+// src/commands/tree.ts
+function buildTree(tasks) {
+  const taskMap = new Map;
+  for (const task of tasks) {
+    taskMap.set(task.id, task);
+  }
+  const nodeMap = new Map;
+  for (const task of tasks) {
+    nodeMap.set(task.id, { task, children: [] });
+  }
+  const roots = [];
+  for (const task of tasks) {
+    const node = nodeMap.get(task.id);
+    if (task.parentId && nodeMap.has(task.parentId)) {
+      const parent = nodeMap.get(task.parentId);
+      parent.children.push(node);
+    } else {
+      roots.push(node);
+    }
+  }
+  const sortNodes = (nodes) => {
+    nodes.sort((a, b) => {
+      const orderA = a.task.sortOrder ?? Infinity;
+      const orderB = b.task.sortOrder ?? Infinity;
+      if (orderA !== orderB)
+        return orderA - orderB;
+      return new Date(a.task.createdAt).getTime() - new Date(b.task.createdAt).getTime();
+    });
+    for (const node of nodes) {
+      sortNodes(node.children);
+    }
+  };
+  sortNodes(roots);
+  return roots;
+}
+function countProgress(node) {
+  let completed = node.task.status === "completed" ? 1 : 0;
+  let total = 1;
+  for (const child of node.children) {
+    const childProgress = countProgress(child);
+    completed += childProgress.completed;
+    total += childProgress.total;
+  }
+  return { completed, total };
+}
+function formatTaskLine2(task, progress) {
+  const status = formatStatusSymbol(task.status);
+  const shortId = c.gray(task.id.slice(-4));
+  const priority = task.priority !== "medium" ? formatPriorityBadge(task.priority) : "";
+  let progressStr = "";
+  if (progress && progress.total > 1) {
+    const childCompleted = progress.completed - (task.status === "completed" ? 1 : 0);
+    const childTotal = progress.total - 1;
+    if (childTotal > 0) {
+      const pct = Math.round(childCompleted / childTotal * 100);
+      progressStr = c.gray(` (${childCompleted}/${childTotal})`);
+      if (pct === 100) {
+        progressStr = c.green(` (${childCompleted}/${childTotal} \u2713)`);
+      }
+    }
+  }
+  if (task.status === "completed" || task.status === "cancelled") {
+    const title2 = c.gray(task.title);
+    return `${status} ${shortId}  ${title2}${progressStr}`;
+  }
+  const title = task.title;
+  return `${status} ${shortId}  ${title}${progressStr}${priority ? "  " + priority : ""}`;
+}
+function renderNode(node, prefix, isLast, isRoot, lines) {
+  const branch = isRoot ? "" : isLast ? "\\-- " : "|-- ";
+  const continuation = isLast ? "    " : "|   ";
+  const progress = node.children.length > 0 ? countProgress(node) : undefined;
+  const taskLine = formatTaskLine2(node.task, progress);
+  lines.push(`${prefix}${branch}${taskLine}`);
+  const childPrefix = isRoot ? prefix : prefix + continuation;
+  const childCount = node.children.length;
+  for (let i = 0;i < childCount; i++) {
+    const child = node.children[i];
+    const childIsLast = i === childCount - 1;
+    renderNode(child, childPrefix, childIsLast, false, lines);
+  }
+}
+function renderTree(roots) {
+  const lines = [];
+  for (const root of roots) {
+    renderNode(root, "", true, true, lines);
+    if (roots.indexOf(root) < roots.length - 1) {
+      lines.push("");
+    }
+  }
+  return lines;
+}
+async function treeCmd(options = {}) {
+  const allTasks = await listTasks();
+  const tasks = options.hideCompleted ? allTasks.filter((t) => t.status !== "completed" && t.status !== "cancelled") : allTasks;
+  if (tasks.length === 0) {
+    console.log(c.yellow("No tasks found."));
+    if (options.hideCompleted) {
+      console.log(c.gray("Use without --hide-completed to include completed tasks."));
+    }
+    return;
+  }
+  const roots = buildTree(tasks);
+  const lines = [];
+  lines.push(c.cyan(c.bold("Task Hierarchy")));
+  lines.push(c.gray(hline(50)));
+  lines.push("");
+  lines.push(...renderTree(roots));
+  lines.push("");
+  lines.push(c.gray(hline(50)));
+  lines.push(c.gray("Legend: [ ] pending  [~] progress  [x] done  [!] blocked"));
+  console.log(lines.join(`
+`));
+}
+
 // src/constants.ts
 var MENU_SEPARATOR_WIDTH = 40;
 var LIST_SEPARATOR_WIDTH = 50;
@@ -250,14 +963,26 @@ Workspaces (${workspaces.length})
 
 // src/interactive.ts
 import * as readline from "readline";
-async function prompt(question) {
+async function prompt(question, options) {
   const rl = readline.createInterface({
     input: process.stdin,
     output: process.stdout
   });
   return new Promise((resolve) => {
-    rl.question(question, (answer) => {
+    let timeoutId;
+    const cleanup = () => {
+      if (timeoutId)
+        clearTimeout(timeoutId);
       rl.close();
+    };
+    if (options?.timeoutMs !== undefined) {
+      timeoutId = setTimeout(() => {
+        cleanup();
+        resolve(options.defaultValue ?? "");
+      }, options.timeoutMs);
+    }
+    rl.question(question, (answer) => {
+      cleanup();
       resolve(answer.trim());
     });
   });
@@ -585,10 +1310,407 @@ async function inboxCountCmd() {
   }
   console.log();
 }
+
+// src/commands/blocked.ts
+function calculateDaysBlocked(task) {
+  const blockedSince = task.updatedAt ?? task.createdAt;
+  const blockedDate = new Date(blockedSince);
+  const now = new Date;
+  const diffMs = now.getTime() - blockedDate.getTime();
+  return Math.floor(diffMs / (1000 * 60 * 60 * 24));
+}
+function getBlockerTasks(task, allTasks) {
+  if (!task.dependencies || task.dependencies.length === 0)
+    return [];
+  const blockers = [];
+  const completedStatuses = new Set(["completed", "cancelled"]);
+  for (const dep of task.dependencies) {
+    const blockerTask = allTasks.find((t) => t.id === dep.taskId);
+    if (blockerTask && !completedStatuses.has(blockerTask.status)) {
+      blockers.push(blockerTask);
+    }
+  }
+  return blockers;
+}
+function getBlockReason(blockers) {
+  if (blockers.length === 0) {
+    return "Unknown (no active blockers found)";
+  }
+  const inProgress = blockers.filter((t) => t.status === "in_progress");
+  const pending = blockers.filter((t) => t.status === "pending");
+  const blocked = blockers.filter((t) => t.status === "blocked");
+  const reasons = [];
+  if (inProgress.length > 0) {
+    reasons.push(`${inProgress.length} in progress`);
+  }
+  if (pending.length > 0) {
+    reasons.push(`${pending.length} pending`);
+  }
+  if (blocked.length > 0) {
+    reasons.push(`${blocked.length} blocked (chain)`);
+  }
+  return `Dependency tasks: ${reasons.join(", ")}`;
+}
+function analyzeBlockedTasks(tasks) {
+  const blockedTasks = tasks.filter((t) => t.status === "blocked");
+  const result = [];
+  for (const task of blockedTasks) {
+    const blockers = getBlockerTasks(task, tasks);
+    const daysBlocked = calculateDaysBlocked(task);
+    const isStale = daysBlocked >= 3;
+    result.push({
+      task,
+      blockers,
+      reason: getBlockReason(blockers),
+      daysBlocked,
+      isStale
+    });
+  }
+  const priorityOrder = { critical: 0, high: 1, medium: 2, low: 3 };
+  result.sort((a, b) => {
+    const pDiff = priorityOrder[a.task.priority] - priorityOrder[b.task.priority];
+    if (pDiff !== 0)
+      return pDiff;
+    return b.daysBlocked - a.daysBlocked;
+  });
+  return result;
+}
+function renderBlockedTask(info) {
+  const lines = [];
+  const { task, blockers, reason, daysBlocked, isStale } = info;
+  const staleIndicator = isStale ? c.red("[!]") : c.yellow("[B]");
+  const taskId = c.gray(task.id.slice(-6));
+  const priority = formatPriorityBadge(task.priority);
+  const title = isStale ? c.red(task.title) : task.title;
+  lines.push(`  ${staleIndicator} ${taskId}  ${title}  ${priority}`);
+  if (blockers.length > 0) {
+    const blockerIds = blockers.map((b) => c.cyan(b.id.slice(-6))).join(", ");
+    lines.push(`      ${c.gray("blocked_by:")} ${blockerIds}`);
+  }
+  lines.push(`      ${c.dim("->")} ${c.dim("Reason:")} ${c.dim(reason)}`);
+  if (isStale) {
+    lines.push(`      ${c.dim("->")} ${c.red(`Blocked for ${daysBlocked} days`)}`);
+  }
+  return lines;
+}
+function renderStaleWarnings(staleItems) {
+  if (staleItems.length === 0)
+    return [];
+  const message = `${staleItems.length} task${staleItems.length > 1 ? "s" : ""} blocked for 3+ days`;
+  return ["", ...renderAlert(message, { severity: "warning" })];
+}
+function renderSummary(totalBlocked, staleCount, byPriority) {
+  const stats = [
+    { label: "Total Blocked", value: totalBlocked, color: "yellow" },
+    { label: "Stale (3+ days)", value: staleCount, color: staleCount > 0 ? "red" : "gray" }
+  ];
+  if (totalBlocked > 0) {
+    if (byPriority.critical > 0) {
+      stats.push({ label: "Critical", value: byPriority.critical, color: "red" });
+    }
+    if (byPriority.high > 0) {
+      stats.push({ label: "High", value: byPriority.high, color: "magenta" });
+    }
+  }
+  return ["", ...renderStats(stats)];
+}
+async function blockedCmd(options = {}) {
+  const tasks = await listTasks();
+  const blockedInfo = analyzeBlockedTasks(tasks);
+  const displayItems = options.stale ? blockedInfo.filter((info) => info.isStale) : blockedInfo;
+  const staleItems = blockedInfo.filter((info) => info.isStale);
+  const byPriority = { critical: 0, high: 0, medium: 0, low: 0 };
+  for (const info of blockedInfo) {
+    byPriority[info.task.priority]++;
+  }
+  const lines = [];
+  const title = options.stale ? "Stale Blocked Tasks" : "Blocked Tasks";
+  lines.push(c.yellow(c.bold(`[!] ${title}`)));
+  lines.push(c.gray(hline(50)));
+  if (displayItems.length === 0) {
+    if (options.stale) {
+      lines.push("");
+      lines.push(c.green("  No stale blocked tasks found."));
+      lines.push(c.gray("  All blocked tasks have been blocked for less than 3 days."));
+    } else {
+      lines.push("");
+      lines.push(c.green("  No blocked tasks found."));
+      lines.push(c.gray("  All tasks are ready to work or completed."));
+    }
+    console.log(lines.join(`
+`));
+    return;
+  }
+  lines.push("");
+  for (const info of displayItems) {
+    lines.push(...renderBlockedTask(info));
+    lines.push("");
+  }
+  if (!options.stale && staleItems.length > 0) {
+    lines.push(...renderStaleWarnings(staleItems));
+  }
+  lines.push(...renderSummary(blockedInfo.length, staleItems.length, byPriority));
+  if (!options.stale && staleItems.length > 0) {
+    lines.push("");
+    lines.push(c.gray("  Tip: Use --stale to show only stale blocked tasks"));
+  }
+  console.log(lines.join(`
+`));
+}
+
+// src/commands/health.ts
+import { detectCircularDependencies, buildDependencyIndices } from "@task-mcp/shared";
+function getOverdueTasks2(tasks) {
+  const today = new Date;
+  today.setHours(0, 0, 0, 0);
+  return tasks.filter((t) => {
+    if (t.status === "completed" || t.status === "cancelled")
+      return false;
+    if (!t.dueDate)
+      return false;
+    const due = new Date(t.dueDate);
+    due.setHours(0, 0, 0, 0);
+    return due < today;
+  });
+}
+function getStaleBlockedTasks2(tasks, staleDays = 3) {
+  const cutoff = Date.now() - staleDays * 24 * 60 * 60 * 1000;
+  return tasks.filter((t) => {
+    if (t.status !== "blocked")
+      return false;
+    const updated = new Date(t.updatedAt).getTime();
+    return updated < cutoff;
+  });
+}
+function findBottlenecks(tasks, limit = 5) {
+  const activeTasks = tasks.filter((t) => t.status !== "completed" && t.status !== "cancelled");
+  const { dependentsIndex } = buildDependencyIndices(activeTasks);
+  const bottlenecks = [];
+  for (const task of activeTasks) {
+    const dependents = dependentsIndex.get(task.id) ?? [];
+    if (dependents.length > 0) {
+      bottlenecks.push({
+        task,
+        blockingCount: dependents.length
+      });
+    }
+  }
+  bottlenecks.sort((a, b) => b.blockingCount - a.blockingCount);
+  return bottlenecks.slice(0, limit);
+}
+function generateRecommendations(tasks, stats, metrics, bottlenecks) {
+  const recommendations = [];
+  const overdueMetric = metrics.find((m) => m.name === "Overdue tasks");
+  if (overdueMetric?.status === "fail") {
+    recommendations.push("Address overdue tasks immediately to prevent further delays");
+  }
+  const staleMetric = metrics.find((m) => m.name === "Stale blocked");
+  if (staleMetric?.status !== "pass") {
+    recommendations.push("Review stale blocked tasks - they may need dependency updates or reassignment");
+  }
+  if (bottlenecks.length > 0 && bottlenecks[0].blockingCount >= 3) {
+    recommendations.push(`Focus on "${bottlenecks[0].task.title}" - it blocks ${bottlenecks[0].blockingCount} other tasks`);
+  }
+  if (stats.completionPercent < 30 && stats.total > 5) {
+    recommendations.push("Completion rate is low. Consider breaking down large tasks or adjusting priorities");
+  }
+  if (stats.blocked > stats.total * 0.3 && stats.total > 3) {
+    recommendations.push("Many tasks are blocked. Review dependency structure for optimization");
+  }
+  if (stats.inProgress === 0 && stats.pending > 0) {
+    recommendations.push("No tasks in progress. Pick up the next available task to maintain momentum");
+  }
+  if (recommendations.length === 0) {
+    recommendations.push("Workspace is in good health. Keep up the good work!");
+  }
+  return recommendations;
+}
+function calculateHealthScore(stats, cycles, overdue, staleBlocked) {
+  let score = 100;
+  if (cycles.length > 0) {
+    score -= 30;
+  }
+  const overdueRatio = stats.total > 0 ? overdue.length / stats.total : 0;
+  score -= Math.min(25, overdueRatio * 100);
+  const staleRatio = stats.total > 0 ? staleBlocked.length / stats.total : 0;
+  score -= Math.min(15, staleRatio * 50);
+  const blockedRatio = stats.total > 0 ? stats.blocked / stats.total : 0;
+  score -= Math.min(15, blockedRatio * 30);
+  if (stats.completionPercent >= 50) {
+    score += 5;
+  }
+  return Math.max(0, Math.min(100, Math.round(score)));
+}
+function analyzeHealth(tasks) {
+  const stats = calculateStats(tasks);
+  const depMetrics = calculateDependencyMetrics(tasks);
+  const cycles = detectCircularDependencies(tasks);
+  const overdue = getOverdueTasks2(tasks);
+  const staleBlocked = getStaleBlockedTasks2(tasks);
+  const bottlenecks = findBottlenecks(tasks);
+  const metrics = [
+    {
+      name: "Completion rate",
+      status: stats.completionPercent >= 50 ? "pass" : stats.completionPercent >= 20 ? "warn" : "fail",
+      value: `${stats.completionPercent}%`,
+      detail: `${stats.completed}/${stats.total - stats.cancelled} tasks`
+    },
+    {
+      name: "No cycles",
+      status: cycles.length === 0 ? "pass" : "fail",
+      value: cycles.length === 0 ? "Clean" : `${cycles.length} found`,
+      detail: cycles.length > 0 ? `Involves: ${cycles[0].join(" -> ")}` : undefined
+    },
+    {
+      name: "Blocked tasks",
+      status: stats.blocked === 0 ? "pass" : stats.blocked <= 2 ? "warn" : "fail",
+      value: `${stats.blocked} tasks`,
+      detail: depMetrics.blockedByDependencies > 0 ? `${depMetrics.blockedByDependencies} waiting on dependencies` : undefined
+    },
+    {
+      name: "Overdue tasks",
+      status: overdue.length === 0 ? "pass" : "fail",
+      value: overdue.length === 0 ? "None" : `${overdue.length} tasks`,
+      detail: overdue.length > 0 ? overdue.map((t) => t.title).slice(0, 2).join(", ") : undefined
+    },
+    {
+      name: "Stale blocked",
+      status: staleBlocked.length === 0 ? "pass" : "warn",
+      value: staleBlocked.length === 0 ? "None" : `${staleBlocked.length} tasks (>3 days)`,
+      detail: staleBlocked.length > 0 ? staleBlocked.map((t) => t.title).slice(0, 2).join(", ") : undefined
+    }
+  ];
+  const score = calculateHealthScore(stats, cycles, overdue, staleBlocked);
+  const recommendations = generateRecommendations(tasks, stats, metrics, bottlenecks);
+  return {
+    score,
+    metrics,
+    bottlenecks,
+    recommendations
+  };
+}
+function getMetricSymbol(status) {
+  switch (status) {
+    case "pass":
+      return c.green("[/]");
+    case "warn":
+      return c.yellow("[!]");
+    case "fail":
+      return c.red("[x]");
+  }
+}
+function renderHealthScore(score, workspace) {
+  const lines = [];
+  let scoreColor;
+  let label;
+  if (score >= 80) {
+    scoreColor = c.green;
+    label = "Excellent";
+  } else if (score >= 60) {
+    scoreColor = c.cyan;
+    label = "Good";
+  } else if (score >= 40) {
+    scoreColor = c.yellow;
+    label = "Fair";
+  } else {
+    scoreColor = c.red;
+    label = "Needs Attention";
+  }
+  lines.push(c.cyan(c.bold("Workspace Health")));
+  lines.push(c.gray(hline(50)));
+  lines.push("");
+  lines.push(`  ${c.gray("Workspace:")}  ${c.bold(workspace)}`);
+  lines.push("");
+  lines.push(`  ${c.gray("Score:")}      ${scoreColor(c.bold(`${score}`))}${c.gray("/100")}  ${c.dim(`(${label})`)}`);
+  lines.push("");
+  lines.push(`  ${progressBar(score, 100, { width: 40, showPercent: false })}`);
+  return lines;
+}
+function renderMetrics(metrics) {
+  const lines = [];
+  lines.push("");
+  lines.push(c.cyan(c.bold("  Health Metrics")));
+  lines.push("");
+  for (const metric of metrics) {
+    const symbol = getMetricSymbol(metric.status);
+    const value = metric.status === "pass" ? c.green(metric.value) : metric.status === "warn" ? c.yellow(metric.value) : c.red(metric.value);
+    lines.push(`  ${symbol} ${metric.name}: ${value}`);
+    if (metric.detail) {
+      lines.push(`      ${c.dim(metric.detail)}`);
+    }
+  }
+  return lines;
+}
+function renderBottlenecks(bottlenecks) {
+  if (bottlenecks.length === 0) {
+    return [];
+  }
+  const items = bottlenecks.map((b) => ({
+    primary: `${c.gray(b.task.id.slice(-4))}  ${b.task.title}`,
+    secondary: c.yellow(`blocks ${b.blockingCount} task${b.blockingCount > 1 ? "s" : ""}`),
+    prefix: formatStatusSymbol(b.task.status)
+  }));
+  return ["", ...renderSection("Bottlenecks", items, { icon: "" })];
+}
+function renderRecommendations(recommendations) {
+  const lines = [];
+  lines.push("");
+  lines.push(c.cyan(c.bold("  Recommendations")));
+  lines.push("");
+  for (const rec of recommendations) {
+    lines.push(`  ${c.dim("-")} ${rec}`);
+  }
+  return lines;
+}
+function renderQuickSummary(score, workspace) {
+  let scoreColor;
+  let label;
+  if (score >= 80) {
+    scoreColor = c.green;
+    label = "Excellent";
+  } else if (score >= 60) {
+    scoreColor = c.cyan;
+    label = "Good";
+  } else if (score >= 40) {
+    scoreColor = c.yellow;
+    label = "Fair";
+  } else {
+    scoreColor = c.red;
+    label = "Needs Attention";
+  }
+  return [
+    `${c.bold(workspace)} health: ${scoreColor(c.bold(`${score}`))}${c.gray("/100")} ${c.dim(`(${label})`)}`,
+    `${progressBar(score, 100, { width: 30, showPercent: false })}`
+  ];
+}
+async function healthCmd(options = {}) {
+  const tasks = await listTasks();
+  const workspace = getCurrentWorkspace();
+  if (tasks.length === 0) {
+    console.log(c.yellow("No tasks found in workspace."));
+    console.log(c.gray(`Workspace: ${workspace}`));
+    return;
+  }
+  const analysis = analyzeHealth(tasks);
+  if (options.quick) {
+    const lines2 = renderQuickSummary(analysis.score, workspace);
+    console.log(lines2.join(`
+`));
+    return;
+  }
+  const lines = [];
+  lines.push(...renderHealthScore(analysis.score, workspace));
+  lines.push(...renderMetrics(analysis.metrics));
+  lines.push(...renderBottlenecks(analysis.bottlenecks));
+  lines.push(...renderRecommendations(analysis.recommendations));
+  lines.push("");
+  console.log(lines.join(`
+`));
+}
 // package.json
 var package_default = {
   name: "@task-mcp/cli",
-  version: "1.0.28",
+  version: "1.0.30",
   description: "Zero-dependency CLI for task-mcp with Bun native visualization",
   type: "module",
   bin: {
@@ -658,7 +1780,7 @@ function parseArgs(argv) {
     }
   }
   return {
-    command: positional[0] ?? "dashboard",
+    command: positional[0] ?? "",
     args: positional.slice(1),
     flags
   };
@@ -672,7 +1794,16 @@ ${c.yellow("USAGE")}
   ${c.bold("task")} [command] [options]
 
 ${c.yellow("COMMANDS")}
-  ${c.cyan("dashboard")} [workspace]    Show workspace dashboard (default)
+  ${c.cyan("(no command)")}             Show smart dashboard (default)
+  ${c.cyan("next")}                     Show suggested next task with details
+  ${c.cyan("n")}                        Alias for next
+  ${c.cyan("blocked")}                  Show blocked tasks and their causes
+  ${c.cyan("b")}                        Alias for blocked
+  ${c.cyan("tree")}                     Show task hierarchy as ASCII tree
+  ${c.cyan("t")}                        Alias for tree
+  ${c.cyan("health")}                   Show workspace health analysis
+  ${c.cyan("h")}                        Alias for health
+  ${c.cyan("dashboard")} [workspace]    Show detailed workspace dashboard
   ${c.cyan("d")} [workspace]            Alias for dashboard
   ${c.cyan("list")}                     List all tasks
   ${c.cyan("ls")}                       Alias for list
@@ -695,8 +1826,11 @@ ${c.yellow("INBOX SUBCOMMANDS")}
 
 ${c.yellow("OPTIONS")}
   ${c.cyan("-i, --interactive")}        Start interactive mode
+  ${c.cyan("--strategy")} <strategy>    Next task strategy (balanced,quick_wins,unblock,critical_path)
   ${c.cyan("--status")} <status>        Filter tasks by status (pending,in_progress,blocked,completed,cancelled)
   ${c.cyan("--priority")} <priority>    Filter tasks by priority (critical,high,medium,low)
+  ${c.cyan("--stale")}                  Show only stale blocked tasks (3+ days)
+  ${c.cyan("--quick")}                  Quick health score only
   ${c.cyan("--all")}                    Include completed/cancelled tasks
 
 ${c.yellow("EXAMPLES")}
@@ -786,10 +1920,37 @@ async function main() {
   }
   try {
     switch (command) {
+      case "":
+        await smartDashboard();
+        break;
       case "dashboard":
       case "d":
         await dashboard(args[0]);
         break;
+      case "next":
+      case "n":
+        await nextCmd({
+          strategy: flags.strategy
+        });
+        break;
+      case "blocked":
+      case "b":
+        await blockedCmd({
+          stale: flags.stale === true
+        });
+        break;
+      case "tree":
+      case "t":
+        await treeCmd({
+          hideCompleted: flags["hide-completed"] === true
+        });
+        break;
+      case "health":
+      case "h":
+        await healthCmd({
+          quick: flags.quick === true
+        });
+        break;
       case "list":
       case "ls":
         await listTasksCmd({

package/package.json

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