@task-mcp/shared 1.0.22 → 1.0.23

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@task-mcp/shared",
-  "version": "1.0.22",
+  "version": "1.0.23",
   "description": "Shared utilities for task-mcp: types, algorithms, and natural language parsing",
   "type": "module",
   "main": "./dist/index.js",

package/src/algorithms/critical-path.ts

@@ -1,9 +1,5 @@
 import type { Task } from "../schemas/task.js";
-import {
-  topologicalSort,
-  findDependents,
-  priorityToNumber,
-} from "./topological-sort.js";
+import { topologicalSort, priorityToNumber } from "./topological-sort.js";
 
 /**
  * Task with computed CPM (Critical Path Method) values
@@ -43,9 +39,7 @@ function getTaskDuration(task: Task): number {
  * Get blocked_by dependencies for a task
  */
 function getBlockedByDeps(task: Task): string[] {
-  return (task.dependencies ?? [])
-    .filter((d) => d.type === "blocked_by")
-    .map((d) => d.taskId);
+  return (task.dependencies ?? []).filter((d) => d.type === "blocked_by").map((d) => d.taskId);
 }
 
 /**
@@ -110,7 +104,10 @@ function calculateProjectDuration(taskMap: Map<string, CPMTask>): number {
  * This is O(n * d) where d is average dependencies, done once upfront
  * Allows O(1) successor lookup instead of O(n) per task
  */
