@task-mcp/shared 1.0.19 → 1.0.21

package/src/utils/hierarchy.test.ts

@@ -1,411 +0,0 @@
-import { describe, test, expect } from "bun:test";
-import {
-  MAX_HIERARCHY_DEPTH,
-  getTaskLevel,
-  validateHierarchyDepth,
-  getAncestorIds,
-  getDescendantIds,
-  getChildTasks,
-  getRootTask,
-  buildTaskTree,
-} from "./hierarchy.js";
-import type { Task } from "../schemas/task.js";
-
-// Helper to create mock tasks
-function createTask(
-  id: string,
-  parentId?: string,
-  overrides: Partial<Task> = {}
-): Task {
-  return {
-    id,
-    title: `Task ${id}`,
-    status: "pending",
-    priority: "medium",
-    workspace: "test-workspace",
-    createdAt: new Date().toISOString(),
-    updatedAt: new Date().toISOString(),
-    parentId,
-    ...overrides,
-  };
-}
-
-describe("MAX_HIERARCHY_DEPTH", () => {
-  test("is set to 3", () => {
-    expect(MAX_HIERARCHY_DEPTH).toBe(3);
-  });
-});
-
-describe("getTaskLevel", () => {
-  test("returns -1 for non-existent task", () => {
-    const tasks = [createTask("A")];
-    expect(getTaskLevel(tasks, "nonexistent")).toBe(-1);
-  });
-
-  test("returns 0 for root task (no parent)", () => {
-    const tasks = [createTask("A")];
-    expect(getTaskLevel(tasks, "A")).toBe(0);
-  });
-
-  test("returns 1 for direct child", () => {
-    const tasks = [createTask("A"), createTask("B", "A")];
-    expect(getTaskLevel(tasks, "B")).toBe(1);
-  });
-
-  test("returns 2 for grandchild", () => {
-    const tasks = [createTask("A"), createTask("B", "A"), createTask("C", "B")];
-    expect(getTaskLevel(tasks, "C")).toBe(2);
-  });
-
-  test("returns 3 for great-grandchild", () => {
-    const tasks = [
-      createTask("A"),
-      createTask("B", "A"),
-      createTask("C", "B"),
-      createTask("D", "C"),
-    ];
-    expect(getTaskLevel(tasks, "D")).toBe(3);
-  });
-
-  test("handles missing parent gracefully", () => {
-    // Task B references non-existent parent "missing"
-    const tasks = [createTask("A"), createTask("B", "missing")];
-    // Should return 0 since parent lookup fails immediately
-    expect(getTaskLevel(tasks, "B")).toBe(0);
-  });
-
-  test("handles broken chain (middle parent missing)", () => {
-    // C -> B -> A, but B is missing
-    const tasks = [createTask("A"), createTask("C", "B")];
-    // C's parent "B" doesn't exist, so level stays 0
-    expect(getTaskLevel(tasks, "C")).toBe(0);
-  });
-});
-
-describe("validateHierarchyDepth", () => {
-  test("returns false for non-existent parent", () => {
-    const tasks = [createTask("A")];
-    expect(validateHierarchyDepth(tasks, "nonexistent")).toBe(false);
-  });
-
-  test("returns true when parent is at level 0", () => {
-    const tasks = [createTask("A")];
-    // Can add child at level 1
-    expect(validateHierarchyDepth(tasks, "A")).toBe(true);
-  });
-
-  test("returns true when parent is at level 1", () => {
-    const tasks = [createTask("A"), createTask("B", "A")];
-    // Can add child at level 2
-    expect(validateHierarchyDepth(tasks, "B")).toBe(true);
-  });
-
-  test("returns true when parent is at level 2", () => {
-    const tasks = [createTask("A"), createTask("B", "A"), createTask("C", "B")];
-    // Can add child at level 3 (MAX_HIERARCHY_DEPTH)
-    expect(validateHierarchyDepth(tasks, "C")).toBe(true);
-  });
-
-  test("returns false when parent is at level 3 (max depth)", () => {
-    const tasks = [
-      createTask("A"),
-      createTask("B", "A"),
-      createTask("C", "B"),
-      createTask("D", "C"),
-    ];
-    // D is at level 3, cannot add child at level 4
-    expect(validateHierarchyDepth(tasks, "D")).toBe(false);
-  });
-});
-
-describe("getAncestorIds", () => {
-  test("returns empty array for non-existent task", () => {
-    const tasks = [createTask("A")];
-    expect(getAncestorIds(tasks, "nonexistent")).toEqual([]);
-  });
-
-  test("returns empty array for root task", () => {
-    const tasks = [createTask("A")];
-    expect(getAncestorIds(tasks, "A")).toEqual([]);
-  });
-
-  test("returns single ancestor for direct child", () => {
-    const tasks = [createTask("A"), createTask("B", "A")];
-    expect(getAncestorIds(tasks, "B")).toEqual(["A"]);
-  });
-
-  test("returns ancestors ordered from immediate parent to root", () => {
-    const tasks = [
-      createTask("A"),
-      createTask("B", "A"),
-      createTask("C", "B"),
-      createTask("D", "C"),
-    ];
-    expect(getAncestorIds(tasks, "D")).toEqual(["C", "B", "A"]);
-  });
-
-  test("handles missing ancestor in chain", () => {
-    // C -> B -> missing
-    const tasks = [createTask("B", "missing"), createTask("C", "B")];
-    // Returns B and "missing" (the parentId), then stops when "missing" lookup fails
-    expect(getAncestorIds(tasks, "C")).toEqual(["B", "missing"]);
-  });
-});
-
-describe("getDescendantIds", () => {
-  test("returns empty array for task with no children", () => {
-    const tasks = [createTask("A"), createTask("B")];
-    expect(getDescendantIds(tasks, "A")).toEqual([]);
-  });
-
-  test("returns direct children", () => {
-    const tasks = [createTask("A"), createTask("B", "A"), createTask("C", "A")];
-    const descendants = getDescendantIds(tasks, "A");
-    expect(descendants.sort()).toEqual(["B", "C"]);
-  });
-
-  test("returns all descendants (children and grandchildren)", () => {
-    const tasks = [
-      createTask("A"),
-      createTask("B", "A"),
-      createTask("C", "A"),
-      createTask("D", "B"),
-      createTask("E", "B"),
-    ];
-    const descendants = getDescendantIds(tasks, "A");
-    expect(descendants.sort()).toEqual(["B", "C", "D", "E"]);
-  });
-
-  test("returns descendants in BFS order", () => {
-    const tasks = [
-      createTask("A"),
-      createTask("B", "A"),
-      createTask("C", "A"),
-      createTask("D", "B"),
-    ];
-    const descendants = getDescendantIds(tasks, "A");
-    // BFS: first level (B, C), then second level (D)
-    // B and C come before D
-    const dIndex = descendants.indexOf("D");
-    const bIndex = descendants.indexOf("B");
-    const cIndex = descendants.indexOf("C");
-    expect(bIndex).toBeLessThan(dIndex);
-    expect(cIndex).toBeLessThan(dIndex);
-  });
-
-  test("returns empty array for non-existent task", () => {
-    const tasks = [createTask("A")];
-    expect(getDescendantIds(tasks, "nonexistent")).toEqual([]);
-  });
-});
-
-describe("getChildTasks", () => {
-  test("returns empty array for task with no children", () => {
-    const tasks = [createTask("A"), createTask("B")];
-    expect(getChildTasks(tasks, "A")).toEqual([]);
-  });
-
-  test("returns only direct children", () => {
-    const tasks = [
-      createTask("A"),
-      createTask("B", "A"),
-      createTask("C", "A"),
-      createTask("D", "B"), // grandchild, should not be included
-    ];
-    const children = getChildTasks(tasks, "A");
-    expect(children.map((t) => t.id).sort()).toEqual(["B", "C"]);
-  });
-
-  test("returns empty array for non-existent parent", () => {
-    const tasks = [createTask("A")];
-    expect(getChildTasks(tasks, "nonexistent")).toEqual([]);
-  });
-
-  test("returns full task objects", () => {
-    const tasks = [createTask("A"), createTask("B", "A", { title: "Custom Title" })];
-    const children = getChildTasks(tasks, "A");
-    expect(children.length).toBe(1);
-    expect(children[0]!.id).toBe("B");
-    expect(children[0]!.title).toBe("Custom Title");
-  });
-});
-
-describe("getRootTask", () => {
-  test("returns null for non-existent task", () => {
-    const tasks = [createTask("A")];
-    expect(getRootTask(tasks, "nonexistent")).toBeNull();
-  });
-
-  test("returns the task itself if it has no parent", () => {
-    const tasks = [createTask("A")];
-    const root = getRootTask(tasks, "A");
-    expect(root?.id).toBe("A");
-  });
-
-  test("returns root for direct child", () => {
-    const tasks = [createTask("A"), createTask("B", "A")];
-    const root = getRootTask(tasks, "B");
-    expect(root?.id).toBe("A");
-  });
-
-  test("returns root for deeply nested task", () => {
-    const tasks = [
-      createTask("A"),
-      createTask("B", "A"),
-      createTask("C", "B"),
-      createTask("D", "C"),
-    ];
-    const root = getRootTask(tasks, "D");
-    expect(root?.id).toBe("A");
-  });
-
-  test("handles broken chain (returns earliest found task)", () => {
-    // C -> B -> missing
-    const tasks = [createTask("B", "missing"), createTask("C", "B")];
-    const root = getRootTask(tasks, "C");
-    // B's parent "missing" doesn't exist, so B is the root
-    expect(root?.id).toBe("B");
-  });
-});
-
-describe("buildTaskTree", () => {
-  test("returns empty array for empty task list", () => {
-    expect(buildTaskTree([])).toEqual([]);
-  });
-
-  test("returns single root task as tree", () => {
-    const tasks = [createTask("A")];
-    const tree = buildTaskTree(tasks);
-    expect(tree.length).toBe(1);
-    expect(tree[0]!.task.id).toBe("A");
-    expect(tree[0]!.children).toEqual([]);
-  });
-
-  test("builds tree with children", () => {
-    const tasks = [createTask("A"), createTask("B", "A"), createTask("C", "A")];
-    const tree = buildTaskTree(tasks);
-    expect(tree.length).toBe(1);
-    expect(tree[0]!.task.id).toBe("A");
-    expect(tree[0]!.children.length).toBe(2);
-    expect(tree[0]!.children.map((c) => c.task.id).sort()).toEqual(["B", "C"]);
-  });
-
-  test("builds nested tree structure", () => {
-    const tasks = [
-      createTask("A"),
-      createTask("B", "A"),
-      createTask("C", "B"),
-      createTask("D", "C"),
-    ];
-    const tree = buildTaskTree(tasks);
-    expect(tree.length).toBe(1);
-    expect(tree[0]!.task.id).toBe("A");
-    expect(tree[0]!.children.length).toBe(1);
-    expect(tree[0]!.children[0]!.task.id).toBe("B");
-    expect(tree[0]!.children[0]!.children.length).toBe(1);
-    expect(tree[0]!.children[0]!.children[0]!.task.id).toBe("C");
-    expect(tree[0]!.children[0]!.children[0]!.children.length).toBe(1);
-    expect(tree[0]!.children[0]!.children[0]!.children[0]!.task.id).toBe("D");
-  });
-
-  test("returns multiple root tasks", () => {
-    const tasks = [createTask("A"), createTask("B"), createTask("C")];
-    const tree = buildTaskTree(tasks);
-    expect(tree.length).toBe(3);
-    expect(tree.map((n) => n.task.id).sort()).toEqual(["A", "B", "C"]);
-  });
-
-  test("builds tree from specific root", () => {
-    const tasks = [
-      createTask("A"),
-      createTask("B", "A"),
-      createTask("C", "B"),
-      createTask("X"),
-      createTask("Y", "X"),
-    ];
-    const tree = buildTaskTree(tasks, "A");
-    expect(tree.length).toBe(1);
-    expect(tree[0]!.task.id).toBe("A");
-    expect(tree[0]!.children.length).toBe(1);
-    expect(tree[0]!.children[0]!.task.id).toBe("B");
-  });
-
-  test("returns empty array for non-existent root", () => {
-    const tasks = [createTask("A")];
-    const tree = buildTaskTree(tasks, "nonexistent");
-    expect(tree).toEqual([]);
-  });
-
-  test("can build subtree from middle of hierarchy", () => {
-    const tasks = [
-      createTask("A"),
-      createTask("B", "A"),
-      createTask("C", "B"),
-      createTask("D", "B"),
-    ];
-    const tree = buildTaskTree(tasks, "B");
-    expect(tree.length).toBe(1);
-    expect(tree[0]!.task.id).toBe("B");
-    expect(tree[0]!.children.length).toBe(2);
-    expect(tree[0]!.children.map((c) => c.task.id).sort()).toEqual(["C", "D"]);
-  });
-
-  test("respects maxDepth parameter", () => {
-    const tasks = [
-      createTask("A"),
-      createTask("B", "A"),
-      createTask("C", "B"),
-      createTask("D", "C"),
-    ];
-    // maxDepth of 2 should include A (depth 0), B (depth 1), but stop children at C
-    const tree = buildTaskTree(tasks, "A", 2);
-    expect(tree.length).toBe(1);
-    expect(tree[0]!.task.id).toBe("A");
-    expect(tree[0]!.children.length).toBe(1);
-    expect(tree[0]!.children[0]!.task.id).toBe("B");
-    // C should be included but with no children (depth 2 is the limit)
-    expect(tree[0]!.children[0]!.children.length).toBe(1);
-    expect(tree[0]!.children[0]!.children[0]!.task.id).toBe("C");
-    expect(tree[0]!.children[0]!.children[0]!.children).toEqual([]);
-  });
-
-  test("handles circular references gracefully", () => {
-    // Create tasks with circular reference: A -> B -> C -> A
-    const taskA = createTask("A", "C");
-    const taskB = createTask("B", "A");
-    const taskC = createTask("C", "B");
-    const tasks = [taskA, taskB, taskC];
-
-    // Should not throw or hang - circular ref is detected
-    const tree = buildTaskTree(tasks);
-    // All tasks have parents, so no "root" tasks exist
-    expect(tree).toEqual([]);
-  });
-
-  test("handles self-referencing task", () => {
-    // Task references itself as parent
-    const selfRef = createTask("A", "A");
-    const tasks = [selfRef];
-
-    // No root tasks (A has parent), should return empty
-    const tree = buildTaskTree(tasks);
-    expect(tree).toEqual([]);
-  });
-
-  test("handles circular reference when building from specific root", () => {
-    // A -> B -> A (circular)
-    const taskA = createTask("A");
-    const taskB = createTask("B", "A");
-    // Manually create circular: make A's children include B which points back
-    // by creating a scenario where childrenMap would loop
-    const tasks = [taskA, taskB];
-    // Simulate circular by modifying childrenMap behavior won't work directly,
-    // but we can test that visited set prevents infinite recursion
-    // Let's create a more direct test case
-    const tree = buildTaskTree(tasks, "A");
-    expect(tree.length).toBe(1);
-    expect(tree[0]!.task.id).toBe("A");
-    expect(tree[0]!.children.length).toBe(1);
-    expect(tree[0]!.children[0]!.task.id).toBe("B");
-  });
-});

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);
-  });
-});