@task-mcp/shared 0.1.0

package/src/utils/date.ts

@@ -0,0 +1,119 @@
+/**
+ * Get current ISO timestamp
+ */
+export function now(): string {
+  return new Date().toISOString();
+}
+
+/**
+ * Parse relative date strings
+ */
+export function parseRelativeDate(input: string): Date | null {
+  const today = new Date();
+  today.setHours(0, 0, 0, 0);
+
+  const lower = input.toLowerCase().trim();
+
+  // Today
+  if (lower === "today" || lower === "오늘") {
+    return today;
+  }
+
+  // Tomorrow
+  if (lower === "tomorrow" || lower === "내일") {
+    const d = new Date(today);
+    d.setDate(d.getDate() + 1);
+    return d;
+  }
+
+  // Yesterday
+  if (lower === "yesterday" || lower === "어제") {
+    const d = new Date(today);
+    d.setDate(d.getDate() - 1);
+    return d;
+  }
+
+  // Next week
+  if (lower === "next week" || lower === "다음주") {
+    const d = new Date(today);
+    d.setDate(d.getDate() + 7);
+    return d;
+  }
+
+  // In N days
+  const inDaysMatch = lower.match(/^in (\d+) days?$/);
+  if (inDaysMatch) {
+    const d = new Date(today);
+    d.setDate(d.getDate() + parseInt(inDaysMatch[1]!, 10));
+    return d;
+  }
+
+  // N일 후
+  const koreanDaysMatch = lower.match(/^(\d+)일\s*후$/);
+  if (koreanDaysMatch) {
+    const d = new Date(today);
+    d.setDate(d.getDate() + parseInt(koreanDaysMatch[1]!, 10));
+    return d;
+  }
+
+  // Weekday names
+  const weekdays = ["sunday", "monday", "tuesday", "wednesday", "thursday", "friday", "saturday"];
+  const weekdayIndex = weekdays.indexOf(lower);
+  if (weekdayIndex !== -1) {
+    const d = new Date(today);
+    const currentDay = d.getDay();
+    const daysUntil = (weekdayIndex - currentDay + 7) % 7 || 7;
+    d.setDate(d.getDate() + daysUntil);
+    return d;
+  }
+
+  // Try parsing as ISO date
+  const parsed = new Date(input);
+  if (!isNaN(parsed.getTime())) {
+    return parsed;
+  }
+
+  return null;
+}
+
+/**
+ * Format date as YYYY-MM-DD
+ */
+export function formatDate(date: Date): string {
+  return date.toISOString().split("T")[0]!;
+}
+
+/**
+ * Check if a date is today
+ */
+export function isToday(date: Date | string): boolean {
+  const d = typeof date === "string" ? new Date(date) : date;
+  const today = new Date();
+  return (
+    d.getFullYear() === today.getFullYear() &&
+    d.getMonth() === today.getMonth() &&
+    d.getDate() === today.getDate()
+  );
+}
+
+/**
+ * Check if a date is before today
+ */
+export function isPastDue(date: Date | string): boolean {
+  const d = typeof date === "string" ? new Date(date) : date;
+  const today = new Date();
+  today.setHours(0, 0, 0, 0);
+  return d < today;
+}
+
+/**
+ * Check if a date is within the next N days
+ */
+export function isWithinDays(date: Date | string, days: number): boolean {
+  const d = typeof date === "string" ? new Date(date) : date;
+  const today = new Date();
+  today.setHours(0, 0, 0, 0);
+  const future = new Date(today);
+  future.setDate(future.getDate() + days);
+  return d >= today && d <= future;
+}

package/src/utils/id.ts

