@task-mcp/shared 1.0.4 → 1.0.7

package/src/utils/natural-language.ts

@@ -1,6 +1,118 @@
 import type { Priority, TaskCreateInput } from "../schemas/task.js";
+import type { InboxCreateInput } from "../schemas/inbox.js";
 import { parseRelativeDate, formatDate } from "./date.js";
 
+/**
+ * Maximum allowed input length for natural language parsing.
+ * Prevents DoS attacks from extremely long input strings.
+ */
+export const MAX_INPUT_LENGTH = 1000;
+
+/**
+ * Error thrown when input validation fails
+ */
+export class InputValidationError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "InputValidationError";
+  }
+}
+
+/**
+ * Validates input string length
+ * @throws {InputValidationError} if input exceeds MAX_INPUT_LENGTH
+ */
+function validateInputLength(input: string): void {
+  if (input.length > MAX_INPUT_LENGTH) {
+    throw new InputValidationError(
+      `Input exceeds maximum length of ${MAX_INPUT_LENGTH} characters (received ${input.length})`
+    );
+  }
+}
+
+/**
+ * Target type for parsed input
+ */
+export type ParseTarget = "task" | "inbox";
+
+/**
+ * Extended parse result with target information
+ */
+export interface ParsedInput {
+  target: ParseTarget;
+  task?: TaskCreateInput;
+  inbox?: InboxCreateInput;
+}
+
+/**
+ * Parse natural language input with target detection
+ *
+ * Target keywords:
+ * - >>inbox, >>메모, >>아이디어 → capture to inbox
+ * - >>task, >>태스크 (default) → create task
+ *
+ * Examples:
+ * - "API 리팩토링 아이디어 >>inbox #backend"
+ * - "Review PR tomorrow #dev !high" (default: task)
+ * - "새 기능 구상 >>메모"
+ */
+export function parseInput(input: string): ParsedInput {
+  validateInputLength(input);
+  let remaining = input.trim();
+  let target: ParseTarget = "task";
+
+  // Detect target keywords (>>inbox, >>task, >>메모, >>아이디어, >>태스크)
+  const targetMatch = remaining.match(/>>(inbox|task|메모|아이디어|태스크)/i);
+  if (targetMatch) {
+    const keyword = targetMatch[1]!.toLowerCase();
+    if (keyword === "inbox" || keyword === "메모" || keyword === "아이디어") {
+      target = "inbox";
+    } else {
+      target = "task";
+    }
+    remaining = remaining.replace(targetMatch[0], "").trim();
+  }
+
+  if (target === "inbox") {
+    return {
+      target: "inbox",
+      inbox: parseInboxInput(remaining),
+    };
+  }
+
+  return {
+    target: "task",
+    task: parseTaskInput(remaining),
+  };
+}
+
+/**
+ * Parse natural language inbox input
+ *
+ * Examples:
+ * - "GraphQL 도입 검토 #backend #연구"
+ * - "성능 개선 아이디어 #performance"
+ */
+export function parseInboxInput(input: string): InboxCreateInput {
+  validateInputLength(input);
+  let remaining = input.trim();
+  const result: InboxCreateInput = { content: "" };
+
+  // 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();
+    }
+  }
+
+  // Clean up and set content
+  result.content = remaining.replace(/\s+/g, " ").trim();
+
+  return result;
+}
+
 /**
  * Parse natural language task input
  *
@@ -11,6 +123,7 @@ import { parseRelativeDate, formatDate } from "./date.js";
  * - "Write tests every Monday #testing"
  */
 export function parseTaskInput(input: string): TaskCreateInput {
+  validateInputLength(input);
   let remaining = input.trim();
   const result: TaskCreateInput = { title: "" };
 

package/src/utils/projection.test.ts

@@ -0,0 +1,505 @@
+import { describe, test, expect } from "bun:test";
+import {
+  projectTask,
+  projectTasks,
+  projectTasksPaginated,
+  projectProject,
+  projectProjects,
+  projectInboxItem,
+  projectInboxItems,
+  formatResponse,
+  applyPagination,
+  truncate,
+  summarizeList,
+} from "./projection.js";
+import type { Task } from "../schemas/task.js";
+import type { Project } from "../schemas/project.js";
+import type { InboxItem } from "../schemas/inbox.js";
+
+// Test fixtures
+const createTask = (overrides: Partial<Task> = {}): Task => {
+  const base: Task = {
+    id: "task-1",
+    projectId: "project-1",
+    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 createProject = (overrides: Partial<Project> = {}): Project => ({
+  id: "proj-1",
+  name: "Test Project",
+  status: "active",
+  createdAt: "2025-01-01T00:00:00.000Z",
+  updatedAt: "2025-01-01T00:00:00.000Z",
+  completionPercentage: 50,
+  description: "A test project",
+  totalTasks: 10,
+  completedTasks: 5,
+  ...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("projectProject", () => {
+  test("concise format returns essential fields", () => {
+    const project = createProject();
+    const result = projectProject(project, "concise");
+
+    expect(result).toEqual({
+      id: "proj-1",
+      name: "Test Project",
+      status: "active",
+      completionPercentage: 50,
+    });
+  });
+
+  test("concise format omits undefined completionPercentage", () => {
+    // Create project without completionPercentage by deleting it
+    const project = createProject();
+    delete (project as Record<string, unknown>)["completionPercentage"];
+    const result = projectProject(project, "concise");
+
+    expect(result).not.toHaveProperty("completionPercentage");
+  });
+
+  test("standard format includes more fields", () => {
+    const project = createProject();
+    const result = projectProject(project, "standard");
+
+    expect(result).toHaveProperty("id");
+    expect(result).toHaveProperty("name");
+    expect(result).toHaveProperty("status");
+    expect(result).toHaveProperty("completionPercentage");
+    expect(result).toHaveProperty("description");
+    expect(result).toHaveProperty("totalTasks");
+    expect(result).toHaveProperty("completedTasks");
+  });
+
+  test("detailed format returns full project", () => {
+    const project = createProject();
+    const result = projectProject(project, "detailed");
+
+    expect(result).toBe(project);
+  });
+});
+
+describe("projectProjects", () => {
+  test("projects all projects without limit", () => {
+    const projects = [createProject({ id: "p1" }), createProject({ id: "p2" })];
+    const result = projectProjects(projects, "concise");
+
+    expect(result).toHaveLength(2);
+  });
+
+  test("limits projects when limit provided", () => {
+    const projects = [
+      createProject({ id: "p1" }),
+      createProject({ id: "p2" }),
+      createProject({ id: "p3" }),
+    ];
+    const result = projectProjects(projects, "concise", 1);
+
+    expect(result).toHaveLength(1);
+    expect(result[0]?.id).toBe("p1");
+  });
+});
+
+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);
+  });
+});