@task-mcp/shared 1.0.20 → 1.0.21

package/src/utils/id.test.ts

@@ -1,235 +0,0 @@
-import { describe, test, expect } from "bun:test";
-import {
-  generateId,
-  generateTaskId,
-  generateInboxId,
-  isValidTaskId,
-  isValidInboxId,
-  validateTaskId,
-  validateInboxId,
-  assertValidTaskId,
-  assertValidInboxId,
-  InvalidIdError,
-} from "./id.js";
-
-describe("ID Generation", () => {
-  describe("generateId", () => {
-    test("generates ID without prefix", () => {
-      const id = generateId();
-      expect(id.length).toBe(12);
-      expect(/^[a-z0-9]+$/.test(id)).toBe(true);
-    });
-
-    test("generates ID with prefix", () => {
-      const id = generateId("test");
-      expect(id).toMatch(/^test_[a-z0-9]+$/);
-    });
-
-    test("generates unique IDs", () => {
-      const ids = new Set(Array.from({ length: 100 }, () => generateId("test")));
-      expect(ids.size).toBe(100);
-    });
-  });
-
-  describe("generateTaskId", () => {
-    test("generates task ID with correct prefix", () => {
-      const id = generateTaskId();
-      expect(id).toMatch(/^task_[a-z0-9]+$/);
-    });
-  });
-
-  describe("generateInboxId", () => {
-    test("generates inbox ID with correct prefix", () => {
-      const id = generateInboxId();
-      expect(id).toMatch(/^inbox_[a-z0-9]+$/);
-    });
-  });
-});
-
-describe("Simple ID Validation (boolean)", () => {
-  describe("isValidTaskId", () => {
-    test("returns true for valid task IDs", () => {
-      expect(isValidTaskId("task_abc123")).toBe(true);
-      expect(isValidTaskId("task_a")).toBe(true);
-      expect(isValidTaskId("task_123")).toBe(true);
-      expect(isValidTaskId("task_abc123def456")).toBe(true);
-    });
-
-    test("returns false for invalid task IDs", () => {
-      expect(isValidTaskId("")).toBe(false);
-      expect(isValidTaskId("task_")).toBe(false);
-      expect(isValidTaskId("abc123")).toBe(false);
-      expect(isValidTaskId("proj_abc123")).toBe(false);
-      expect(isValidTaskId("task_ABC123")).toBe(false);
-      expect(isValidTaskId("task_abc-123")).toBe(false);
-      expect(isValidTaskId("task_abc.123")).toBe(false);
-      expect(isValidTaskId("task_abc/123")).toBe(false);
-      expect(isValidTaskId("task_abc 123")).toBe(false);
-    });
-  });
-
-  describe("isValidInboxId", () => {
-    test("returns true for valid inbox IDs", () => {
-      expect(isValidInboxId("inbox_abc123")).toBe(true);
-      expect(isValidInboxId("inbox_a")).toBe(true);
-    });
-
-    test("returns false for invalid inbox IDs", () => {
-      expect(isValidInboxId("")).toBe(false);
-      expect(isValidInboxId("in_abc123")).toBe(false);
-      expect(isValidInboxId("task_abc123")).toBe(false);
-    });
-  });
-});
-
-describe("Detailed ID Validation", () => {
-  describe("validateTaskId", () => {
-    test("returns valid: true for valid task IDs", () => {
-      expect(validateTaskId("task_abc123")).toEqual({ valid: true });
-      expect(validateTaskId("task_a1b2c3")).toEqual({ valid: true });
-    });
-
-    test("returns error for null/undefined", () => {
-      const result = validateTaskId(null);
-      expect(result.valid).toBe(false);
-      expect(result.reason).toContain("required");
-
-      const result2 = validateTaskId(undefined);
-      expect(result2.valid).toBe(false);
-    });
-
-    test("returns error for non-string", () => {
-      const result = validateTaskId(123);
-      expect(result.valid).toBe(false);
-      expect(result.reason).toContain("string");
-      expect(result.reason).toContain("number");
-    });
-
-    test("returns error for empty string", () => {
-      const result = validateTaskId("");
-      expect(result.valid).toBe(false);
-      expect(result.reason).toContain("empty");
-    });
-
-    test("returns error for missing prefix", () => {
-      const result = validateTaskId("abc123");
-      expect(result.valid).toBe(false);
-      expect(result.reason).toContain("task_");
-    });
-
-    test("returns error for wrong prefix", () => {
-      const result = validateTaskId("proj_abc123");
-      expect(result.valid).toBe(false);
-      expect(result.reason).toContain("task_");
-    });
-
-    test("returns error for invalid characters", () => {
-      const result = validateTaskId("task_abc-123");
-      expect(result.valid).toBe(false);
-      expect(result.reason).toContain("invalid characters");
-    });
-  });
-
-  describe("validateInboxId", () => {
-    test("returns valid: true for valid inbox IDs", () => {
-      expect(validateInboxId("inbox_abc123")).toEqual({ valid: true });
-    });
-
-    test("returns error for missing prefix", () => {
-      const result = validateInboxId("in_abc");
-      expect(result.valid).toBe(false);
-      expect(result.reason).toContain("inbox_");
-    });
-  });
-});
-
-describe("Assert Functions", () => {
-  describe("assertValidTaskId", () => {
-    test("does not throw for valid ID", () => {
-      expect(() => assertValidTaskId("task_abc123")).not.toThrow();
-    });
-
-    test("throws InvalidIdError for invalid ID", () => {
-      expect(() => assertValidTaskId("")).toThrow(InvalidIdError);
-      expect(() => assertValidTaskId("abc123")).toThrow(InvalidIdError);
-      expect(() => assertValidTaskId(null)).toThrow(InvalidIdError);
-    });
-
-    test("InvalidIdError contains correct properties", () => {
-      try {
-        assertValidTaskId("invalid");
-      } catch (error) {
-        expect(error).toBeInstanceOf(InvalidIdError);
-        if (error instanceof InvalidIdError) {
-          expect(error.idType).toBe("task");
-          expect(error.invalidValue).toBe("invalid");
-          expect(error.reason).toBeDefined();
-          expect(error.message).toContain("task");
-        }
-      }
-    });
-  });
-
-  describe("assertValidInboxId", () => {
-    test("does not throw for valid ID", () => {
-      expect(() => assertValidInboxId("inbox_abc123")).not.toThrow();
-    });
-
-    test("throws InvalidIdError for invalid ID", () => {
-      expect(() => assertValidInboxId("in_abc")).toThrow(InvalidIdError);
-    });
-  });
-});
-
-describe("InvalidIdError", () => {
-  test("extends Error", () => {
-    const error = new InvalidIdError("task", "bad_id", "test reason");
-    expect(error).toBeInstanceOf(Error);
-    expect(error).toBeInstanceOf(InvalidIdError);
-  });
-
-  test("has correct name", () => {
-    const error = new InvalidIdError("task", "bad_id", "test reason");
-    expect(error.name).toBe("InvalidIdError");
-  });
-
-  test("has correct message format", () => {
-    const error = new InvalidIdError("task", "bad_id", "test reason");
-    expect(error.message).toBe("Invalid task ID: test reason");
-  });
-
-  test("exposes idType, invalidValue, and reason", () => {
-    const error = new InvalidIdError("task", "wrong", "missing prefix");
-    expect(error.idType).toBe("task");
-    expect(error.invalidValue).toBe("wrong");
-    expect(error.reason).toBe("missing prefix");
-  });
-});
-
-describe("Security: ID Injection Prevention", () => {
-  test("rejects path traversal attempts", () => {
-    expect(validateTaskId("task_../etc/passwd").valid).toBe(false);
-    expect(validateTaskId("task_..%2F..%2Fetc").valid).toBe(false);
-  });
-
-  test("rejects null bytes", () => {
-    expect(validateTaskId("task_abc\0def").valid).toBe(false);
-  });
-
-  test("rejects SQL injection attempts", () => {
-    expect(validateTaskId("task_'; DROP TABLE tasks;--").valid).toBe(false);
-    expect(validateTaskId("task_1 OR 1=1").valid).toBe(false);
-  });
-
-  test("rejects script injection attempts", () => {
-    expect(validateTaskId("task_<script>alert(1)</script>").valid).toBe(false);
-  });
-
-  test("only allows safe alphanumeric characters", () => {
-    // The regex ^task_[a-z0-9]+$ only allows lowercase letters and numbers
-    expect(validateTaskId("task_abc123").valid).toBe(true);
-    expect(validateTaskId("task_UPPERCASE").valid).toBe(false);
-    expect(validateTaskId("task_with_underscore").valid).toBe(false);
-    expect(validateTaskId("task_with-dash").valid).toBe(false);
-  });
-});

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