@@ -0,0 +1,45 @@
+/**
+ * Generate a unique ID with optional prefix
+ */
+export function generateId(prefix: string = ""): string {
+  const timestamp = Date.now().toString(36);
+  const random = Math.random().toString(36).substring(2, 8);
+  return prefix ? `${prefix}_${timestamp}${random}` : `${timestamp}${random}`;
+}
+
+/**
+ * Generate a task ID
+ */
+export function generateTaskId(): string {
+  return generateId("task");
+}
+
+/**
+ * Generate a project ID
+ */
+export function generateProjectId(): string {
+  return generateId("proj");
+}
+
+/**
+ * Generate a view ID
+ */
+export function generateViewId(): string {
+  return generateId("view");
+}
+
+/**
+ * Validate a project ID format
+ * @returns true if valid format (proj_[alphanumeric])
+ */
+export function isValidProjectId(id: string): boolean {
+  return /^proj_[a-z0-9]+$/.test(id);
+}
+
+/**
+ * Validate a task ID format
+ * @returns true if valid format (task_[alphanumeric])
+ */
+export function isValidTaskId(id: string): boolean {
+  return /^task_[a-z0-9]+$/.test(id);
+}

package/src/utils/index.ts

@@ -0,0 +1,3 @@
+export { generateId, generateTaskId, generateProjectId, generateViewId, isValidProjectId, isValidTaskId } from "./id.js";
+export { now, parseRelativeDate, formatDate, isToday, isPastDue, isWithinDays } from "./date.js";
+export { parseTaskInput } from "./natural-language.js";

package/src/utils/natural-language.test.ts

