@task-mcp/shared 1.0.19 → 1.0.21

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

@@ -1,182 +0,0 @@
-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("sortOrder parsing", () => {
-    test("parses ^1 as sortOrder 1", () => {
-      const result = parseTaskInput("First task ^1");
-      expect(result.sortOrder).toBe(1);
-      expect(result.title).toBe("First task");
-    });
-
-    test("parses ^10 as sortOrder 10", () => {
-      const result = parseTaskInput("Tenth task ^10");
-      expect(result.sortOrder).toBe(10);
-      expect(result.title).toBe("Tenth task");
-    });
-
-    test("parses sortOrder in middle of input", () => {
-      const result = parseTaskInput("Task ^5 with more text");
-      expect(result.sortOrder).toBe(5);
-      expect(result.title).toBe("Task with more text");
-    });
-
-    test("parses sortOrder with other metadata", () => {
-      const result = parseTaskInput("Task ^3 #dev !high");
-      expect(result.sortOrder).toBe(3);
-      expect(result.tags).toEqual(["dev"]);
-      expect(result.priority).toBe("high");
-      expect(result.title).toBe("Task");
-    });
-  });
-
-  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/projection.test.ts

@@ -1,425 +0,0 @@
-import { describe, test, expect } from "bun:test";
-import {
-  projectTask,
-  projectTasks,
-  projectTasksPaginated,
-  projectInboxItem,
-  projectInboxItems,
-  formatResponse,
-  applyPagination,
-  truncate,
-  summarizeList,
-} from "./projection.js";
-import type { Task } from "../schemas/task.js";
-import type { InboxItem } from "../schemas/inbox.js";
-
-// Test fixtures
-const createTask = (overrides: Partial<Task> = {}): Task => {
-  const base: Task = {
-    id: "task-1",
-    workspace: "test-workspace",
-    title: "Test Task",
-    status: "pending",
-    priority: "medium",
-    createdAt: "2025-01-01T00:00:00.000Z",
-    updatedAt: "2025-01-01T00:00:00.000Z",
-    dueDate: "2025-01-15",
-    tags: ["test", "unit"],
-    contexts: ["work"],
-    parentId: "parent-1",
-    description: "This is a test task with a long description",
-    estimate: { expected: 60, optimistic: 30, pessimistic: 120 },
-    dependencies: [{ taskId: "dep-1", type: "blocked_by" }],
-  };
-  return { ...base, ...overrides };
-};
-
-const createInboxItem = (overrides: Partial<InboxItem> = {}): InboxItem => ({
-  id: "inbox-1",
-  content: "Quick idea for later",
-  status: "pending",
-  capturedAt: "2025-01-01T00:00:00.000Z",
-  tags: ["idea"],
-  source: "cli",
-  ...overrides,
-});
-
-describe("projectTask", () => {
-  test("concise format returns only 4 essential fields", () => {
-    const task = createTask();
-    const result = projectTask(task, "concise");
-
-    expect(result).toEqual({
-      id: "task-1",
-      title: "Test Task",
-      status: "pending",
-      priority: "medium",
-    });
-    expect(Object.keys(result)).toHaveLength(4);
-  });
-
-  test("standard format returns 8 common fields", () => {
-    const task = createTask();
-    const result = projectTask(task, "standard");
-
-    expect(result).toEqual({
-      id: "task-1",
-      title: "Test Task",
-      status: "pending",
-      priority: "medium",
-      dueDate: "2025-01-15",
-      tags: ["test", "unit"],
-      contexts: ["work"],
-      parentId: "parent-1",
-    });
-  });
-
-  test("detailed format returns full task", () => {
-    const task = createTask();
-    const result = projectTask(task, "detailed");
-
-    expect(result).toBe(task); // Same reference
-    expect(result).toHaveProperty("description");
-    expect(result).toHaveProperty("estimate");
-    expect(result).toHaveProperty("dependencies");
-  });
-
-  test("concise format omits undefined optional fields", () => {
-    // Create task without optional fields by deleting them
-    const task = createTask();
-    delete (task as Record<string, unknown>)["dueDate"];
-    delete (task as Record<string, unknown>)["tags"];
-    const result = projectTask(task, "concise");
-
-    expect(result).not.toHaveProperty("dueDate");
-    expect(result).not.toHaveProperty("tags");
-  });
-});
-
-describe("projectTasks", () => {
-  test("projects all tasks without limit", () => {
-    const tasks = [createTask({ id: "t1" }), createTask({ id: "t2" }), createTask({ id: "t3" })];
-    const result = projectTasks(tasks, "concise");
-
-    expect(result).toHaveLength(3);
-    expect(result[0]).toEqual({ id: "t1", title: "Test Task", status: "pending", priority: "medium" });
-  });
-
-  test("limits tasks when limit provided", () => {
-    const tasks = [
-      createTask({ id: "t1" }),
-      createTask({ id: "t2" }),
-      createTask({ id: "t3" }),
-      createTask({ id: "t4" }),
-      createTask({ id: "t5" }),
-    ];
-    const result = projectTasks(tasks, "concise", 2);
-
-    expect(result).toHaveLength(2);
-    expect(result.map((t) => t.id)).toEqual(["t1", "t2"]);
-  });
-
-  test("returns all tasks if limit exceeds length", () => {
-    const tasks = [createTask({ id: "t1" }), createTask({ id: "t2" })];
-    const result = projectTasks(tasks, "concise", 100);
-
-    expect(result).toHaveLength(2);
-  });
-
-  test("returns empty array for empty input", () => {
-    const result = projectTasks([], "concise");
-    expect(result).toEqual([]);
-  });
-});
-
-describe("projectTasksPaginated", () => {
-  test("returns paginated response with correct metadata", () => {
-    const tasks = Array.from({ length: 50 }, (_, i) => createTask({ id: `t${i}` }));
-    const result = projectTasksPaginated(tasks, "concise", 10, 0);
-
-    expect(result.items).toHaveLength(10);
-    expect(result.total).toBe(50);
-    expect(result.limit).toBe(10);
-    expect(result.offset).toBe(0);
-    expect(result.hasMore).toBe(true);
-  });
-
-  test("returns correct page with offset", () => {
-    const tasks = Array.from({ length: 50 }, (_, i) => createTask({ id: `t${i}` }));
-    const result = projectTasksPaginated(tasks, "concise", 10, 20);
-
-    expect(result.items).toHaveLength(10);
-    expect(result.items[0]?.id).toBe("t20");
-    expect(result.offset).toBe(20);
-    expect(result.hasMore).toBe(true);
-  });
-
-  test("hasMore is false on last page", () => {
-    const tasks = Array.from({ length: 25 }, (_, i) => createTask({ id: `t${i}` }));
-    const result = projectTasksPaginated(tasks, "concise", 10, 20);
-
-    expect(result.items).toHaveLength(5);
-    expect(result.hasMore).toBe(false);
-  });
-
-  test("enforces max limit of 100", () => {
-    const tasks = Array.from({ length: 200 }, (_, i) => createTask({ id: `t${i}` }));
-    const result = projectTasksPaginated(tasks, "concise", 150, 0);
-
-    expect(result.items).toHaveLength(100);
-    expect(result.limit).toBe(100);
-    expect(result.hasMore).toBe(true);
-  });
-
-  test("uses default limit of 20", () => {
-    const tasks = Array.from({ length: 50 }, (_, i) => createTask({ id: `t${i}` }));
-    const result = projectTasksPaginated(tasks, "concise");
-
-    expect(result.items).toHaveLength(20);
-    expect(result.limit).toBe(20);
-  });
-});
-
-describe("projectInboxItem", () => {
-  test("concise format returns 3 essential fields", () => {
-    const item = createInboxItem();
-    const result = projectInboxItem(item, "concise");
-
-    expect(result).toEqual({
-      id: "inbox-1",
-      content: "Quick idea for later",
-      status: "pending",
-    });
-    expect(Object.keys(result)).toHaveLength(3);
-  });
-
-  test("standard format includes capturedAt and tags", () => {
-    const item = createInboxItem();
-    const result = projectInboxItem(item, "standard");
-
-    expect(result).toEqual({
-      id: "inbox-1",
-      content: "Quick idea for later",
-      status: "pending",
-      capturedAt: "2025-01-01T00:00:00.000Z",
-      tags: ["idea"],
-    });
-  });
-
-  test("detailed format returns full item", () => {
-    const item = createInboxItem();
-    const result = projectInboxItem(item, "detailed");
-
-    expect(result).toBe(item);
-    expect(result).toHaveProperty("source");
-  });
-});
-
-describe("projectInboxItems", () => {
-  test("projects and limits inbox items", () => {
-    const items = [
-      createInboxItem({ id: "i1" }),
-      createInboxItem({ id: "i2" }),
-      createInboxItem({ id: "i3" }),
-    ];
-    const result = projectInboxItems(items, "concise", 2);
-
-    expect(result).toHaveLength(2);
-    expect(result.map((i) => i.id)).toEqual(["i1", "i2"]);
-  });
-});
-
-describe("formatResponse", () => {
-  test("returns JSON for concise format", () => {
-    const data = { id: "1", name: "test" };
-    const result = formatResponse(data, "concise");
-
-    expect(result).toBe(JSON.stringify(data));
-  });
-
-  test("returns JSON for standard format", () => {
-    const data = [{ id: "1" }, { id: "2" }];
-    const result = formatResponse(data, "standard");
-
-    expect(result).toBe(JSON.stringify(data));
-  });
-
-  test("uses detailedFormatter for detailed format", () => {
-    const data = { id: "1", name: "test" };
-    const formatter = (d: typeof data | (typeof data)[]) => {
-      if (Array.isArray(d)) return d.map((i) => `${i.id}`).join(",");
-      return `ID: ${d.id}, Name: ${d.name}`;
-    };
-    const result = formatResponse(data, "detailed", formatter);
-
-    expect(result).toBe("ID: 1, Name: test");
-  });
-
-  test("falls back to JSON if no detailedFormatter provided", () => {
-    const data = { id: "1" };
-    const result = formatResponse(data, "detailed");
-
-    expect(result).toBe(JSON.stringify(data));
-  });
-});
-
-describe("applyPagination", () => {
-  test("applies limit and offset correctly", () => {
-    const items = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
-    const result = applyPagination(items, 3, 2);
-
-    expect(result.items).toEqual([3, 4, 5]);
-    expect(result.hasMore).toBe(true);
-    expect(result.total).toBe(10);
-  });
-
-  test("enforces max limit of 100", () => {
-    const items = Array.from({ length: 200 }, (_, i) => i);
-    const result = applyPagination(items, 150);
-
-    expect(result.items).toHaveLength(100);
-  });
-
-  test("enforces min limit of 1", () => {
-    const items = [1, 2, 3];
-    const result = applyPagination(items, 0);
-
-    expect(result.items).toHaveLength(1);
-  });
-
-  test("handles negative offset as 0", () => {
-    const items = [1, 2, 3];
-    const result = applyPagination(items, 10, -5);
-
-    expect(result.items).toEqual([1, 2, 3]);
-  });
-
-  test("uses default values", () => {
-    const items = Array.from({ length: 50 }, (_, i) => i);
-    const result = applyPagination(items);
-
-    expect(result.items).toHaveLength(20);
-    expect(result.items[0]).toBe(0);
-  });
-});
-
-describe("truncate", () => {
-  test("returns original string if under max length", () => {
-    const result = truncate("short", 100);
-    expect(result).toBe("short");
-  });
-
-  test("truncates and adds ellipsis", () => {
-    const result = truncate("this is a very long string", 10);
-    expect(result).toBe("this is...");
-    expect(result.length).toBe(10);
-  });
-
-  test("uses default max length of 100", () => {
-    const longString = "a".repeat(150);
-    const result = truncate(longString);
-
-    expect(result.length).toBe(100);
-    expect(result.endsWith("...")).toBe(true);
-  });
-
-  test("handles empty string", () => {
-    const result = truncate("");
-    expect(result).toBe("");
-  });
-
-  test("handles string exactly at max length", () => {
-    const str = "a".repeat(100);
-    const result = truncate(str, 100);
-
-    expect(result).toBe(str);
-  });
-});
-
-describe("summarizeList", () => {
-  test("returns displayed items and remaining count", () => {
-    const items = [
-      { id: "1", name: "A" },
-      { id: "2", name: "B" },
-      { id: "3", name: "C" },
-      { id: "4", name: "D" },
-      { id: "5", name: "E" },
-      { id: "6", name: "F" },
-      { id: "7", name: "G" },
-    ];
-
-    const result = summarizeList(items, 3, (i) => i.id);
-
-    expect(result.displayed).toHaveLength(3);
-    expect(result.remaining).toBe(4);
-    expect(result.remainingIds).toEqual(["4", "5", "6", "7"]);
-  });
-
-  test("returns all items if under maxDisplay", () => {
-    const items = [{ id: "1" }, { id: "2" }];
-    const result = summarizeList(items, 5, (i) => i.id);
-
-    expect(result.displayed).toHaveLength(2);
-    expect(result.remaining).toBe(0);
-    expect(result.remainingIds).toEqual([]);
-  });
-
-  test("uses default maxDisplay of 5", () => {
-    const items = Array.from({ length: 10 }, (_, i) => ({ id: `${i}` }));
-    const result = summarizeList(items, undefined, (i) => i.id);
-
-    expect(result.displayed).toHaveLength(5);
-    expect(result.remaining).toBe(5);
-  });
-
-  test("handles empty list", () => {
-    const result = summarizeList([], 5, (i: { id: string }) => i.id);
-
-    expect(result.displayed).toEqual([]);
-    expect(result.remaining).toBe(0);
-    expect(result.remainingIds).toEqual([]);
-  });
-});
-
-// Token efficiency verification tests
-describe("token efficiency", () => {
-  test("concise task is significantly smaller than full task", () => {
-    const task = createTask({
-      description: "A very long description ".repeat(10),
-      estimate: { expected: 60, optimistic: 30, pessimistic: 120 },
-      dependencies: [
-        { taskId: "d1", type: "blocked_by" },
-        { taskId: "d2", type: "blocked_by" },
-      ],
-    });
-
-    const concise = projectTask(task, "concise");
-    const full = projectTask(task, "detailed");
-
-    const conciseSize = JSON.stringify(concise).length;
-    const fullSize = JSON.stringify(full).length;
-
-    // Concise should be at least 50% smaller
-    expect(conciseSize).toBeLessThan(fullSize * 0.5);
-  });
-
-  test("concise list is significantly smaller than full list", () => {
-    const tasks = Array.from({ length: 20 }, (_, i) =>
-      createTask({
-        id: `task-${i}`,
-        title: `Task ${i}: Do something important`,
-        description: "Detailed description of what needs to be done ".repeat(5),
-        estimate: { expected: 60, optimistic: 30, pessimistic: 120 },
-      })
-    );
-
-    const concise = projectTasks(tasks, "concise");
-    const full = projectTasks(tasks, "detailed");
-
-    const conciseSize = JSON.stringify(concise).length;
-    const fullSize = JSON.stringify(full).length;
-
-    // For list of 20 tasks, concise should be 70%+ smaller
-    expect(conciseSize).toBeLessThan(fullSize * 0.4);
-  });
-});