@@ -1,242 +0,0 @@
-import { describe, test, expect } from "bun:test";
-import {
-  parseTaskInput,
-  parseInboxInput,
-  InputValidationError,
-} 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();
-    });
-  });
-
-  describe("empty content validation", () => {
-    test("throws error when input contains only tags", () => {
-      expect(() => parseTaskInput("#tag #only")).toThrow(InputValidationError);
-      expect(() => parseTaskInput("#tag #only")).toThrow(
-        "Task title cannot be empty after parsing"
-      );
-    });
-
-    test("throws error when input contains only metadata", () => {
-      expect(() => parseTaskInput("#dev !high @focus")).toThrow(
-        InputValidationError
-      );
-    });
-
-    test("throws error for empty input", () => {
-      expect(() => parseTaskInput("")).toThrow(InputValidationError);
-    });
-
-    test("throws error for whitespace-only input", () => {
-      expect(() => parseTaskInput("   ")).toThrow(InputValidationError);
-    });
-  });
-});
-
-describe("parseInboxInput", () => {
-  describe("basic parsing", () => {
-    test("parses content with tags", () => {
-      const result = parseInboxInput("GraphQL 도입 검토 #backend #연구");
-      expect(result.content).toBe("GraphQL 도입 검토");
-      expect(result.tags).toEqual(["backend", "연구"]);
-    });
-
-    test("parses content without tags", () => {
-      const result = parseInboxInput("Simple idea to capture");
-      expect(result.content).toBe("Simple idea to capture");
-      expect(result.tags).toBeUndefined();
-    });
-  });
-
-  describe("empty content validation", () => {
-    test("throws error when input contains only tags", () => {
-      expect(() => parseInboxInput("#tag #only")).toThrow(InputValidationError);
-      expect(() => parseInboxInput("#tag #only")).toThrow(
-        "Content cannot be empty after parsing"
-      );
-    });
-
-    test("throws error for empty input", () => {
-      expect(() => parseInboxInput("")).toThrow(InputValidationError);
-    });
-
-    test("throws error for whitespace-only input", () => {
-      expect(() => parseInboxInput("   ")).toThrow(InputValidationError);
-    });
-  });
-});