@@ -0,0 +1,154 @@
+import { describe, test, expect } from "bun:test";
+import { parseTaskInput } from "./natural-language.js";
+
+describe("parseTaskInput", () => {
+  describe("priority parsing", () => {
+    test("parses !critical priority", () => {
+      const result = parseTaskInput("Fix bug !critical");
+      expect(result.priority).toBe("critical");
+      expect(result.title).toBe("Fix bug");
+    });
+
+    test("parses !high priority", () => {
+      const result = parseTaskInput("Review PR !high");
+      expect(result.priority).toBe("high");
+    });
+
+    test("parses !medium priority", () => {
+      const result = parseTaskInput("Write docs !medium");
+      expect(result.priority).toBe("medium");
+    });
+
+    test("parses !low priority", () => {
+      const result = parseTaskInput("Clean up !low");
+      expect(result.priority).toBe("low");
+    });
+
+    test("parses Korean priority !높음", () => {
+      const result = parseTaskInput("버그 수정 !높음");
+      expect(result.priority).toBe("high");
+      expect(result.title).toBe("버그 수정");
+    });
+
+    test("parses Korean priority !긴급", () => {
+      const result = parseTaskInput("장애 대응 !긴급");
+      expect(result.priority).toBe("critical");
+      expect(result.title).toBe("장애 대응");
+    });
+  });
+
+  describe("tag parsing", () => {
+    test("parses single tag", () => {
+      const result = parseTaskInput("Fix auth #backend");
+      expect(result.tags).toEqual(["backend"]);
+      expect(result.title).toBe("Fix auth");
+    });
+
+    test("parses multiple tags", () => {
+      const result = parseTaskInput("Update API #backend #api #v2");
+      expect(result.tags).toEqual(["backend", "api", "v2"]);
+    });
+
+    test("parses Korean tags", () => {
+      const result = parseTaskInput("보고서 작성 #업무 #문서");
+      expect(result.tags).toEqual(["업무", "문서"]);
+      expect(result.title).toBe("보고서 작성");
+    });
+  });
+
+  describe("context parsing", () => {
+    test("parses single context", () => {
+      const result = parseTaskInput("Deep work task @focus");
+      expect(result.contexts).toEqual(["focus"]);
+      expect(result.title).toBe("Deep work task");
+    });
+
+    test("parses multiple contexts", () => {
+      const result = parseTaskInput("Review code @focus @office");
+      expect(result.contexts).toEqual(["focus", "office"]);
+    });
+  });
+
+  describe("due date parsing", () => {
+    test("parses 'by tomorrow'", () => {
+      const result = parseTaskInput("Submit report by tomorrow");
+      expect(result.dueDate).toBeDefined();
+      expect(result.title).toBe("Submit report");
+    });
+
+    test("parses 'until Friday'", () => {
+      const result = parseTaskInput("Complete feature until Friday");
+      expect(result.dueDate).toBeDefined();
+    });
+
+    test("parses Korean '내일까지'", () => {
+      const result = parseTaskInput("보고서 제출 내일까지");
+      expect(result.dueDate).toBeDefined();
+      expect(result.title).toBe("보고서 제출");
+    });
+
+    test("parses standalone 'tomorrow' at end", () => {
+      const result = parseTaskInput("Submit PR tomorrow");
+      expect(result.dueDate).toBeDefined();
+      expect(result.title).toBe("Submit PR");
+    });
+  });
+
+  describe("time estimate parsing", () => {
+    test("parses hours only", () => {
+      const result = parseTaskInput("Write tests 2h");
+      expect(result.estimate?.expected).toBe(120);
+    });
+
+    test("parses minutes only", () => {
+      const result = parseTaskInput("Quick fix 30m");
+      expect(result.estimate?.expected).toBe(30);
+    });
+
+    test("parses combined hours and minutes", () => {
+      const result = parseTaskInput("Big refactor 1h30m");
+      expect(result.estimate?.expected).toBe(90);
+    });
+
+    test("removes time estimate from title", () => {
+      const result = parseTaskInput("Task 2h30m done");
+      expect(result.estimate?.expected).toBe(150);
+      expect(result.title).toBe("Task done");
+    });
+  });
+
+  describe("combined parsing", () => {
+    test("parses full English input", () => {
+      const result = parseTaskInput("Review PR #dev !high @focus");
+      expect(result.title).toBe("Review PR");
+      expect(result.tags).toEqual(["dev"]);
+      expect(result.priority).toBe("high");
+      expect(result.contexts).toEqual(["focus"]);
+    });
+
+    test("parses input with due date", () => {
+      const result = parseTaskInput("Submit report by tomorrow #work");
+      expect(result.title).toBe("Submit report");
+      expect(result.tags).toEqual(["work"]);
+      expect(result.dueDate).toBeDefined();
+    });
+
+    test("parses full Korean input", () => {
+      const result = parseTaskInput("보고서 작성 내일까지 #업무 !높음 @집중");
+      expect(result.title).toBe("보고서 작성");
+      expect(result.tags).toEqual(["업무"]);
+      expect(result.priority).toBe("high");
+      expect(result.contexts).toEqual(["집중"]);
+      expect(result.dueDate).toBeDefined();
+    });
+
+    test("returns clean title with no metadata", () => {
+      const result = parseTaskInput("Simple task");
+      expect(result.title).toBe("Simple task");
+      expect(result.tags).toBeUndefined();
+      expect(result.priority).toBeUndefined();
+      expect(result.contexts).toBeUndefined();
+      expect(result.dueDate).toBeUndefined();
+    });
+  });
+});

package/src/utils/natural-language.ts

