@task-mcp/shared 1.0.13 → 1.0.14

package/src/utils/dashboard-renderer.ts

@@ -15,6 +15,7 @@ import {
   pad,
   banner,
   stripAnsi,
+  formatPriority,
   type TableColumn,
 } from "./terminal-ui.js";
 
@@ -53,6 +54,7 @@ export interface DashboardData {
   inboxItems?: InboxItem[] | undefined;
   currentProject?: Project | undefined;
   version?: string | undefined;
+  activeTag?: string | undefined;
 }
 
 // =============================================================================
@@ -158,16 +160,6 @@ export function calculateDependencyMetrics(tasks: Task[]): DependencyMetrics {
 // Formatters
 // =============================================================================
 
-function formatPriority(priority: Task["priority"]): string {
-  const colors: Record<string, (s: string) => string> = {
-    critical: c.red,
-    high: c.yellow,
-    medium: c.blue,
-    low: c.gray,
-  };
-  return (colors[priority] ?? c.gray)(priority);
-}
-
 function getTimeAgo(date: Date): string {
   const now = new Date();
   const diffMs = now.getTime() - date.getTime();
@@ -488,7 +480,7 @@ export function renderDashboard(
     stripAnsiCodes = false,
   } = options;
 
-  const { tasks, projects, inboxItems = [], currentProject, version } = data;
+  const { tasks, projects, inboxItems = [], currentProject, version, activeTag } = data;
   const lines: string[] = [];
 
   // Banner
@@ -503,8 +495,13 @@ export function renderDashboard(
     ? `${c.bold("Project:")} ${currentProject.name}`
     : `${c.bold("All Projects")} (${projects.length} projects)`;
 
-  if (version) {
-    lines.push(c.dim(`v${version}  ${projectInfo}`));
+  // Build header line with version and tag
+  const headerParts: string[] = [];
+  if (version) headerParts.push(`v${version}`);
+  if (activeTag) headerParts.push(`#${activeTag}`);
+
+  if (headerParts.length > 0) {
+    lines.push(c.dim(`${headerParts.join("  ")}  ${projectInfo}`));
   } else {
     lines.push(projectInfo);
   }
@@ -557,13 +554,14 @@ export function renderDashboard(
 export function renderProjectDashboard(
   project: Project,
   tasks: Task[],
-  options: { stripAnsiCodes?: boolean; version?: string } = {}
+  options: { stripAnsiCodes?: boolean; version?: string; activeTag?: string } = {}
 ): string {
   const data: DashboardData = {
     tasks,
     projects: [project],
     currentProject: project,
     version: options.version,
+    activeTag: options.activeTag,
   };
 
   return renderDashboard(
@@ -587,13 +585,14 @@ export function renderGlobalDashboard(
   allTasks: Task[],
   inboxItems: InboxItem[],
   getProjectTasks: (projectId: string) => Task[],
-  options: { stripAnsiCodes?: boolean; version?: string } = {}
+  options: { stripAnsiCodes?: boolean; version?: string; activeTag?: string } = {}
 ): string {
   const data: DashboardData = {
     tasks: allTasks,
     projects,
     inboxItems,
     version: options.version,
+    activeTag: options.activeTag,
   };
 
   return renderDashboard(data, getProjectTasks, {

package/src/utils/date.test.ts

@@ -1,5 +1,17 @@
 import { describe, test, expect } from "bun:test";
-import { now, parseRelativeDate, formatDate, isToday, isPastDue, isWithinDays } from "./date.js";
+import {
+  now,
+  parseRelativeDate,
+  parseRelativeDateSafe,
+  parseDateString,
+  formatDate,
+  formatDisplayDate,
+  isToday,
+  isPastDue,
+  isWithinDays,
+  isValidDate,
+  DateParseError,
+} from "./date.js";
 
 describe("now", () => {
   test("returns ISO timestamp string", () => {
@@ -102,6 +114,137 @@ describe("parseRelativeDate", () => {
   });
 });
 
+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");
@@ -123,6 +266,14 @@ describe("isToday", () => {
   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", () => {
@@ -137,6 +288,11 @@ describe("isPastDue", () => {
     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", () => {
@@ -157,4 +313,17 @@ describe("isWithinDays", () => {
     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

@@ -1,3 +1,33 @@
+/**
+ * Error thrown when date parsing fails
+ */
+export class DateParseError extends Error {
+  constructor(
+    message: string,
+    public readonly input: string,
+    public readonly reason: DateParseErrorReason
+  ) {
+    super(message);
+    this.name = "DateParseError";
+  }
+}
+
+/**
+ * Reasons why date parsing can fail
+ */
+export type DateParseErrorReason =
+  | "empty_input"
+  | "invalid_format"
+  | "invalid_date"
+  | "out_of_range";
+
+/**
+ * Result type for date parsing operations
+ */
+export type DateParseResult =
+  | { success: true; date: Date }
+  | { success: false; error: string; reason: DateParseErrorReason };
+
 /**
  * Get current ISO timestamp
  */
@@ -7,53 +37,104 @@ export function now(): string {
 
 /**
  * Parse relative date strings
+ * @returns Date object if parsing succeeds, null otherwise
  */
 export function parseRelativeDate(input: string): Date | null {
+  const result = parseRelativeDateSafe(input);
+  return result.success ? result.date : null;
+}
+
+/**
+ * Parse relative date strings with detailed error information
+ *
+ * Supported formats:
+ * - Relative: "today", "tomorrow", "yesterday", "next week", "in N days"
+ * - Korean: "오늘", "내일", "어제", "다음주", "N일 후"
+ * - Weekdays: "monday", "tuesday", etc.
+ * - ISO format: "YYYY-MM-DD"
+ *
+ * @returns DateParseResult with either the parsed date or error details
+ */
+export function parseRelativeDateSafe(input: string): DateParseResult {
+  // Validate input
+  if (!input || typeof input !== "string") {
+    return {
+      success: false,
+      error: "Date input is empty or not a string",
+      reason: "empty_input",
+    };
+  }
+
+  const trimmed = input.trim();
+  if (trimmed.length === 0) {
+    return {
+      success: false,
+      error: "Date input is empty after trimming whitespace",
+      reason: "empty_input",
+    };
+  }
+
   const today = new Date();
   today.setHours(0, 0, 0, 0);
 
-  const lower = input.toLowerCase().trim();
+  const lower = trimmed.toLowerCase();
 
   // Today
   if (lower === "today" || lower === "오늘") {
-    return today;
+    return { success: true, date: today };
   }
 
   // Tomorrow
   if (lower === "tomorrow" || lower === "내일") {
     const d = new Date(today);
     d.setDate(d.getDate() + 1);
-    return d;
+    return { success: true, date: d };
   }
 
   // Yesterday
   if (lower === "yesterday" || lower === "어제") {
     const d = new Date(today);
     d.setDate(d.getDate() - 1);
-    return d;
+    return { success: true, date: d };
   }
 
   // Next week
   if (lower === "next week" || lower === "다음주") {
     const d = new Date(today);
     d.setDate(d.getDate() + 7);
-    return d;
+    return { success: true, date: d };
   }
 
   // In N days
   const inDaysMatch = lower.match(/^in (\d+) days?$/);
   if (inDaysMatch) {
+    const days = parseInt(inDaysMatch[1]!, 10);
+    if (days > 3650) {
+      return {
+        success: false,
+        error: `Day offset ${days} exceeds maximum of 3650 (10 years)`,
+        reason: "out_of_range",
+      };
+    }
     const d = new Date(today);
-    d.setDate(d.getDate() + parseInt(inDaysMatch[1]!, 10));
-    return d;
+    d.setDate(d.getDate() + days);
+    return { success: true, date: d };
   }
 
   // N일 후
   const koreanDaysMatch = lower.match(/^(\d+)일\s*후$/);
   if (koreanDaysMatch) {
+    const days = parseInt(koreanDaysMatch[1]!, 10);
+    if (days > 3650) {
+      return {
+        success: false,
+        error: `Day offset ${days} exceeds maximum of 3650 (10 years)`,
+        reason: "out_of_range",
+      };
+    }
     const d = new Date(today);
-    d.setDate(d.getDate() + parseInt(koreanDaysMatch[1]!, 10));
-    return d;
+    d.setDate(d.getDate() + days);
+    return { success: true, date: d };
   }
 
   // Weekday names
@@ -64,32 +145,75 @@ export function parseRelativeDate(input: string): Date | null {
     const currentDay = d.getDay();
     const daysUntil = (weekdayIndex - currentDay + 7) % 7 || 7;
     d.setDate(d.getDate() + daysUntil);
-    return d;
+    return { success: true, date: d };
   }
 
   // Try parsing as YYYY-MM-DD format (local timezone, no UTC shift)
-  const isoDateMatch = input.match(/^(\d{4})-(\d{2})-(\d{2})$/);
+  const isoDateMatch = trimmed.match(/^(\d{4})-(\d{2})-(\d{2})$/);
   if (isoDateMatch) {
     const [, yearStr, monthStr, dayStr] = isoDateMatch;
     const year = parseInt(yearStr!, 10);
     const month = parseInt(monthStr!, 10) - 1; // 0-indexed
     const day = parseInt(dayStr!, 10);
+
+    // Validate ranges before creating Date
+    if (year < 1900 || year > 2100) {
+      return {
+        success: false,
+        error: `Year ${year} is out of supported range (1900-2100)`,
+        reason: "out_of_range",
+      };
+    }
+    if (month < 0 || month > 11) {
+      return {
+        success: false,
+        error: `Month ${monthStr} is invalid (must be 01-12)`,
+        reason: "invalid_date",
+      };
+    }
+    if (day < 1 || day > 31) {
+      return {
+        success: false,
+        error: `Day ${dayStr} is invalid (must be 01-31)`,
+        reason: "invalid_date",
+      };
+    }
+
     const d = new Date(year, month, day);
     // Validate the date is valid (e.g., not Feb 30)
     if (d.getFullYear() === year && d.getMonth() === month && d.getDate() === day) {
-      return d;
+      return { success: true, date: d };
     }
+
+    return {
+      success: false,
+      error: `Invalid date: ${trimmed} (e.g., February 30 does not exist)`,
+      reason: "invalid_date",
+    };
+  }
+
+  // Check if it looks like an ISO date but malformed
+  if (/^\d{4}-\d{1,2}-\d{1,2}$/.test(trimmed) && !isoDateMatch) {
+    return {
+      success: false,
+      error: `Date "${trimmed}" should use YYYY-MM-DD format with zero-padded month and day`,
+      reason: "invalid_format",
+    };
   }
 
   // Try parsing other date formats (fallback)
-  const parsed = new Date(input);
+  const parsed = new Date(trimmed);
   if (!isNaN(parsed.getTime())) {
     // For non-YYYY-MM-DD formats, normalize to local midnight
     const d = new Date(parsed.getFullYear(), parsed.getMonth(), parsed.getDate());
-    return d;
+    return { success: true, date: d };
   }
 
-  return null;
+  return {
+    success: false,
+    error: `Unable to parse "${trimmed}" as a date. Supported formats: "today", "tomorrow", "next week", "in N days", weekday names, or YYYY-MM-DD`,
+    reason: "invalid_format",
+  };
 }
 
 /**
@@ -103,13 +227,57 @@ export function formatDate(date: Date): string {
   return `${year}-${month}-${day}`;
 }
 
+/**
+ * Parse a date string and return a validated Date object
+ * @throws {DateParseError} if the string cannot be parsed as a valid date
+ */
+export function parseDateString(input: string): Date {
+  if (!input || typeof input !== "string" || input.trim().length === 0) {
+    throw new DateParseError("Date string is empty or not a string", input ?? "", "empty_input");
+  }
+
+  const d = new Date(input);
+  if (isNaN(d.getTime())) {
+    throw new DateParseError(
+      `Unable to parse "${input}" as a date`,
+      input,
+      "invalid_format"
+    );
+  }
+
+  return d;
+}
+
+/**
+ * Check if a Date object is valid (not Invalid Date)
+ */
+export function isValidDate(date: Date): boolean {
+  return date instanceof Date && !isNaN(date.getTime());
+}
+
 /**
  * Format date for display using system locale
  * Use this for showing dates to users
  * Output: YY/MM/DD, MM/DD/YY, DD/MM/YY (depends on locale)
+ * @throws {DateParseError} if input string cannot be parsed
  */
 export function formatDisplayDate(date: Date | string): string {
-  const d = typeof date === "string" ? new Date(date) : date;
+  let d: Date;
+
+  if (typeof date === "string") {
+    d = parseDateString(date);
+  } else {
+    d = date;
+  }
+
+  if (!isValidDate(d)) {
+    throw new DateParseError(
+      "Invalid Date object provided",
+      String(date),
+      "invalid_date"
+    );
+  }
+
   const parts = new Intl.DateTimeFormat(undefined, {
     year: "2-digit",
     month: "2-digit",
@@ -122,11 +290,28 @@ export function formatDisplayDate(date: Date | string): string {
     .join("/");
 }
 
+/**
+ * Safely convert string or Date to Date, returning null for invalid inputs
+ */
+function toDate(date: Date | string): Date | null {
+  if (date instanceof Date) {
+    return isValidDate(date) ? date : null;
+  }
+  if (typeof date === "string" && date.trim().length > 0) {
+    const d = new Date(date);
+    return isValidDate(d) ? d : null;
+  }
+  return null;
+}
+
 /**
  * Check if a date is today
+ * Returns false for invalid dates (does not throw)
  */
 export function isToday(date: Date | string): boolean {
-  const d = typeof date === "string" ? new Date(date) : date;
+  const d = toDate(date);
+  if (!d) return false;
+
   const today = new Date();
   return (
     d.getFullYear() === today.getFullYear() &&
@@ -137,9 +322,12 @@ export function isToday(date: Date | string): boolean {
 
 /**
  * Check if a date is before today
+ * Returns false for invalid dates (does not throw)
  */
 export function isPastDue(date: Date | string): boolean {
-  const d = typeof date === "string" ? new Date(date) : date;
+  const d = toDate(date);
+  if (!d) return false;
+
   const today = new Date();
   today.setHours(0, 0, 0, 0);
   return d < today;
@@ -147,9 +335,16 @@ export function isPastDue(date: Date | string): boolean {
 
 /**
  * Check if a date is within the next N days
+ * Returns false for invalid dates or invalid days parameter (does not throw)
  */
 export function isWithinDays(date: Date | string, days: number): boolean {
-  const d = typeof date === "string" ? new Date(date) : date;
+  const d = toDate(date);
+  if (!d) return false;
+
+  if (typeof days !== "number" || !Number.isFinite(days) || days < 0) {
+    return false;
+  }
+
   const today = new Date();
   today.setHours(0, 0, 0, 0);
   const future = new Date(today);