package/src/utils/priority-queue.test.ts

@@ -1,103 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { PriorityQueue } from "./priority-queue";
-
-describe("PriorityQueue", () => {
-  test("creates empty queue", () => {
-    const pq = new PriorityQueue<number>((a, b) => a - b);
-    expect(pq.length).toBe(0);
-    expect(pq.isEmpty()).toBe(true);
-  });
-
-  test("pop from empty queue returns undefined", () => {
-    const pq = new PriorityQueue<number>((a, b) => a - b);
-    expect(pq.pop()).toBeUndefined();
-  });
-
-  test("peek from empty queue returns undefined", () => {
-    const pq = new PriorityQueue<number>((a, b) => a - b);
-    expect(pq.peek()).toBeUndefined();
-  });
-
-  test("single element operations", () => {
-    const pq = new PriorityQueue<number>((a, b) => a - b);
-    pq.push(42);
-    expect(pq.length).toBe(1);
-    expect(pq.peek()).toBe(42);
-    expect(pq.pop()).toBe(42);
-    expect(pq.isEmpty()).toBe(true);
-  });
-
-  test("maintains max-heap property (higher value first with a-b comparator)", () => {
-    const pq = new PriorityQueue<number>((a, b) => a - b);
-    pq.push(5);
-    pq.push(2);
-    pq.push(8);
-    pq.push(1);
-    pq.push(9);
-
-    // Max-heap: higher values come first
-    expect(pq.pop()).toBe(9);
-    expect(pq.pop()).toBe(8);
-    expect(pq.pop()).toBe(5);
-    expect(pq.pop()).toBe(2);
-    expect(pq.pop()).toBe(1);
-  });
-
-  test("works with reversed comparator (min-heap behavior)", () => {
-    const pq = new PriorityQueue<number>((a, b) => b - a);
-    pq.push(5);
-    pq.push(2);
-    pq.push(8);
-
-    // Reversed comparator: smaller values come first
-    expect(pq.pop()).toBe(2);
-    expect(pq.pop()).toBe(5);
-    expect(pq.pop()).toBe(8);
-  });
-
-  test("works with objects", () => {
-    interface Task {
-      priority: number;
-      name: string;
-    }
-    // Higher priority value = higher priority (max-heap)
-    const pq = new PriorityQueue<Task>((a, b) => a.priority - b.priority);
-
-    pq.push({ priority: 3, name: "high" });
-    pq.push({ priority: 1, name: "low" });
-    pq.push({ priority: 2, name: "medium" });
-
-    expect(pq.pop()?.name).toBe("high");
-    expect(pq.pop()?.name).toBe("medium");
-    expect(pq.pop()?.name).toBe("low");
-  });
-
-  test("length property tracks queue size correctly", () => {
-    const pq = new PriorityQueue<number>((a, b) => a - b);
-    expect(pq.length).toBe(0);
-
-    pq.push(1);
-    expect(pq.length).toBe(1);
-
-    pq.push(2);
-    pq.push(3);
-    expect(pq.length).toBe(3);
-
-    pq.pop();
-    expect(pq.length).toBe(2);
-
-    pq.pop();
-    pq.pop();
-    expect(pq.length).toBe(0);
-  });
-
-  test("peek does not remove element", () => {
-    const pq = new PriorityQueue<number>((a, b) => a - b);
-    pq.push(5);
-    pq.push(10);
-
-    expect(pq.peek()).toBe(10);
-    expect(pq.peek()).toBe(10);
-    expect(pq.length).toBe(2);
-  });
-});