@task-mcp/cli 1.0.15 → 1.0.17

package/src/interactive.ts

@@ -7,6 +7,11 @@ import { c, banner } from "./ansi.js";
 import { dashboard } from "./commands/dashboard.js";
 import { listTasksCmd, listProjectsCmd } from "./commands/list.js";
 import * as readline from "node:readline";
+import {
+  MENU_SEPARATOR_WIDTH,
+  ERROR_MESSAGE_DELAY_MS,
+  WELCOME_SCREEN_DELAY_MS,
+} from "./constants.js";
 
 interface MenuOption {
   key: string;
@@ -40,7 +45,7 @@ async function showMenu(title: string, options: MenuOption[]): Promise<void> {
   console.log(banner("TASK MCP"));
   console.log();
   console.log(c.bold(c.cyan(title)));
-  console.log(c.dim("─".repeat(40)));
+  console.log(c.dim("─".repeat(MENU_SEPARATOR_WIDTH)));
   console.log();
 
   for (const opt of options) {
@@ -56,7 +61,7 @@ async function showMenu(title: string, options: MenuOption[]): Promise<void> {
     await selected.action();
   } else if (choice !== "") {
     console.log(c.error(`Invalid option: ${choice}`));
-    await sleep(1000);
+    await sleep(ERROR_MESSAGE_DELAY_MS);
   }
 }
 
@@ -103,22 +108,6 @@ async function mainMenu(): Promise<boolean> {
         await tasksMenu();
       },
     },
-    {
-      key: "a",
-      label: "Analysis",
-      description: "View analysis tools",
-      action: async () => {
-        await analysisMenu();
-      },
-    },
-    {
-      key: "q",
-      label: "Quick Actions",
-      description: "Common quick actions",
-      action: async () => {
-        await quickActionsMenu();
-      },
-    },
     {
       key: "x",
       label: "Exit",
@@ -140,7 +129,7 @@ async function mainMenu(): Promise<boolean> {
 async function dashboardMenu(): Promise<void> {
   console.clear();
   console.log(c.bold(c.cyan("Dashboard")));
-  console.log(c.dim("─".repeat(40)));
+  console.log(c.dim("─".repeat(MENU_SEPARATOR_WIDTH)));
   console.log();
 
   const projectId = await prompt(c.cyan("Project ID (Enter for all): "));
@@ -247,131 +236,6 @@ async function tasksMenu(): Promise<void> {
   await showMenu("Tasks", options);
 }
 
-/**
- * Analysis Menu
- */
-async function analysisMenu(): Promise<void> {
-  const options: MenuOption[] = [
-    {
-      key: "c",
-      label: "Complexity Analysis",
-      description: "View task complexity summary",
-      action: async () => {
-        console.clear();
-        console.log(c.yellow("Complexity Analysis"));
-        console.log(c.dim("Use MCP tools: get_complexity_summary, save_complexity_analysis"));
-        console.log();
-        console.log("Features:");
-        console.log("  - Score 1-10 complexity rating");
-        console.log("  - Factors: state_management, cross_cutting, etc.");
-        console.log("  - Suggested subtask count");
-        console.log();
-        await waitForKey();
-      },
-    },
-    {
-      key: "t",
-      label: "Tech Stack Analysis",
-      description: "View tech areas and risk",
-      action: async () => {
-        console.clear();
-        console.log(c.yellow("Tech Stack Analysis"));
-        console.log(c.dim("Use MCP tools: get_tech_stack_summary, save_tech_stack_analysis"));
-        console.log();
-        console.log("Features:");
-        console.log("  - Areas: schema, backend, frontend, infra, devops, test, docs");
-        console.log("  - Risk levels: low, medium, high, critical");
-        console.log("  - Breaking change detection");
-        console.log();
-        await waitForKey();
-      },
-    },
-    {
-      key: "r",
-      label: "Risk Analysis",
-      description: "Find high-risk tasks",
-      action: async () => {
-        console.clear();
-        console.log(c.yellow("Risk Analysis"));
-        console.log(c.dim("Use MCP tools: find_high_risk_tasks, suggest_safe_order"));
-        console.log();
-        console.log("Features:");
-        console.log("  - Identify high/critical risk tasks");
-        console.log("  - Suggest safe execution order");
-        console.log("  - Phase-based task grouping");
-        console.log();
-        await waitForKey();
-      },
-    },
-    {
-      key: "b",
-      label: "Back to Main Menu",
-      action: () => {},
-    },
-  ];
-
-  await showMenu("Analysis Tools", options);
-}
-
-/**
- * Quick Actions Menu
- */
-async function quickActionsMenu(): Promise<void> {
-  const options: MenuOption[] = [
-    {
-      key: "t",
-      label: "Today's Tasks",
-      action: async () => {
-        console.clear();
-        console.log(c.bold(c.yellow("Today's Tasks")));
-        console.log(c.dim("Use MCP tool: view_today"));
-        console.log();
-        await waitForKey();
-      },
-    },
-    {
-      key: "w",
-      label: "This Week",
-      action: async () => {
-        console.clear();
-        console.log(c.bold(c.yellow("This Week's Tasks")));
-        console.log(c.dim("Use MCP tool: view_this_week"));
-        console.log();
-        await waitForKey();
-      },
-    },
-    {
-      key: "q",
-      label: "Quick Wins",
-      action: async () => {
-        console.clear();
-        console.log(c.bold(c.yellow("Quick Wins")));
-        console.log(c.dim("Use MCP tool: view_quick_wins"));
-        console.log();
-        await waitForKey();
-      },
-    },
-    {
-      key: "n",
-      label: "Next Task Suggestion",
-      action: async () => {
-        console.clear();
-        console.log(c.bold(c.yellow("Next Task Suggestion")));
-        console.log(c.dim("Use MCP tool: suggest_next_task"));
-        console.log();
-        await waitForKey();
-      },
-    },
-    {
-      key: "b",
-      label: "Back to Main Menu",
-      action: () => {},
-    },
-  ];
-
-  await showMenu("Quick Actions", options);
-}
-
 /**
  * Start interactive mode
  */
@@ -382,7 +246,7 @@ export async function startInteractive(): Promise<void> {
   console.log(c.bold("Welcome to Task MCP Interactive Mode"));
   console.log(c.dim("Navigate using keyboard shortcuts"));
   console.log();
-  await sleep(1000);
+  await sleep(WELCOME_SCREEN_DELAY_MS);
 
   while (true) {
     try {

package/src/storage.ts

@@ -1,183 +1,68 @@
 /**
- * Simple file-based storage reader for CLI
- * Reads directly from .tasks/ directory
+ * CLI Storage utilities
+ * Wrapper functions for store access and pure functions for task statistics
  */
 
-import { readdir, readFile } from "node:fs/promises";
-import { join } from "node:path";
+import type { Task, Project, InboxItem } from "@task-mcp/shared";
+import {
+  TaskStore,
+  ProjectStore,
+  InboxStore,
+  StateStore,
+} from "@task-mcp/mcp-server/storage";
 
-export interface ComplexityAnalysis {
-  score?: number;
-  factors?: string[];
-  rationale?: string;
-}
+// Re-export types from shared for consumers of this module
+export type { Task, Project, InboxItem };
 
-export interface TechStackAnalysis {
-  areas?: string[];
-  riskLevel?: "low" | "medium" | "high" | "critical";
-  hasBreakingChange?: boolean;
-  affectedComponents?: string[];
-}
+// Initialize stores
+const taskStore = new TaskStore();
+const projectStore = new ProjectStore();
+const inboxStore = new InboxStore();
+const stateStore = new StateStore();
 
-export interface Task {
-  id: string;
-  title: string;
-  description?: string;
-  status: "pending" | "in_progress" | "blocked" | "completed" | "cancelled";
-  priority: "critical" | "high" | "medium" | "low";
-  projectId: string;
-  parentId?: string;
-  dependencies?: { taskId: string; type: "blocks" | "blocked_by" | "related"; reason?: string }[];
-  dueDate?: string;
-  createdAt: string;
-  updatedAt: string;
-  completedAt?: string;
-  contexts?: string[];
-  tags?: string[];
-  complexity?: ComplexityAnalysis;
-  techStack?: TechStackAnalysis;
-}
-
-export interface Project {
-  id: string;
-  name: string;
-  description?: string;
-  status: "active" | "on_hold" | "completed" | "archived";
-  defaultPriority?: "critical" | "high" | "medium" | "low";
-  createdAt: string;
-  updatedAt: string;
-  targetDate?: string;
-}
-
-export interface TasksFile {
-  version: number;
-  tasks: Task[];
-}
-
-export interface InboxItem {
-  id: string;
-  content: string;
-  status: "pending" | "promoted" | "discarded";
-  source?: string;
-  tags?: string[];
-  capturedAt: string;
-  promotedToTaskId?: string;
-}
-
-export interface InboxFile {
-  version: number;
-  items: InboxItem[];
-}
-
-function getTasksDir(): string {
-  return join(process.cwd(), ".tasks");
-}
-
-/**
- * Validate a project ID format to prevent path traversal attacks.
- * Valid format: proj_[alphanumeric only]
- */
-function isValidProjectId(id: string): boolean {
-  return /^proj_[a-z0-9]+$/.test(id);
-}
-
-async function readJson<T>(path: string): Promise<T | null> {
-  try {
-    const content = await readFile(path, "utf-8");
-    return JSON.parse(content) as T;
-  } catch {
-    return null;
-  }
-}
-
-async function listDirs(path: string): Promise<string[]> {
-  try {
-    const entries = await readdir(path, { withFileTypes: true });
-    return entries.filter(e => e.isDirectory()).map(e => e.name);
-  } catch {
-    return [];
-  }
-}
+// =============================================================================
+// Store Wrapper Functions
+// =============================================================================
 
 /**
  * List all projects
- * Uses Promise.allSettled for parallel I/O with graceful error handling
  */
 export async function listProjects(includeArchived = false): Promise<Project[]> {
-  const projectsDir = join(getTasksDir(), "projects");
-  const projectIds = await listDirs(projectsDir);
-
-  // Use allSettled to handle individual project read failures gracefully
-  const results = await Promise.allSettled(
-    projectIds.map((id) => readJson<Project>(join(projectsDir, id, "project.json")))
-  );
-
-  const projects = results
-    .filter((r): r is PromiseFulfilledResult<Project | null> => r.status === "fulfilled")
-    .map((r) => r.value)
-    .filter(
-      (project): project is Project =>
-        project !== null && (includeArchived || project.status !== "archived")
-    );
-
-  return projects.sort(
-    (a, b) => new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime()
-  );
+  const projects = await projectStore.list();
+  if (includeArchived) {
+    return projects;
+  }
+  return projects.filter((p) => p.status !== "archived");
 }
 
-
 /**
- * List tasks for a project
+ * List tasks for a specific project
  */
 export async function listTasks(projectId: string): Promise<Task[]> {
-  // Validate project ID to prevent path traversal
-  if (!isValidProjectId(projectId)) {
-    console.error(`Invalid project ID format: ${projectId}`);
-    return [];
-  }
-  const path = join(getTasksDir(), "projects", projectId, "tasks.json");
-  const data = await readJson<TasksFile>(path);
-  return data?.tasks ?? [];
+  return taskStore.list(projectId);
 }
 
 /**
- * List inbox items
+ * List all tasks across all projects
  */
-export async function listInboxItems(status?: "pending" | "promoted" | "discarded"): Promise<InboxItem[]> {
-  const path = join(getTasksDir(), "inbox.json");
-  const data = await readJson<InboxFile>(path);
-  const items = data?.items ?? [];
-
-  if (status) {
-    return items.filter(i => i.status === status);
-  }
-  return items;
+export async function listAllTasks(): Promise<Task[]> {
+  return taskStore.listAll();
 }
 
 /**
- * Get pending inbox count
+ * List inbox items by status
  */
-export async function getInboxCount(): Promise<number> {
-  const items = await listInboxItems("pending");
-  return items.length;
+export async function listInboxItems(
+  status?: "pending" | "promoted" | "discarded"
+): Promise<InboxItem[]> {
+  return inboxStore.list({ status });
 }
 
 /**
- * List all tasks across all projects
- * Uses Promise.all for parallel I/O instead of sequential reads
+ * Get the active tag (git branch context)
  */
-export async function listAllTasks(): Promise<Task[]> {
-  const projects = await listProjects(true);
-
-  // Parallel reads instead of sequential for better performance
-  const taskArrays = await Promise.all(
-    projects.map((project) => listTasks(project.id))
-  );
-  const allTasks = taskArrays.flat();
-
-  return allTasks.sort(
-    (a, b) => new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime()
-  );
+export async function getActiveTag(): Promise<string> {
+  return stateStore.getActiveTag();
 }
 
 /**
@@ -320,275 +205,3 @@ export function suggestNextTask(tasks: Task[]): Task | null {
 
   return actionable[0] ?? null;
 }
-
-/**
- * Check if date is today
- */
-function isToday(dateStr: string): boolean {
-  const date = new Date(dateStr);
-  const today = new Date();
-  return date.toDateString() === today.toDateString();
-}
-
-/**
- * Check if date is overdue
- */
-function isOverdue(dateStr: string): boolean {
-  const date = new Date(dateStr);
-  const today = new Date();
-  today.setHours(0, 0, 0, 0);
-  return date < today;
-}
-
-/**
- * Check if date is within N days
- */
-function isWithinDays(dateStr: string, days: number): boolean {
-  const date = new Date(dateStr);
-  const future = new Date();
-  future.setDate(future.getDate() + days);
-  return date <= future;
-}
-
-/**
- * Get tasks due today or overdue
- */
-export function getTodayTasks(tasks: Task[]): Task[] {
-  return tasks.filter(t =>
-    t.status !== "completed" &&
-    t.status !== "cancelled" &&
-    t.dueDate &&
-    (isToday(t.dueDate) || isOverdue(t.dueDate))
-  );
-}
-
-/**
- * Get tasks due this week
- */
-export function getThisWeekTasks(tasks: Task[]): Task[] {
-  return tasks.filter(t =>
-    t.status !== "completed" &&
-    t.status !== "cancelled" &&
-    t.dueDate &&
-    isWithinDays(t.dueDate, 7)
-  );
-}
-
-/**
- * Get overdue tasks
- */
-export function getOverdueTasks(tasks: Task[]): Task[] {
-  return tasks.filter(t =>
-    t.status !== "completed" &&
-    t.status !== "cancelled" &&
-    t.dueDate &&
-    isOverdue(t.dueDate)
-  );
-}
-
-/**
- * Task tree node for hierarchy
- */
-export interface TaskTreeNode {
-  task: Task;
-  children: TaskTreeNode[];
-}
-
-/**
- * Build task hierarchy tree
- */
-export function buildTaskTree(tasks: Task[]): TaskTreeNode[] {
-  const taskMap = new Map(tasks.map(t => [t.id, t]));
-  const childrenMap = new Map<string, Task[]>();
-
-  // Build parent -> children map
-  for (const task of tasks) {
-    if (task.parentId) {
-      const children = childrenMap.get(task.parentId) ?? [];
-      children.push(task);
-      childrenMap.set(task.parentId, children);
-    }
-  }
-
-  function buildNode(task: Task): TaskTreeNode {
-    const children = childrenMap.get(task.id) ?? [];
-    return {
-      task,
-      children: children.map(buildNode),
-    };
-  }
-
-  // Return all root tasks (no parent)
-  const rootTasks = tasks.filter(t => !t.parentId);
-  return rootTasks.map(buildNode);
-}
-
-/**
- * Count total nodes in tree
- */
-export function countTreeNodes(nodes: TaskTreeNode[]): number {
-  return nodes.reduce((sum, n) => sum + 1 + countTreeNodes(n.children), 0);
-}
-
-/**
- * Simple Critical Path calculation
- * Returns tasks that are on the critical path based on dependencies
- */
-export interface CriticalPathResult {
-  criticalPath: Task[];
-  totalDuration: number;
-  bottlenecks: { task: Task; blocksCount: number }[];
-}
-
-/**
- * Calculate complexity and tech stack statistics
- */
-export interface AnalysisStats {
-  complexity: {
-    analyzed: number;
-    avgScore: number;
-    distribution: { low: number; medium: number; high: number };
-    topFactors: { factor: string; count: number }[];
-  };
-  techStack: {
-    analyzed: number;
-    byArea: Record<string, number>;
-    byRisk: { low: number; medium: number; high: number; critical: number };
-    breakingChanges: number;
-  };
-}
-
-export function calculateAnalysisStats(tasks: Task[]): AnalysisStats {
-  const activeTasks = tasks.filter(t =>
-    t.status !== "completed" && t.status !== "cancelled"
-  );
-
-  // Complexity stats
-  const tasksWithComplexity = activeTasks.filter(t => t.complexity?.score);
-  const scores = tasksWithComplexity.map(t => t.complexity!.score!);
-  const avgScore = scores.length > 0
-    ? Math.round((scores.reduce((a, b) => a + b, 0) / scores.length) * 10) / 10
-    : 0;
-
-  const complexityDist = { low: 0, medium: 0, high: 0 };
-  for (const score of scores) {
-    if (score <= 3) complexityDist.low++;
-    else if (score <= 6) complexityDist.medium++;
-    else complexityDist.high++;
-  }
-
-  // Count factors
-  const factorCounts: Record<string, number> = {};
-  for (const t of tasksWithComplexity) {
-    for (const f of t.complexity?.factors ?? []) {
-      factorCounts[f] = (factorCounts[f] ?? 0) + 1;
-    }
-  }
-  const topFactors = Object.entries(factorCounts)
-    .map(([factor, count]) => ({ factor, count }))
-    .sort((a, b) => b.count - a.count)
-    .slice(0, 5);
-
-  // Tech stack stats
-  const tasksWithTech = activeTasks.filter(t => t.techStack?.areas?.length);
-  const byArea: Record<string, number> = {};
-  for (const t of tasksWithTech) {
-    for (const area of t.techStack?.areas ?? []) {
-      byArea[area] = (byArea[area] ?? 0) + 1;
-    }
-  }
-
-  const byRisk = { low: 0, medium: 0, high: 0, critical: 0 };
-  for (const t of tasksWithTech) {
-    const risk = t.techStack?.riskLevel ?? "medium";
-    byRisk[risk]++;
-  }
-
-  const breakingChanges = tasksWithTech.filter(t => t.techStack?.hasBreakingChange).length;
-
-  return {
-    complexity: {
-      analyzed: tasksWithComplexity.length,
-      avgScore,
-      distribution: complexityDist,
-      topFactors,
-    },
-    techStack: {
-      analyzed: tasksWithTech.length,
-      byArea,
-      byRisk,
-      breakingChanges,
-    },
-  };
-}
-
-export function calculateCriticalPath(tasks: Task[]): CriticalPathResult {
-  const activeTasks = tasks.filter(t =>
-    t.status !== "completed" && t.status !== "cancelled"
-  );
-
-  if (activeTasks.length === 0) {
-    return { criticalPath: [], totalDuration: 0, bottlenecks: [] };
-  }
-
-  const taskMap = new Map(activeTasks.map(t => [t.id, t]));
-
-  // Count how many tasks each task blocks
-  const blocksCount: Record<string, number> = {};
-  for (const task of activeTasks) {
-    for (const dep of task.dependencies ?? []) {
-      if (dep.type === "blocked_by") {
-        blocksCount[dep.taskId] = (blocksCount[dep.taskId] ?? 0) + 1;
-      }
-    }
-  }
-
-  // Find bottlenecks (tasks that block the most other tasks)
-  const bottlenecks = Object.entries(blocksCount)
-    .map(([id, count]) => ({ task: taskMap.get(id)!, blocksCount: count }))
-    .filter(b => b.task)
-    .sort((a, b) => b.blocksCount - a.blocksCount)
-    .slice(0, 5);
-
-  // Simple critical path: find longest chain
-  const getDepth = (taskId: string, visited = new Set<string>()): number => {
-    if (visited.has(taskId)) return 0;
-    visited.add(taskId);
-
-    const task = taskMap.get(taskId);
-    if (!task) return 0;
-
-    const deps = task.dependencies?.filter(d => d.type === "blocked_by") ?? [];
-    if (deps.length === 0) return 1;
-
-    let maxDepth = 0;
-    for (const dep of deps) {
-      maxDepth = Math.max(maxDepth, getDepth(dep.taskId, new Set(visited)));
-    }
-    return maxDepth + 1;
-  };
-
-  // Calculate depth for each task and find critical path
-  const tasksWithDepth = activeTasks.map(t => ({
-    task: t,
-    depth: getDepth(t.id),
-  }));
-
-  const maxDepth = Math.max(...tasksWithDepth.map(t => t.depth), 0);
-
-  // Critical path = tasks with maximum depth
-  const criticalPath = tasksWithDepth
-    .filter(t => t.depth === maxDepth)
-    .map(t => t.task)
-    .sort((a, b) => {
-      const aBlocks = blocksCount[a.id] ?? 0;
-      const bBlocks = blocksCount[b.id] ?? 0;
-      return bBlocks - aBlocks;
-    });
-
-  return {
-    criticalPath,
-    totalDuration: maxDepth * 30, // Assume 30 min per task
-    bottlenecks,
-  };
-}