@task-mcp/shared 1.0.22 → 1.0.24

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.test.ts

@@ -0,0 +1,329 @@
+import { describe, test, expect } from "bun:test";
+import {
+  now,
+  parseRelativeDate,
+  parseRelativeDateSafe,
+  parseDateString,
+  formatDate,
+  formatDisplayDate,
+  isToday,
+  isPastDue,
+  isWithinDays,
+  isValidDate,
+  DateParseError,
+} from "./date.js";
+
+describe("now", () => {
+  test("returns ISO timestamp string", () => {
+    const result = now();
+    expect(typeof result).toBe("string");
+    expect(result).toMatch(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/);
+  });
+
+  test("returns current time within tolerance", () => {
+    const before = Date.now();
+    const result = now();
+    const after = Date.now();
+
+    const resultTime = new Date(result).getTime();
+    expect(resultTime).toBeGreaterThanOrEqual(before);
+    expect(resultTime).toBeLessThanOrEqual(after);
+  });
+});
+
+describe("parseRelativeDate", () => {
+  test("parses 'today'", () => {
+    const result = parseRelativeDate("today");
+    expect(result).not.toBeNull();
+    const today = new Date();
+    expect(result!.getDate()).toBe(today.getDate());
+  });
+
+  test("parses '오늘' (Korean today)", () => {
+    const result = parseRelativeDate("오늘");
+    expect(result).not.toBeNull();
+    const today = new Date();
+    expect(result!.getDate()).toBe(today.getDate());
+  });
+
+  test("parses 'tomorrow'", () => {
+    const result = parseRelativeDate("tomorrow");
+    expect(result).not.toBeNull();
+    const tomorrow = new Date();
+    tomorrow.setDate(tomorrow.getDate() + 1);
+    expect(result!.getDate()).toBe(tomorrow.getDate());
+  });
+
+  test("parses '내일' (Korean tomorrow)", () => {
+    const result = parseRelativeDate("내일");
+    expect(result).not.toBeNull();
+    const tomorrow = new Date();
+    tomorrow.setDate(tomorrow.getDate() + 1);
+    expect(result!.getDate()).toBe(tomorrow.getDate());
+  });
+
+  test("parses 'yesterday'", () => {
+    const result = parseRelativeDate("yesterday");
+    expect(result).not.toBeNull();
+    const yesterday = new Date();
+    yesterday.setDate(yesterday.getDate() - 1);
+    expect(result!.getDate()).toBe(yesterday.getDate());
+  });
+
+  test("parses 'next week'", () => {
+    const result = parseRelativeDate("next week");
+    expect(result).not.toBeNull();
+    const nextWeek = new Date();
+    nextWeek.setDate(nextWeek.getDate() + 7);
+    expect(result!.getDate()).toBe(nextWeek.getDate());
+  });
+
+  test("parses 'in 3 days'", () => {
+    const result = parseRelativeDate("in 3 days");
+    expect(result).not.toBeNull();
+    const future = new Date();
+    future.setDate(future.getDate() + 3);
+    expect(result!.getDate()).toBe(future.getDate());
+  });
+
+  test("parses '5일 후' (Korean days later)", () => {
+    const result = parseRelativeDate("5일 후");
+    expect(result).not.toBeNull();
+    const future = new Date();
+    future.setDate(future.getDate() + 5);
+    expect(result!.getDate()).toBe(future.getDate());
+  });
+
+  test("parses weekday names", () => {
+    const result = parseRelativeDate("monday");
+    expect(result).not.toBeNull();
+    expect(result!.getDay()).toBe(1); // Monday = 1
+  });
+
+  test("parses ISO date string", () => {
+    const result = parseRelativeDate("2025-12-31");
+    expect(result).not.toBeNull();
+    expect(result!.getFullYear()).toBe(2025);
+    expect(result!.getMonth()).toBe(11); // December = 11
+    expect(result!.getDate()).toBe(31);
+  });
+
+  test("returns null for invalid input", () => {
+    const result = parseRelativeDate("invalid date string");
+    expect(result).toBeNull();
+  });
+});
+
+describe("parseRelativeDateSafe", () => {
+  test("returns success result for valid date", () => {
+    const result = parseRelativeDateSafe("tomorrow");
+    expect(result.success).toBe(true);
+    if (result.success === true) {
+      const tomorrow = new Date();
+      tomorrow.setDate(tomorrow.getDate() + 1);
+      expect(result.date.getDate()).toBe(tomorrow.getDate());
+    }
+  });
+
+  test("returns error for empty input", () => {
+    const result = parseRelativeDateSafe("");
+    expect(result.success).toBe(false);
+    if (result.success === false) {
+      expect(result.reason).toBe("empty_input");
+      expect(result.error).toContain("empty");
+    }
+  });
+
+  test("returns error for whitespace-only input", () => {
+    const result = parseRelativeDateSafe("   ");
+    expect(result.success).toBe(false);
+    if (result.success === false) {
+      expect(result.reason).toBe("empty_input");
+    }
+  });
+
+  test("returns error for invalid date format", () => {
+    const result = parseRelativeDateSafe("not a date");
+    expect(result.success).toBe(false);
+    if (result.success === false) {
+      expect(result.reason).toBe("invalid_format");
+      expect(result.error).toContain("Supported formats");
+    }
+  });
+
+  test("returns error for malformed ISO date", () => {
+    const result = parseRelativeDateSafe("2025-1-5");
+    expect(result.success).toBe(false);
+    if (result.success === false) {
+      expect(result.reason).toBe("invalid_format");
+      expect(result.error).toContain("zero-padded");
+    }
+  });
+
+  test("returns error for invalid date like Feb 30", () => {
+    const result = parseRelativeDateSafe("2025-02-30");
+    expect(result.success).toBe(false);
+    if (result.success === false) {
+      expect(result.reason).toBe("invalid_date");
+      expect(result.error).toContain("February 30");
+    }
+  });
+
+  test("returns error for year out of range", () => {
+    const result = parseRelativeDateSafe("1800-01-01");
+    expect(result.success).toBe(false);
+    if (result.success === false) {
+      expect(result.reason).toBe("out_of_range");
+      expect(result.error).toContain("1900-2100");
+    }
+  });
+
+  test("returns error for excessive day offset", () => {
+    const result = parseRelativeDateSafe("in 5000 days");
+    expect(result.success).toBe(false);
+    if (result.success === false) {
+      expect(result.reason).toBe("out_of_range");
+      expect(result.error).toContain("3650");
+    }
+  });
+});
+
+describe("isValidDate", () => {
+  test("returns true for valid Date", () => {
+    expect(isValidDate(new Date())).toBe(true);
+    expect(isValidDate(new Date("2025-01-01"))).toBe(true);
+  });
+
+  test("returns false for Invalid Date", () => {
+    expect(isValidDate(new Date("invalid"))).toBe(false);
+    expect(isValidDate(new Date(NaN))).toBe(false);
+  });
+});
+
+describe("parseDateString", () => {
+  test("parses valid date string", () => {
+    const result = parseDateString("2025-01-15");
+    expect(result).toBeInstanceOf(Date);
+    expect(result.getFullYear()).toBe(2025);
+  });
+
+  test("throws DateParseError for empty string", () => {
+    expect(() => parseDateString("")).toThrow(DateParseError);
+    try {
+      parseDateString("");
+    } catch (e) {
+      expect(e).toBeInstanceOf(DateParseError);
+      expect((e as DateParseError).reason).toBe("empty_input");
+    }
+  });
+
+  test("throws DateParseError for invalid string", () => {
+    expect(() => parseDateString("not a date")).toThrow(DateParseError);
+    try {
+      parseDateString("not a date");
+    } catch (e) {
+      expect(e).toBeInstanceOf(DateParseError);
+      expect((e as DateParseError).reason).toBe("invalid_format");
+      expect((e as DateParseError).input).toBe("not a date");
+    }
+  });
+});
+
+describe("formatDisplayDate error handling", () => {
+  test("throws DateParseError for invalid string", () => {
+    expect(() => formatDisplayDate("invalid")).toThrow(DateParseError);
+  });
+
+  test("throws DateParseError for Invalid Date object", () => {
+    expect(() => formatDisplayDate(new Date("invalid"))).toThrow(DateParseError);
+  });
+
+  test("formats valid string date", () => {
+    const result = formatDisplayDate("2025-06-15");
+    expect(typeof result).toBe("string");
+    expect(result).toMatch(/\d+\/\d+\/\d+/);
+  });
+});
+
+describe("formatDate", () => {
+  test("formats date as YYYY-MM-DD", () => {
+    const date = new Date("2025-06-15T10:30:00");
+    expect(formatDate(date)).toBe("2025-06-15");
+  });
+});
+
+describe("isToday", () => {
+  test("returns true for today", () => {
+    expect(isToday(new Date())).toBe(true);
+  });
+
+  test("returns false for tomorrow", () => {
+    const tomorrow = new Date();
+    tomorrow.setDate(tomorrow.getDate() + 1);
+    expect(isToday(tomorrow)).toBe(false);
+  });
+
+  test("accepts string input", () => {
+    expect(isToday(new Date().toISOString())).toBe(true);
+  });
+
+  test("returns false for invalid date string", () => {
+    expect(isToday("invalid")).toBe(false);
+  });
+
+  test("returns false for Invalid Date object", () => {
+    expect(isToday(new Date("invalid"))).toBe(false);
+  });
+});
+
+describe("isPastDue", () => {
+  test("returns true for yesterday", () => {
+    const yesterday = new Date();
+    yesterday.setDate(yesterday.getDate() - 1);
+    expect(isPastDue(yesterday)).toBe(true);
+  });
+
+  test("returns false for tomorrow", () => {
+    const tomorrow = new Date();
+    tomorrow.setDate(tomorrow.getDate() + 1);
+    expect(isPastDue(tomorrow)).toBe(false);
+  });
+
+  test("returns false for invalid date", () => {
+    expect(isPastDue("invalid")).toBe(false);
+    expect(isPastDue(new Date("invalid"))).toBe(false);
+  });
+});
+
+describe("isWithinDays", () => {
+  test("returns true for date within range", () => {
+    const inThreeDays = new Date();
+    inThreeDays.setDate(inThreeDays.getDate() + 3);
+    expect(isWithinDays(inThreeDays, 7)).toBe(true);
+  });
+
+  test("returns false for date outside range", () => {
+    const inTenDays = new Date();
+    inTenDays.setDate(inTenDays.getDate() + 10);
+    expect(isWithinDays(inTenDays, 7)).toBe(false);
+  });
+
+  test("returns false for past date", () => {
+    const yesterday = new Date();
+    yesterday.setDate(yesterday.getDate() - 1);
+    expect(isWithinDays(yesterday, 7)).toBe(false);
+  });
+
+  test("returns false for invalid date", () => {
+    expect(isWithinDays("invalid", 7)).toBe(false);
+    expect(isWithinDays(new Date("invalid"), 7)).toBe(false);
+  });
+
+  test("returns false for invalid days parameter", () => {
+    const tomorrow = new Date();
+    tomorrow.setDate(tomorrow.getDate() + 1);
+    expect(isWithinDays(tomorrow, -1)).toBe(false);
+    expect(isWithinDays(tomorrow, NaN)).toBe(false);
+    expect(isWithinDays(tomorrow, Infinity)).toBe(false);
+  });
+});

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, {