-function buildSuccessorIndex(sortedTasks: Task[], taskMap: Map<string, CPMTask>): Map<string, CPMTask[]> {
+function buildSuccessorIndex(
+  sortedTasks: Task[],
+  taskMap: Map<string, CPMTask>
+): Map<string, CPMTask[]> {
   const successorIndex = new Map<string, CPMTask[]>();
 
   // Initialize empty arrays for all tasks
@@ -244,9 +241,7 @@ function extractCriticalPath(sortedTasks: Task[], taskMap: Map<string, CPMTask>)
  * Find top bottlenecks (critical tasks blocking the most downstream work)
  */
 function findBottlenecks(criticalPath: CPMTask[], limit = 5): CPMTask[] {
-  return [...criticalPath]
-    .sort((a, b) => b.dependentCount - a.dependentCount)
-    .slice(0, limit);
+  return [...criticalPath].sort((a, b) => b.dependentCount - a.dependentCount).slice(0, limit);
 }
 
 /**
@@ -262,9 +257,7 @@ function findBottlenecks(criticalPath: CPMTask[], limit = 5): CPMTask[] {
  */
 export function criticalPathAnalysis(tasks: Task[]): CPMResult {
   // Filter to only pending/in_progress tasks
-  const activeTasks = tasks.filter(
-    (t) => t.status === "pending" || t.status === "in_progress"
-  );
+  const activeTasks = tasks.filter((t) => t.status === "pending" || t.status === "in_progress");
 
   if (activeTasks.length === 0) {
     return {
@@ -318,16 +311,12 @@ export function criticalPathAnalysis(tasks: Task[]): CPMResult {
  * Optimized to O(n + e) where n = number of tasks, e = number of dependencies
  */
 export function findParallelTasks(tasks: Task[]): Task[][] {
-  const activeTasks = tasks.filter(
-    (t) => t.status === "pending" || t.status === "in_progress"
-  );
+  const activeTasks = tasks.filter((t) => t.status === "pending" || t.status === "in_progress");
 
   if (activeTasks.length === 0) return [];
 
   // Find tasks with no uncompleted dependencies
-  const completedIds = new Set(
-    tasks.filter((t) => t.status === "completed").map((t) => t.id)
-  );
+  const completedIds = new Set(tasks.filter((t) => t.status === "completed").map((t) => t.id));
 
   const available = activeTasks.filter((task) => {
     const deps = getBlockedByDeps(task);
@@ -376,9 +365,7 @@ export function findParallelTasks(tasks: Task[]): Task[][] {
       if (processed.has(other.id)) continue;
 
       // O(1) check: tasks are independent if neither depends on the other
-      const independent =
-        !conflicting.has(other.id) &&
-        !dependsOn.get(other.id)?.has(task.id);
+      const independent = !conflicting.has(other.id) && !dependsOn.get(other.id)?.has(task.id);
 
       if (independent) {
         group.push(other);
@@ -402,9 +389,7 @@ export function suggestNextTask(
     maxMinutes?: number;
   } = {}
 ): Task | null {
-  const activeTasks = tasks.filter(
-    (t) => t.status === "pending" || t.status === "in_progress"
-  );
+  const activeTasks = tasks.filter((t) => t.status === "pending" || t.status === "in_progress");
 
   if (activeTasks.length === 0) return null;
 
@@ -412,9 +397,7 @@ export function suggestNextTask(
   const cpm = criticalPathAnalysis(tasks);
 
   // Filter by availability (all dependencies completed)
-  const completedIds = new Set(
-    tasks.filter((t) => t.status === "completed").map((t) => t.id)
-  );
+  const completedIds = new Set(tasks.filter((t) => t.status === "completed").map((t) => t.id));
 
   let candidates = cpm.tasks.filter((task) => {
     const deps = getBlockedByDeps(task);
@@ -434,9 +417,7 @@ export function suggestNextTask(
 
   // Filter by time if specified
   if (options.maxMinutes) {
-    const timeFiltered = candidates.filter(
-      (t) => getTaskDuration(t) <= options.maxMinutes!
-    );
+    const timeFiltered = candidates.filter((t) => getTaskDuration(t) <= options.maxMinutes!);
     if (timeFiltered.length > 0) {
       candidates = timeFiltered;
     }
@@ -459,4 +440,3 @@ export function suggestNextTask(
   scored.sort((a, b) => b.score - a.score);
   return scored[0]?.task ?? null;
 }
-

package/src/algorithms/dependency-integrity.ts

@@ -35,9 +35,7 @@ export interface ValidateDependencyOptions {
 /**
  * Validates if a dependency can be added between two tasks
  */
-export function validateDependency(
-  options: ValidateDependencyOptions
-): DependencyValidationResult {
+export function validateDependency(options: ValidateDependencyOptions): DependencyValidationResult {
   const { taskId, blockedBy, tasks, checkDuplicates = true } = options;
 
   // 1. Self-dependency check
@@ -117,9 +115,7 @@ export interface InvalidDependencyReference {
 /**
  * Find all invalid dependency references (orphaned references)
  */
-export function findInvalidDependencies(
-  tasks: Task[]
-): InvalidDependencyReference[] {
+export function findInvalidDependencies(tasks: Task[]): InvalidDependencyReference[] {
   const taskIds = new Set(tasks.map((t) => t.id));
   const invalid: InvalidDependencyReference[] = [];
 
@@ -242,17 +238,12 @@ export interface DependencyIntegrityReport {
 /**
  * Check overall dependency integrity of a project
  */
-export function checkDependencyIntegrity(
-  tasks: Task[]
-): DependencyIntegrityReport {
+export function checkDependencyIntegrity(tasks: Task[]): DependencyIntegrityReport {
   const selfDeps = findSelfDependencies(tasks);
   const invalidRefs = findInvalidDependencies(tasks);
   const cycles = detectCircularDependencies(tasks);
 
-  const totalDependencies = tasks.reduce(
-    (sum, t) => sum + (t.dependencies?.length ?? 0),
-    0
-  );
+  const totalDependencies = tasks.reduce((sum, t) => sum + (t.dependencies?.length ?? 0), 0);
 
   const issueCount = selfDeps.length + invalidRefs.length + cycles.length;
   const valid = issueCount === 0;

package/src/algorithms/tech-analysis.ts

@@ -5,14 +5,14 @@ import type { Task, TechArea, RiskLevel } from "../schemas/task.js";
  * Based on dependency flow: DB changes → Infrastructure → Backend → Frontend → Tests
  */
 const TECH_ORDER: Record<TechArea, number> = {
-  schema: 0,    // DB/schema changes first
-  infra: 0,     // Infrastructure setup
-  devops: 1,    // CI/CD pipelines
-  backend: 2,   // API/server
-  frontend: 3,  // UI
-  test: 4,      // Tests
-  docs: 4,      // Documentation
-  refactor: 5,  // Refactoring last
+  schema: 0, // DB/schema changes first
+  infra: 0, // Infrastructure setup
+  devops: 1, // CI/CD pipelines
+  backend: 2, // API/server
+  frontend: 3, // UI
+  test: 4, // Tests
+  docs: 4, // Documentation
+  refactor: 5, // Refactoring last
 };
 
 /**
@@ -143,9 +143,7 @@ function hasBreakingChange(task: Task): boolean {
  */
 export function suggestSafeOrder(tasks: Task[]): SafeOrderResult {
   // Filter to active tasks only
-  const activeTasks = tasks.filter(
-    (t) => t.status === "pending" || t.status === "in_progress"
-  );
+  const activeTasks = tasks.filter((t) => t.status === "pending" || t.status === "in_progress");
 
   if (activeTasks.length === 0) {
     return {
@@ -175,7 +173,10 @@ export function suggestSafeOrder(tasks: Task[]): SafeOrderResult {
     if (aBreaking !== bBreaking) return aBreaking - bBreaking;
 
     // 4. Priority as tiebreaker (higher priority first)
-    return (PRIORITY_ORDER[a.priority] ?? DEFAULT_PRIORITY_ORDER) - (PRIORITY_ORDER[b.priority] ?? DEFAULT_PRIORITY_ORDER);
+    return (
+      (PRIORITY_ORDER[a.priority] ?? DEFAULT_PRIORITY_ORDER) -
+      (PRIORITY_ORDER[b.priority] ?? DEFAULT_PRIORITY_ORDER)
+    );
   });
 
   // Group into phases by tech level
@@ -258,9 +259,7 @@ function getPrimaryArea(task: Task): TechArea | "mixed" {
  */
 export function findBreakingChanges(tasks: Task[]): Task[] {
   return tasks.filter(
-    (t) =>
-      (t.status === "pending" || t.status === "in_progress") &&
-      hasBreakingChange(t)
+    (t) => (t.status === "pending" || t.status === "in_progress") && hasBreakingChange(t)
   );
 }
 
@@ -284,16 +283,21 @@ export function groupByTechArea(tasks: Task[]): Map<TechArea, Task[]> {
 
   // Initialize all groups
   const allAreas: TechArea[] = [
-    "schema", "infra", "devops", "backend", "frontend", "test", "docs", "refactor"
+    "schema",
+    "infra",
+    "devops",
+    "backend",
+    "frontend",
+    "test",
+    "docs",
+    "refactor",
   ];
   for (const area of allAreas) {
     groups.set(area, []);
   }
 
   // Group active tasks
-  const activeTasks = tasks.filter(
-    (t) => t.status === "pending" || t.status === "in_progress"
-  );
+  const activeTasks = tasks.filter((t) => t.status === "pending" || t.status === "in_progress");
 
   for (const task of activeTasks) {
     const areas = task.techStack?.areas ?? [];
@@ -314,9 +318,9 @@ export function groupByTechArea(tasks: Task[]): Map<TechArea, Task[]> {
  * Complexity distribution by level
  */
 export interface ComplexityDistribution {
-  low: number;    // 1 to LOW_MAX
+  low: number; // 1 to LOW_MAX
   medium: number; // LOW_MAX+1 to MEDIUM_MAX
-  high: number;   // MEDIUM_MAX+1 to 10
+  high: number; // MEDIUM_MAX+1 to 10
 }
 
 /**
@@ -337,9 +341,7 @@ export interface ComplexitySummary {
  * Analyze complexity distribution across tasks
  */
 export function getComplexitySummary(tasks: Task[]): ComplexitySummary {
-  const activeTasks = tasks.filter(
-    (t) => t.status === "pending" || t.status === "in_progress"
-  );
+  const activeTasks = tasks.filter((t) => t.status === "pending" || t.status === "in_progress");
 
   const analyzed = activeTasks.filter((t) => t.complexity?.score !== undefined);
   const unanalyzed = activeTasks.filter((t) => t.complexity?.score === undefined);
@@ -394,9 +396,7 @@ export interface TechStackSummary {
  * Analyze tech stack distribution across tasks
  */
 export function getTechStackSummary(tasks: Task[]): TechStackSummary {
-  const activeTasks = tasks.filter(
-    (t) => t.status === "pending" || t.status === "in_progress"
-  );
+  const activeTasks = tasks.filter((t) => t.status === "pending" || t.status === "in_progress");
 
   const analyzed = activeTasks.filter((t) => t.techStack?.areas !== undefined);
   const unanalyzed = activeTasks.filter((t) => t.techStack?.areas === undefined);

package/src/algorithms/topological-sort.ts

@@ -115,20 +115,13 @@ export function topologicalSort(tasks: Task[]): Task[] {
 /**
  * Detect if adding a dependency would create a cycle
  */
-export function wouldCreateCycle(
-  tasks: Task[],
-  fromId: string,
-  toId: string
-): boolean {
+export function wouldCreateCycle(tasks: Task[], fromId: string, toId: string): boolean {
   // Create a temporary task list with the new dependency
   const tempTasks = tasks.map((t) => {
     if (t.id === fromId) {
       return {
         ...t,
-        dependencies: [
-          ...(t.dependencies ?? []),
-          { taskId: toId, type: "blocked_by" as const },
-        ],
+        dependencies: [...(t.dependencies ?? []), { taskId: toId, type: "blocked_by" as const }],
       };
     }
     return t;
@@ -173,7 +166,10 @@ export function buildDependencyIndices(tasks: Task[]): {
       .map((d) => d.taskId);
 
     // Store direct dependencies for this task
-    dependenciesIndex.set(task.id, deps.filter((depId) => taskMap.has(depId)));
+    dependenciesIndex.set(
+      task.id,
+      deps.filter((depId) => taskMap.has(depId))
+    );
 
     // Update dependents index (reverse lookup)
     for (const depId of deps) {

package/src/schemas/index.ts

@@ -19,21 +19,10 @@ export {
 } from "./task.js";
 
 // View schemas
-export {
-  SmartViewFilter,
-  SortField,
-  SortOrder,
-  SmartView,
-  BuiltInView,
-} from "./view.js";
+export { SmartViewFilter, SortField, SortOrder, SmartView, BuiltInView } from "./view.js";
 
 // Inbox schemas
-export {
-  InboxStatus,
-  InboxItem,
-  InboxCreateInput,
-  InboxUpdateInput,
-} from "./inbox.js";
+export { InboxStatus, InboxItem, InboxCreateInput, InboxUpdateInput } from "./inbox.js";
 
 // Response format schemas (token optimization)
 export {

package/src/schemas/response-format.ts

@@ -129,9 +129,9 @@ export interface DashboardPriorityBreakdown {
 
 // Dependency metrics
 export interface DashboardDependencyMetrics {
-  ready: number;    // No dependencies or all satisfied
-  blocked: number;  // Has unsatisfied dependencies
-  noDeps: number;   // Tasks with no dependencies
+  ready: number; // No dependencies or all satisfied
+  blocked: number; // Has unsatisfied dependencies
+  noDeps: number; // Tasks with no dependencies
 }
 
 // Next task recommendation
@@ -139,12 +139,12 @@ export interface DashboardNextTask {
   id: string;
   title: string;
   priority: string;
-  reason: string;   // Why this task is recommended
+  reason: string; // Why this task is recommended
 }
 
 // Critical path info
 export interface DashboardCriticalPath {
-  length: number;    // Total duration in minutes
+  length: number; // Total duration in minutes
   taskCount: number; // Number of tasks on critical path
 }
 
@@ -162,7 +162,7 @@ export interface DashboardStatusBreakdown {
 export interface DashboardSubtaskProgress {
   completed: number;
   total: number;
-  pct: number;       // 0-100
+  pct: number; // 0-100
   inProgress: number;
   pending: number;
   blocked: number;

package/src/schemas/response-schema.ts

@@ -28,26 +28,27 @@ const BaseResponse = z.object({
   type: ResponseType.describe("Type of response: question, suggestion, or confirmation"),
   message: z.string().describe("Main message to display to user"),
   context: z.string().optional().describe("Additional context or explanation"),
-  priority: ResponsePriority.optional().describe("Urgency/importance of response (default: medium)"),
+  priority: ResponsePriority.optional().describe(
+    "Urgency/importance of response (default: medium)"
+  ),
 });
 
 // Question response - for clarification
 export const QuestionResponse = BaseResponse.extend({
   type: z.literal("question"),
-  options: z.array(ResponseOption).optional()
+  options: z
+    .array(ResponseOption)
+    .optional()
     .describe("Multiple choice options (omit for free-form answer)"),
-  defaultOption: z.string().optional()
-    .describe("Default option value if user provides no input"),
+  defaultOption: z.string().optional().describe("Default option value if user provides no input"),
 });
 export type QuestionResponse = z.infer<typeof QuestionResponse>;
 
 // Suggestion response - for recommendations
 export const SuggestionResponse = BaseResponse.extend({
   type: z.literal("suggestion"),
-  options: z.array(ResponseOption).min(1)
-    .describe("Suggested options for user to choose from"),
-  reasoning: z.string().optional()
-    .describe("Explanation of why these suggestions were made"),
+  options: z.array(ResponseOption).min(1).describe("Suggested options for user to choose from"),
+  reasoning: z.string().optional().describe("Explanation of why these suggestions were made"),
 });
 export type SuggestionResponse = z.infer<typeof SuggestionResponse>;
 
@@ -55,9 +56,13 @@ export type SuggestionResponse = z.infer<typeof SuggestionResponse>;
 export const ConfirmationResponse = BaseResponse.extend({
   type: z.literal("confirmation"),
   action: z.string().describe("Action that will be taken if confirmed"),
-  consequences: z.array(z.string()).optional()
+  consequences: z
+    .array(z.string())
+    .optional()
     .describe("List of effects or changes that will occur"),
-  defaultConfirm: z.boolean().optional()
+  defaultConfirm: z
+    .boolean()
+    .optional()
     .describe("Default choice if user provides no input (default: false)"),
 });
 export type ConfirmationResponse = z.infer<typeof ConfirmationResponse>;
@@ -74,19 +79,19 @@ export type AgentResponse = z.infer<typeof AgentResponse>;
 export const GenerateResponseInput = z.object({
   type: ResponseType.describe("Type of response to generate"),
   message: z.string().describe("Main message"),
-  options: z.array(ResponseOption).optional()
-    .describe("Options for question/suggestion types"),
+  options: z.array(ResponseOption).optional().describe("Options for question/suggestion types"),
   context: z.string().optional(),
   priority: ResponsePriority.optional().default("medium"),
-  action: z.string().optional()
-    .describe("Action description (for confirmation type)"),
-  consequences: z.array(z.string()).optional()
+  action: z.string().optional().describe("Action description (for confirmation type)"),
+  consequences: z
+    .array(z.string())
+    .optional()
     .describe("Consequences list (for confirmation type)"),
-  reasoning: z.string().optional()
-    .describe("Reasoning explanation (for suggestion type)"),
-  defaultOption: z.string().optional()
-    .describe("Default option value (for question type)"),
-  defaultConfirm: z.boolean().optional()
+  reasoning: z.string().optional().describe("Reasoning explanation (for suggestion type)"),
+  defaultOption: z.string().optional().describe("Default option value (for question type)"),
+  defaultConfirm: z
+    .boolean()
+    .optional()
     .describe("Default confirmation choice (for confirmation type)"),
 });
 export type GenerateResponseInput = z.infer<typeof GenerateResponseInput>;

package/src/schemas/task.ts

@@ -5,13 +5,7 @@ export const Priority = z.enum(["critical", "high", "medium", "low"]);
 export type Priority = z.infer<typeof Priority>;
 
 // Task status with clear state machine
-export const TaskStatus = z.enum([
-  "pending",
-  "in_progress",
-  "blocked",
-  "completed",
-  "cancelled",
-]);
+export const TaskStatus = z.enum(["pending", "in_progress", "blocked", "completed", "cancelled"]);
 export type TaskStatus = z.infer<typeof TaskStatus>;
 
 // Dependency relationship types
@@ -37,25 +31,13 @@ export const TimeEstimate = z
   .refine(
     (data) => {
       const { optimistic, expected, pessimistic } = data;
-      if (
-        optimistic !== undefined &&
-        expected !== undefined &&
-        optimistic > expected
-      ) {
+      if (optimistic !== undefined && expected !== undefined && optimistic > expected) {
         return false;
       }
-      if (
-        expected !== undefined &&
-        pessimistic !== undefined &&
-        expected > pessimistic
-      ) {
+      if (expected !== undefined && pessimistic !== undefined && expected > pessimistic) {
         return false;
       }
-      if (
-        optimistic !== undefined &&
-        pessimistic !== undefined &&
-        optimistic > pessimistic
-      ) {
+      if (optimistic !== undefined && pessimistic !== undefined && optimistic > pessimistic) {
         return false;
       }
       return true;

package/src/utils/dashboard-renderer.ts

@@ -41,11 +41,13 @@ export interface DashboardStats {
 export interface DependencyMetrics {
   readyToWork: number;
   blockedByDependencies: number;
-  mostDependedOn?: {
-    id: string;
-    title: string;
-    dependentCount: number;
-  } | undefined;
+  mostDependedOn?:
+    | {
+        id: string;
+        title: string;
+        dependentCount: number;
+      }
+    | undefined;
 }
 
 export interface WorkspaceInfo {
@@ -107,9 +109,7 @@ export function calculateStats(tasks: Task[]): DashboardStats {
 }
 
 export function calculateDependencyMetrics(tasks: Task[]): DependencyMetrics {
-  const completedIds = new Set(
-    tasks.filter((t) => t.status === "completed").map((t) => t.id)
-  );
+  const completedIds = new Set(tasks.filter((t) => t.status === "completed").map((t) => t.id));
 
   let readyToWork = 0;
   let blockedByDependencies = 0;
@@ -134,10 +134,7 @@ export function calculateDependencyMetrics(tasks: Task[]): DependencyMetrics {
 
     // Track dependent counts
     for (const dep of deps) {
-      dependentCounts.set(
-        dep.taskId,
-        (dependentCounts.get(dep.taskId) ?? 0) + 1
-      );
+      dependentCounts.set(dep.taskId, (dependentCounts.get(dep.taskId) ?? 0) + 1);
     }
   }
 
@@ -192,8 +189,7 @@ export function renderStatusWidget(tasks: Task[]): string {
   const today = getTodayTasks(tasks);
   const overdue = getOverdueTasks(tasks);
   const activeTasks = stats.total - stats.cancelled;
-  const percent =
-    activeTasks > 0 ? Math.round((stats.completed / activeTasks) * 100) : 0;
+  const percent = activeTasks > 0 ? Math.round((stats.completed / activeTasks) * 100) : 0;
 
   const lines: string[] = [];
 
@@ -252,16 +248,10 @@ export function renderActionsWidget(tasks: Task[]): string {
 
   // Get top 4 ready tasks sorted by priority
   const readyTasks = tasks
-    .filter(
-      (t) =>
-        t.status === "pending" &&
-        (!t.dependencies || t.dependencies.length === 0)
-    )
+    .filter((t) => t.status === "pending" && (!t.dependencies || t.dependencies.length === 0))
     .sort((a, b) => {
       const priorityOrder = { critical: 0, high: 1, medium: 2, low: 3 };
-      return (
-        (priorityOrder[a.priority] ?? 2) - (priorityOrder[b.priority] ?? 2)
-      );
+      return (priorityOrder[a.priority] ?? 2) - (priorityOrder[b.priority] ?? 2);
     })
     .slice(0, 4);
 
@@ -341,17 +331,13 @@ export function renderWorkspacesTable(
     const stats = calculateStats(tasks);
     const depMetrics = calculateDependencyMetrics(tasks);
     const activeTasks = stats.total - stats.cancelled;
-    const percent =
-      activeTasks > 0
-        ? Math.round((stats.completed / activeTasks) * 100)
-        : 0;
+    const percent = activeTasks > 0 ? Math.round((stats.completed / activeTasks) * 100) : 0;
 
     // Create mini progress bar
     const barWidth = 8;
     const filled = Math.round((percent / 100) * barWidth);
     const empty = barWidth - filled;
-    const miniBar =
-      c.green("█".repeat(filled)) + c.gray("░".repeat(empty));
+    const miniBar = c.green("█".repeat(filled)) + c.gray("░".repeat(empty));
 
     rows.push({
       name: truncateStr(ws.name, 20),
@@ -392,9 +378,7 @@ export const renderProjectsTable = renderWorkspacesTable;
  * Render Tasks table for single workspace view
  */
 export function renderTasksTable(tasks: Task[], limit: number = 10): string {
-  const activeTasks = tasks.filter(
-    (t) => t.status !== "completed" && t.status !== "cancelled"
-  );
+  const activeTasks = tasks.filter((t) => t.status !== "completed" && t.status !== "cancelled");
 
   if (activeTasks.length === 0) {
     return c.gray("No active tasks.");
@@ -421,10 +405,7 @@ export function renderTasksTable(tasks: Task[], limit: number = 10): string {
     },
   ];
 
-  let result = table(
-    displayTasks as unknown as Record<string, unknown>[],
-    columns
-  );
+  let result = table(displayTasks as unknown as Record<string, unknown>[], columns);
 
   if (activeTasks.length > limit) {
     result += `\n${c.gray(`(+${activeTasks.length - limit} more tasks)`)}`;
@@ -440,21 +421,14 @@ export function renderTasksTable(tasks: Task[], limit: number = 10): string {
 function getTodayTasks(tasks: Task[]): Task[] {
   const today = new Date().toISOString().split("T")[0];
   return tasks.filter(
-    (t) =>
-      t.dueDate === today &&
-      t.status !== "completed" &&
-      t.status !== "cancelled"
+    (t) => t.dueDate === today && t.status !== "completed" && t.status !== "cancelled"
   );
 }
 
 function getOverdueTasks(tasks: Task[]): Task[] {
   const today = new Date().toISOString().split("T")[0] ?? "";
   return tasks.filter(
-    (t) =>
-      t.dueDate &&
-      t.dueDate < today &&
-      t.status !== "completed" &&
-      t.status !== "cancelled"
+    (t) => t.dueDate && t.dueDate < today && t.status !== "completed" && t.status !== "cancelled"
   );
 }
 
@@ -538,9 +512,7 @@ export function renderDashboard(
 
   // Tasks table (for single workspace view)
   if (showTasks && (currentWorkspace || workspaces.length === 1)) {
-    const activeTasks = tasks.filter(
-      (t) => t.status !== "completed" && t.status !== "cancelled"
-    );
+    const activeTasks = tasks.filter((t) => t.status !== "completed" && t.status !== "cancelled");
     if (activeTasks.length > 0) {
       lines.push(c.bold(`Tasks (${activeTasks.length})`));
       lines.push("");
@@ -565,7 +537,7 @@ export function renderWorkspaceDashboard(
   const wsInfo: WorkspaceInfo = {
     name: workspace,
     taskCount: tasks.length,
-    completedCount: tasks.filter(t => t.status === "completed").length,
+    completedCount: tasks.filter((t) => t.status === "completed").length,
   };
 
   const data: DashboardData = {
@@ -576,17 +548,13 @@ export function renderWorkspaceDashboard(
     activeTag: options.activeTag,
   };
 
-  return renderDashboard(
-    data,
-    () => tasks,
-    {
-      showBanner: true,
-      showInbox: false,
-      showWorkspaces: false,
-      showTasks: true,
-      stripAnsiCodes: options.stripAnsiCodes,
-    }
-  );
+  return renderDashboard(data, () => tasks, {
+    showBanner: true,
+    showInbox: false,
+    showWorkspaces: false,
+    showTasks: true,
+    stripAnsiCodes: options.stripAnsiCodes,
+  });
 }
 
 // Legacy export for backwards compatibility

package/src/utils/date.ts

@@ -247,11 +247,7 @@ export function parseDateString(input: string): Date {
 
   const d = new Date(input);
   if (isNaN(d.getTime())) {
-    throw new DateParseError(
-      `Unable to parse "${input}" as a date`,
-      input,
-      "invalid_format"
-    );
+    throw new DateParseError(`Unable to parse "${input}" as a date`, input, "invalid_format");
   }
 
   return d;
@@ -280,11 +276,7 @@ export function formatDisplayDate(date: Date | string): string {
   }
 
   if (!isValidDate(d)) {
-    throw new DateParseError(
-      "Invalid Date object provided",
-      String(date),
-      "invalid_date"
-    );
+    throw new DateParseError("Invalid Date object provided", String(date), "invalid_date");
   }
 
   const parts = new Intl.DateTimeFormat(undefined, {

package/src/utils/hierarchy.ts

@@ -34,7 +34,9 @@ export function getTaskLevel(tasks: Task[], taskId: string): number {
   while (currentTask.parentId) {
     const parent = taskMap.get(currentTask.parentId);
     if (!parent) {
-      console.warn(`[task-mcp] Orphaned parent reference: task "${currentTask.id}" references non-existent parent "${currentTask.parentId}"`);
+      console.warn(
+        `[task-mcp] Orphaned parent reference: task "${currentTask.id}" references non-existent parent "${currentTask.parentId}"`
+      );
       break;
     }
     level++;
@@ -57,10 +59,7 @@ export function getTaskLevel(tasks: Task[], taskId: string): number {
  * @param parentId - ID of the proposed parent task
  * @returns true if a child can be added, false if it would exceed max depth
  */
-export function validateHierarchyDepth(
-  tasks: Task[],
-  parentId: string
-): boolean {
+export function validateHierarchyDepth(tasks: Task[], parentId: string): boolean {
   const parentLevel = getTaskLevel(tasks, parentId);
 
   if (parentLevel === -1) {

package/src/utils/index.ts

@@ -31,7 +31,13 @@ export {
   type DateParseResult,
   type IsWithinDaysResult,
 } from "./date.js";
-export { parseTaskInput, parseInboxInput, parseInput, type ParseTarget, type ParsedInput } from "./natural-language.js";
+export {
+  parseTaskInput,
+  parseInboxInput,
+  parseInput,
+  type ParseTarget,
+  type ParsedInput,
+} from "./natural-language.js";
 export {
   MAX_HIERARCHY_DEPTH,
   getTaskLevel,

package/src/utils/terminal-ui.ts

@@ -185,11 +185,9 @@ export function isFullWidth(char: string): boolean {
     (code >= 0xffe0 && code <= 0xffe6) || // Fullwidth Symbols
     (code >= 0x20000 && code <= 0x2ffff) || // CJK Extension B, C, D, E, F
     (code >= 0x30000 && code <= 0x3ffff) || // CJK Extension G, H, I
-
     // Symbols (typically wide in terminals)
     (code >= 0x2600 && code <= 0x26ff) || // Misc Symbols (sun, moon, stars, etc.)
     (code >= 0x2700 && code <= 0x27bf) || // Dingbats
-
     // Emoji ranges (comprehensive coverage)
     (code >= 0x1f1e0 && code <= 0x1f1ff) || // Regional Indicator Symbols (flags)
     (code >= 0x1f300 && code <= 0x1f5ff) || // Misc Symbols & Pictographs
@@ -202,7 +200,6 @@ export function isFullWidth(char: string): boolean {
     (code >= 0x1fa00 && code <= 0x1fa6f) || // Chess Symbols
     (code >= 0x1fa70 && code <= 0x1faff) || // Symbols & Pictographs Extended-A
     (code >= 0x1fb00 && code <= 0x1fbff) || // Symbols for Legacy Computing
-
     // Additional emoji-related
     (code >= 0x231a && code <= 0x231b) || // Watch, Hourglass
     (code >= 0x23e9 && code <= 0x23f3) || // Media control symbols
@@ -278,7 +275,11 @@ export const visibleLength = displayWidth;
 /**
  * Pad string to width (accounting for display width)
  */
-export function pad(str: string, width: number, align: "left" | "right" | "center" = "left"): string {
+export function pad(
+  str: string,
+  width: number,
+  align: "left" | "right" | "center" = "left"
+): string {
   const len = displayWidth(str);
   const diff = width - len;
   if (diff <= 0) return str;
@@ -359,7 +360,8 @@ export function progressBar(
   const filledCount = Math.round((percent / 100) * width);
   const emptyCount = width - filledCount;
 
-  const bar = color(filled.repeat(filledCount), filledColor) + color(empty.repeat(emptyCount), emptyColor);
+  const bar =
+    color(filled.repeat(filledCount), filledColor) + color(empty.repeat(emptyCount), emptyColor);
 
   return showPercent ? `${bar} ${percent}%` : bar;
 }
@@ -383,7 +385,10 @@ export function box(content: string, options: BoxOptions = {}): string {
   const { padding = 1, borderColor = "cyan", title, rounded = true } = options;
 
   const lines = content.split("\n");
-  const maxLen = Math.max(...lines.map(l => displayWidth(stripAnsi(l))), title ? title.length + 2 : 0);
+  const maxLen = Math.max(
+    ...lines.map((l) => displayWidth(stripAnsi(l))),
+    title ? title.length + 2 : 0
+  );
   const innerWidth = options.width ? options.width - 2 - padding * 2 : maxLen + padding * 2;
 
   const tl = rounded ? BOX.rTopLeft : BOX.topLeft;
@@ -402,7 +407,10 @@ export function box(content: string, options: BoxOptions = {}): string {
     const remaining = innerWidth - titlePart.length;
     const leftPad = Math.floor(remaining / 2);
     const rightPad = remaining - leftPad;
-    top = applyBorder(tl + h.repeat(leftPad)) + c.bold(titlePart) + applyBorder(h.repeat(rightPad) + tr);
+    top =
+      applyBorder(tl + h.repeat(leftPad)) +
+      c.bold(titlePart) +
+      applyBorder(h.repeat(rightPad) + tr);
   } else {
     top = applyBorder(tl + h.repeat(innerWidth) + tr);
   }
@@ -412,10 +420,16 @@ export function box(content: string, options: BoxOptions = {}): string {
   const paddingLines = Array(padding).fill(padLine);
 
   // Content lines
-  const contentLines = lines.map(line => {
+  const contentLines = lines.map((line) => {
     const lineWidth = displayWidth(stripAnsi(line));
     const padRight = innerWidth - lineWidth - padding;
-    return applyBorder(v) + " ".repeat(padding) + line + " ".repeat(Math.max(0, padRight)) + applyBorder(v);
+    return (
+      applyBorder(v) +
+      " ".repeat(padding) +
+      line +
+      " ".repeat(Math.max(0, padRight)) +
+      applyBorder(v)
+    );
   });
 
   // Bottom border
@@ -452,16 +466,16 @@ export function drawBox(lines: string[], options: BoxOptions = {}): string[] {
     const rightBorder = remainingWidth - leftBorder;
     result.push(
       applyBorder(BOX.topLeft) +
-      applyBorder(BOX.horizontal.repeat(leftBorder)) +
-      c.label(titleStr) +
-      applyBorder(BOX.horizontal.repeat(rightBorder)) +
-      applyBorder(BOX.topRight)
+        applyBorder(BOX.horizontal.repeat(leftBorder)) +
+        c.label(titleStr) +
+        applyBorder(BOX.horizontal.repeat(rightBorder)) +
+        applyBorder(BOX.topRight)
     );
   } else {
     result.push(
       applyBorder(BOX.topLeft) +
-      applyBorder(BOX.horizontal.repeat(boxWidth - 2)) +
-      applyBorder(BOX.topRight)
+        applyBorder(BOX.horizontal.repeat(boxWidth - 2)) +
+        applyBorder(BOX.topRight)
     );
   }
 
@@ -469,18 +483,18 @@ export function drawBox(lines: string[], options: BoxOptions = {}): string[] {
   for (const line of lines) {
     result.push(
       applyBorder(BOX.vertical) +
-      padStr +
-      padEnd(line, innerWidth) +
-      padStr +
-      applyBorder(BOX.vertical)
+        padStr +
+        padEnd(line, innerWidth) +
+        padStr +
+        applyBorder(BOX.vertical)
     );
   }
 
   // Bottom border
   result.push(
     applyBorder(BOX.bottomLeft) +
-    applyBorder(BOX.horizontal.repeat(boxWidth - 2)) +
-    applyBorder(BOX.bottomRight)
+      applyBorder(BOX.horizontal.repeat(boxWidth - 2)) +
+      applyBorder(BOX.bottomRight)
   );
 
   return result;
@@ -494,9 +508,9 @@ export function drawBox(lines: string[], options: BoxOptions = {}): string[] {
  * Place multiple boxes side by side (string input, string output)
  */
 export function sideBySide(boxes: string[], gap: number = 2): string {
-  const boxLines = boxes.map(b => b.split("\n"));
-  const maxHeight = Math.max(...boxLines.map(lines => lines.length));
-  const boxWidths = boxLines.map(lines => Math.max(...lines.map(l => displayWidth(l))));
+  const boxLines = boxes.map((b) => b.split("\n"));
+  const maxHeight = Math.max(...boxLines.map((lines) => lines.length));
+  const boxWidths = boxLines.map((lines) => Math.max(...lines.map((l) => displayWidth(l))));
 
   // Pad each box to max height
   const paddedBoxLines = boxLines.map((lines, i) => {
@@ -504,7 +518,7 @@ export function sideBySide(boxes: string[], gap: number = 2): string {
     while (lines.length < maxHeight) {
       lines.push(" ".repeat(width));
     }
-    return lines.map(line => {
+    return lines.map((line) => {
       const lineWidth = displayWidth(line);
       if (lineWidth < width) {
         return line + " ".repeat(width - lineWidth);
@@ -518,7 +532,7 @@ export function sideBySide(boxes: string[], gap: number = 2): string {
   const gapStr = " ".repeat(gap);
 
   for (let i = 0; i < maxHeight; i++) {
-    const lineParts = paddedBoxLines.map(lines => lines[i] ?? "");
+    const lineParts = paddedBoxLines.map((lines) => lines[i] ?? "");
     result.push(lineParts.join(gapStr));
   }
 
@@ -529,14 +543,8 @@ export function sideBySide(boxes: string[], gap: number = 2): string {
  * Merge two boxes side by side (array input, array output)
  * For MCP server compatibility
  */
-export function sideBySideArrays(
-  leftLines: string[],
-  rightLines: string[],
-  gap = 2
-): string[] {
-  const leftWidth = leftLines.length > 0
-    ? Math.max(...leftLines.map(displayWidth))
-    : 0;
+export function sideBySideArrays(leftLines: string[], rightLines: string[], gap = 2): string[] {
+  const leftWidth = leftLines.length > 0 ? Math.max(...leftLines.map(displayWidth)) : 0;
 
   const maxLines = Math.max(leftLines.length, rightLines.length);
   const result: string[] = [];
@@ -580,10 +588,10 @@ export function table<T extends Record<string, unknown>>(
   const { headerColor = "cyan", borderColor = "gray" } = options;
 
   // Calculate column widths
-  const widths = columns.map(col => {
+  const widths = columns.map((col) => {
     const headerWidth = displayWidth(col.header);
     const maxDataWidth = Math.max(
-      ...data.map(row => {
+      ...data.map((row) => {
         const val = col.format ? col.format(row[col.key], row) : String(row[col.key] ?? "");
         return displayWidth(val);
       }),
@@ -601,10 +609,10 @@ export function table<T extends Record<string, unknown>>(
     .join(` ${border} `);
 
   // Separator
-  const separator = widths.map(w => hBorder.repeat(w)).join(color(`─${BOX.cross}─`, borderColor));
+  const separator = widths.map((w) => hBorder.repeat(w)).join(color(`─${BOX.cross}─`, borderColor));
 
   // Data rows
-  const dataRows = data.map(row =>
+  const dataRows = data.map((row) =>
     columns
       .map((col, i) => {
         const w = widths[i] ?? 0;
@@ -621,33 +629,24 @@ export function table<T extends Record<string, unknown>>(
  * Render table with full borders (array output)
  * For MCP server compatibility
  */
-export function renderTable(
-  columns: TableColumn[],
-  rows: Record<string, unknown>[]
-): string[] {
+export function renderTable(columns: TableColumn[], rows: Record<string, unknown>[]): string[] {
   const colWidths: number[] = columns.map((col) => {
     const headerWidth = col.header.length;
-    const maxValueWidth = Math.max(
-      ...rows.map((row) => String(row[col.key] ?? "").length)
-    );
+    const maxValueWidth = Math.max(...rows.map((row) => String(row[col.key] ?? "").length));
     return col.width ?? Math.max(headerWidth, maxValueWidth);
   });
 
   const result: string[] = [];
 
   // Header row
-  const headerCells = columns.map((col, i) =>
-    c.label(center(col.header, colWidths[i] ?? 0))
+  const headerCells = columns.map((col, i) => c.label(center(col.header, colWidths[i] ?? 0)));
+  result.push(
+    c.muted(BOX.vertical) + headerCells.join(c.muted(BOX.vertical)) + c.muted(BOX.vertical)
   );
-  result.push(c.muted(BOX.vertical) + headerCells.join(c.muted(BOX.vertical)) + c.muted(BOX.vertical));
 
   // Separator
   const separator = columns.map((_, i) => BOX.horizontal.repeat(colWidths[i] ?? 0));
-  result.push(
-    c.muted(BOX.teeRight) +
-    c.muted(separator.join(BOX.cross)) +
-    c.muted(BOX.teeLeft)
-  );
+  result.push(c.muted(BOX.teeRight) + c.muted(separator.join(BOX.cross)) + c.muted(BOX.teeLeft));
 
   // Data rows
   for (const row of rows) {
@@ -782,5 +781,5 @@ export function banner(text: string): string {
     }
   }
 
-  return lines.map(l => c.cyan(l)).join("\n");
+  return lines.map((l) => c.cyan(l)).join("\n");
 }