@task-mcp/cli 1.0.4 → 1.0.6

package/src/storage.ts

@@ -6,6 +6,19 @@
 import { readdir, readFile } from "node:fs/promises";
 import { join } from "node:path";
 
+export interface ComplexityAnalysis {
+  score?: number;
+  factors?: string[];
+  rationale?: string;
+}
+
+export interface TechStackAnalysis {
+  areas?: string[];
+  riskLevel?: "low" | "medium" | "high" | "critical";
+  hasBreakingChange?: boolean;
+  affectedComponents?: string[];
+}
+
 export interface Task {
   id: string;
   title: string;
@@ -13,6 +26,7 @@ export interface Task {
   status: "pending" | "in_progress" | "blocked" | "completed" | "cancelled";
   priority: "critical" | "high" | "medium" | "low";
   projectId: string;
+  parentId?: string;
   dependencies?: { taskId: string; type: string; reason?: string }[];
   dueDate?: string;
   createdAt: string;
@@ -20,6 +34,8 @@ export interface Task {
   completedAt?: string;
   contexts?: string[];
   tags?: string[];
+  complexity?: ComplexityAnalysis;
+  techStack?: TechStackAnalysis;
 }
 
 export interface Project {
@@ -38,17 +54,31 @@ export interface TasksFile {
   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");
 }
 
-async function fileExists(path: string): Promise<boolean> {
-  try {
-    await readFile(path);
-    return true;
-  } catch {
-    return false;
-  }
+/**
+ * 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> {
@@ -71,54 +101,79 @@ async function listDirs(path: string): Promise<string[]> {
 
 /**
  * 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);
 
-  const projects: Project[] = [];
-  for (const id of projectIds) {
-    const project = await readJson<Project>(join(projectsDir, id, "project.json"));
-    if (project) {
-      if (includeArchived || project.status !== "archived") {
-        projects.push(project);
-      }
-    }
-  }
+  // 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()
   );
 }
 
-/**
- * Get a project by ID
- */
-export async function getProject(projectId: string): Promise<Project | null> {
-  const path = join(getTasksDir(), "projects", projectId, "project.json");
-  return readJson<Project>(path);
-}
 
 /**
  * List tasks for a 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 ?? [];
 }
 
+/**
+ * List inbox items
+ */
+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;
+}
+
+/**
+ * Get pending inbox count
+ */
+export async function getInboxCount(): Promise<number> {
+  const items = await listInboxItems("pending");
+  return items.length;
+}
+
 /**
  * List all tasks across all projects
+ * Uses Promise.all for parallel I/O instead of sequential reads
  */
 export async function listAllTasks(): Promise<Task[]> {
   const projects = await listProjects(true);
-  const allTasks: Task[] = [];
 
-  for (const project of projects) {
-    const tasks = await listTasks(project.id);
-    allTasks.push(...tasks);
-  }
+  // 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()
@@ -265,3 +320,275 @@ 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,
+  };
+}