@@ -0,0 +1,125 @@
+import type { Priority, TaskCreateInput } from "../schemas/task.js";
+import { parseRelativeDate } from "./date.js";
+
+/**
+ * Parse natural language task input
+ *
+ * Examples:
+ * - "Review PR tomorrow #dev !high"
+ * - "내일까지 보고서 작성 #업무 !높음 @집중"
+ * - "Fix bug by Friday #backend !critical"
+ * - "Write tests every Monday #testing"
+ */
+export function parseTaskInput(input: string): TaskCreateInput {
+  let remaining = input.trim();
+  const result: TaskCreateInput = { title: "" };
+
+  // Extract priority (!high, !critical, !medium, !low, !높음, !보통, !낮음)
+  const priorityMatch = remaining.match(/!([\p{L}\p{N}_]+)/gu);
+  if (priorityMatch) {
+    for (const match of priorityMatch) {
+      const priority = parsePriority(match.slice(1));
+      if (priority) {
+        result.priority = priority;
+        remaining = remaining.replace(match, "").trim();
+        break;
+      }
+    }
+  }
+
+  // Extract contexts (@focus, @review, @집중)
+  const contextMatches = remaining.match(/@([\p{L}\p{N}_]+)/gu);
+  if (contextMatches) {
+    result.contexts = contextMatches.map((m) => m.slice(1));
+    for (const match of contextMatches) {
+      remaining = remaining.replace(match, "").trim();
+    }
+  }
+
+  // Extract tags (#dev, #backend, #개발)
+  const tagMatches = remaining.match(/#([\p{L}\p{N}_]+)/gu);
+  if (tagMatches) {
+    result.tags = tagMatches.map((m) => m.slice(1));
+    for (const match of tagMatches) {
+      remaining = remaining.replace(match, "").trim();
+    }
+  }
+
+  // Extract due date patterns
+  // "by Friday", "by tomorrow", "until next week"
+  const byMatch = remaining.match(/\b(by|until|before)\s+(\w+(\s+\w+)?)/i);
+  if (byMatch) {
+    const dateStr = byMatch[2]!;
+    const date = parseRelativeDate(dateStr);
+    if (date) {
+      result.dueDate = date.toISOString();
+      remaining = remaining.replace(byMatch[0], "").trim();
+    }
+  }
+
+  // Korean date patterns: "내일까지", "금요일까지"
+  const koreanDueMatch = remaining.match(/(\S+)까지/);
+  if (koreanDueMatch && !result.dueDate) {
+    const dateStr = koreanDueMatch[1]!;
+    const date = parseRelativeDate(dateStr);
+    if (date) {
+      result.dueDate = date.toISOString();
+      remaining = remaining.replace(koreanDueMatch[0], "").trim();
+    }
+  }
+
+  // "tomorrow", "today" at the end
+  const dateWords = ["tomorrow", "today", "내일", "오늘", "모레"];
+  for (const word of dateWords) {
+    if (remaining.toLowerCase().endsWith(word) && !result.dueDate) {
+      const date = parseRelativeDate(word);
+      if (date) {
+        result.dueDate = date.toISOString();
+        remaining = remaining.slice(0, -word.length).trim();
+      }
+    }
+  }
+
+  // Extract time estimate (30m, 2h, 1h30m)
+  // Pattern matches: "2h30m", "2h", "30m" (but not empty string)
+  const timeMatch = remaining.match(/\b(\d+h\d+m|\d+h|\d+m)\b/);
+  if (timeMatch) {
+    let minutes = 0;
+    const hoursMatch = timeMatch[0].match(/(\d+)h/);
+    const minsMatch = timeMatch[0].match(/(\d+)m/);
+    if (hoursMatch) {
+      minutes += parseInt(hoursMatch[1]!, 10) * 60;
+    }
+    if (minsMatch) {
+      minutes += parseInt(minsMatch[1]!, 10);
+    }
+    if (minutes > 0) {
+      result.estimate = { expected: minutes, confidence: "medium" };
+      remaining = remaining.replace(timeMatch[0], "").trim();
+    }
+  }
+
+  // Clean up extra spaces
+  result.title = remaining.replace(/\s+/g, " ").trim();
+
+  return result;
+}
+
+function parsePriority(input: string): Priority | null {
+  const lower = input.toLowerCase();
+
+  const priorityMap: Record<string, Priority> = {
+    critical: "critical",
+    highest: "critical",
+    긴급: "critical",
+    high: "high",
+    높음: "high",
+    medium: "medium",
+    normal: "medium",
+    보통: "medium",
+    low: "low",
+    낮음: "low",
+  };
+
+  return priorityMap[lower] ?? null;
+}