@task-mcp/shared 1.0.20 → 1.0.21

package/src/algorithms/critical-path.test.ts

@@ -1,241 +0,0 @@
-import { describe, test, expect } from "bun:test";
-import {
-  criticalPathAnalysis,
-  findParallelTasks,
-  suggestNextTask,
-} from "./critical-path.js";
-import type { Task } from "../schemas/task.js";
-
-// Helper to create mock tasks
-function createTask(
-  id: string,
-  options: {
-    priority?: string;
-    deps?: string[];
-    estimate?: number;
-    status?: string;
-    contexts?: string[];
-  } = {}
-): Task {
-  const task: Task = {
-    id,
-    title: `Task ${id}`,
-    status: (options.status ?? "pending") as Task["status"],
-    priority: (options.priority ?? "medium") as Task["priority"],
-    workspace: "test-workspace",
-    createdAt: new Date().toISOString(),
-    updatedAt: new Date().toISOString(),
-    dependencies: (options.deps ?? []).map((depId) => ({
-      taskId: depId,
-      type: "blocked_by" as const,
-    })),
-  };
-  if (options.estimate) {
-    task.estimate = { expected: options.estimate, confidence: "medium" as const };
-  }
-  if (options.contexts) {
-    task.contexts = options.contexts;
-  }
-  return task;
-}
-
-describe("criticalPathAnalysis", () => {
-  test("returns empty result for empty input", () => {
-    const result = criticalPathAnalysis([]);
-    expect(result.tasks).toEqual([]);
-    expect(result.criticalPath).toEqual([]);
-    expect(result.projectDuration).toBe(0);
-  });
-
-  test("returns empty for all completed tasks", () => {
-    const tasks = [createTask("A", { status: "completed" })];
-    const result = criticalPathAnalysis(tasks);
-    expect(result.tasks).toEqual([]);
-  });
-
-  test("calculates single task correctly", () => {
-    const tasks = [createTask("A", { estimate: 60 })];
-    const result = criticalPathAnalysis(tasks);
-
-    expect(result.projectDuration).toBe(60);
-    expect(result.criticalPath.length).toBe(1);
-    expect(result.criticalPath[0]!.id).toBe("A");
-    expect(result.criticalPath[0]!.isCritical).toBe(true);
-  });
-
-  test("identifies critical path in linear chain", () => {
-    // A -> B -> C (each 30 min)
-    const tasks = [
-      createTask("A", { estimate: 30 }),
-      createTask("B", { estimate: 30, deps: ["A"] }),
-      createTask("C", { estimate: 30, deps: ["B"] }),
-    ];
-    const result = criticalPathAnalysis(tasks);
-
-    expect(result.projectDuration).toBe(90);
-    expect(result.criticalPath.length).toBe(3);
-    expect(result.criticalPath.map((t) => t.id)).toEqual(["A", "B", "C"]);
-  });
-
-  test("calculates slack for parallel tasks", () => {
-    // A (60) and B (30) both lead to C
-    // A is on critical path, B has 30 min slack
-    const tasks = [
-      createTask("A", { estimate: 60 }),
-      createTask("B", { estimate: 30 }),
-      createTask("C", { estimate: 30, deps: ["A", "B"] }),
-    ];
-    const result = criticalPathAnalysis(tasks);
-
-    expect(result.projectDuration).toBe(90); // A + C
-
-    const taskA = result.tasks.find((t) => t.id === "A")!;
-    const taskB = result.tasks.find((t) => t.id === "B")!;
-    const taskC = result.tasks.find((t) => t.id === "C")!;
-
-    expect(taskA.isCritical).toBe(true);
-    expect(taskB.slack).toBe(30); // B can start 30 min late
-    expect(taskC.isCritical).toBe(true);
-  });
-
-  test("identifies bottlenecks by dependent count", () => {
-    // A blocks B, C, D
-    const tasks = [
-      createTask("A", { estimate: 30 }),
-      createTask("B", { estimate: 30, deps: ["A"] }),
-      createTask("C", { estimate: 30, deps: ["A"] }),
-      createTask("D", { estimate: 30, deps: ["A"] }),
-    ];
-    const result = criticalPathAnalysis(tasks);
-
-    expect(result.bottlenecks.length).toBeGreaterThan(0);
-    expect(result.bottlenecks[0]!.id).toBe("A"); // A blocks the most tasks
-  });
-});
-
-describe("findParallelTasks", () => {
-  test("returns empty for empty input", () => {
-    const result = findParallelTasks([]);
-    expect(result).toEqual([]);
-  });
-
-  test("returns single group for independent tasks", () => {
-    const tasks = [
-      createTask("A"),
-      createTask("B"),
-      createTask("C"),
-    ];
-    const result = findParallelTasks(tasks);
-
-    expect(result.length).toBe(1);
-    expect(result[0]!.length).toBe(3);
-  });
-
-  test("excludes tasks with uncompleted dependencies", () => {
-    const tasks = [
-      createTask("A"),
-      createTask("B", { deps: ["A"] }),
-    ];
-    const result = findParallelTasks(tasks);
-
-    // Only A is available (B is blocked)
-    expect(result.length).toBe(1);
-    expect(result[0]!.length).toBe(1);
-    expect(result[0]![0]!.id).toBe("A");
-  });
-
-  test("includes task when dependency is completed", () => {
-    const tasks = [
-      createTask("A", { status: "completed" }),
-      createTask("B", { deps: ["A"] }),
-      createTask("C"),
-    ];
-    const result = findParallelTasks(tasks);
-
-    // B and C can run in parallel
-    expect(result.length).toBe(1);
-    expect(result[0]!.map((t) => t.id).sort()).toEqual(["B", "C"]);
-  });
-
-  test("excludes completed tasks from result", () => {
-    const tasks = [
-      createTask("A", { status: "completed" }),
-      createTask("B"),
-    ];
-    const result = findParallelTasks(tasks);
-
-    expect(result.length).toBe(1);
-    expect(result[0]!.length).toBe(1);
-    expect(result[0]![0]!.id).toBe("B");
-  });
-});
-
-describe("suggestNextTask", () => {
-  test("returns null for empty input", () => {
-    const result = suggestNextTask([]);
-    expect(result).toBeNull();
-  });
-
-  test("returns null when all tasks completed", () => {
-    const tasks = [createTask("A", { status: "completed" })];
-    const result = suggestNextTask(tasks);
-    expect(result).toBeNull();
-  });
-
-  test("prefers critical path tasks", () => {
-    // A is critical (longer), B has slack
-    const tasks = [
-      createTask("A", { estimate: 60, priority: "low" }),
-      createTask("B", { estimate: 30, priority: "high" }),
-      createTask("C", { estimate: 30, deps: ["A", "B"] }),
-    ];
-    const result = suggestNextTask(tasks);
-
-    // A is on critical path, should be suggested first
-    expect(result!.id).toBe("A");
-  });
-
-  test("filters by context when specified", () => {
-    const tasks = [
-      createTask("A", { priority: "critical", contexts: ["office"] }),
-      createTask("B", { priority: "high", contexts: ["focus"] }),
-    ];
-    const result = suggestNextTask(tasks, { contexts: ["focus"] });
-
-    expect(result!.id).toBe("B");
-  });
-
-  test("filters by max time when specified", () => {
-    const tasks = [
-      createTask("A", { estimate: 120, priority: "critical" }),
-      createTask("B", { estimate: 30, priority: "high" }),
-    ];
-    const result = suggestNextTask(tasks, { maxMinutes: 60 });
-
-    expect(result!.id).toBe("B");
-  });
-
-  test("skips blocked tasks", () => {
-    const tasks = [
-      createTask("A", { priority: "low" }),
-      createTask("B", { priority: "critical", deps: ["A"] }),
-    ];
-    const result = suggestNextTask(tasks);
-
-    // B is blocked, so A should be suggested
-    expect(result!.id).toBe("A");
-  });
-
-  test("considers tasks with more dependents", () => {
-    const tasks = [
-      createTask("A", { priority: "medium" }),
-      createTask("B", { priority: "medium" }),
-      createTask("C", { priority: "medium", deps: ["A"] }),
-      createTask("D", { priority: "medium", deps: ["A"] }),
-    ];
-    const result = suggestNextTask(tasks);
-
-    // A blocks more tasks (C and D), should be preferred over B
-    expect(result!.id).toBe("A");
-  });
-});

package/src/algorithms/dependency-integrity.test.ts

@@ -1,348 +0,0 @@
-import { describe, test, expect } from "bun:test";
-import {
-  DependencyErrorCode,
-  validateDependency,
-  findInvalidDependencies,
-  findSelfDependencies,
-  detectCircularDependencies,
-  checkDependencyIntegrity,
-} from "./dependency-integrity.js";
-import type { Task } from "../schemas/task.js";
-
-// Helper to create mock tasks
-function createTask(
-  id: string,
-  title: string = `Task ${id}`,
-  deps: Array<{ taskId: string; type: "blocked_by" | "blocks" | "related" }> = []
-): Task {
-  return {
-    id,
-    title,
-    status: "pending",
-    priority: "medium",
-    workspace: "test-workspace",
-    createdAt: new Date().toISOString(),
-    updatedAt: new Date().toISOString(),
-    dependencies: deps,
-  };
-}
-
-describe("validateDependency", () => {
-  test("returns valid for a valid dependency", () => {
-    const tasks = [createTask("A"), createTask("B")];
-    const result = validateDependency({
-      taskId: "B",
-      blockedBy: "A",
-      tasks,
-    });
-    expect(result.valid).toBe(true);
-    expect(result.errorCode).toBeUndefined();
-  });
-
-  test("rejects self-dependency", () => {
-    const tasks = [createTask("A")];
-    const result = validateDependency({
-      taskId: "A",
-      blockedBy: "A",
-      tasks,
-    });
-    expect(result.valid).toBe(false);
-    expect(result.errorCode).toBe(DependencyErrorCode.SELF_DEPENDENCY);
-    expect(result.errorMessage).toContain("cannot depend on itself");
-    expect(result.suggestion).toBeDefined();
-  });
-
-  test("rejects when task not found", () => {
-    const tasks = [createTask("A")];
-    const result = validateDependency({
-      taskId: "B",
-      blockedBy: "A",
-      tasks,
-    });
-    expect(result.valid).toBe(false);
-    expect(result.errorCode).toBe(DependencyErrorCode.TASK_NOT_FOUND);
-    expect(result.errorMessage).toContain("Task not found");
-  });
-
-  test("rejects when blocker not found", () => {
-    const tasks = [createTask("A")];
-    const result = validateDependency({
-      taskId: "A",
-      blockedBy: "B",
-      tasks,
-    });
-    expect(result.valid).toBe(false);
-    expect(result.errorCode).toBe(DependencyErrorCode.BLOCKER_NOT_FOUND);
-    expect(result.errorMessage).toContain("Blocking task not found");
-  });
-
-  test("rejects duplicate dependency", () => {
-    const tasks = [
-      createTask("A"),
-      createTask("B", "Task B", [{ taskId: "A", type: "blocked_by" }]),
-    ];
-    const result = validateDependency({
-      taskId: "B",
-      blockedBy: "A",
-      tasks,
-    });
-    expect(result.valid).toBe(false);
-    expect(result.errorCode).toBe(DependencyErrorCode.DUPLICATE_DEPENDENCY);
-    expect(result.errorMessage).toContain("already blocked by");
-  });
-
-  test("allows duplicate when checkDuplicates is false", () => {
-    const tasks = [
-      createTask("A"),
-      createTask("B", "Task B", [{ taskId: "A", type: "blocked_by" }]),
-    ];
-    const result = validateDependency({
-      taskId: "B",
-      blockedBy: "A",
-      tasks,
-      checkDuplicates: false,
-    });
-    expect(result.valid).toBe(true);
-  });
-
-  test("rejects circular dependency", () => {
-    const tasks = [
-      createTask("A", "Task A", [{ taskId: "B", type: "blocked_by" }]),
-      createTask("B"),
-    ];
-    // B is blocking A, so A blocking B would create a cycle
-    const result = validateDependency({
-      taskId: "B",
-      blockedBy: "A",
-      tasks,
-    });
-    expect(result.valid).toBe(false);
-    expect(result.errorCode).toBe(DependencyErrorCode.CIRCULAR_DEPENDENCY);
-    expect(result.errorMessage).toContain("cycle");
-    expect(result.suggestion).toContain("depends on");
-  });
-
-  test("rejects indirect circular dependency", () => {
-    const tasks = [
-      createTask("A", "Task A", [{ taskId: "B", type: "blocked_by" }]),
-      createTask("B", "Task B", [{ taskId: "C", type: "blocked_by" }]),
-      createTask("C"),
-    ];
-    // A <- B <- C, adding C <- A would create cycle
-    const result = validateDependency({
-      taskId: "C",
-      blockedBy: "A",
-      tasks,
-    });
-    expect(result.valid).toBe(false);
-    expect(result.errorCode).toBe(DependencyErrorCode.CIRCULAR_DEPENDENCY);
-  });
-});
-
-describe("findInvalidDependencies", () => {
-  test("returns empty array when all dependencies are valid", () => {
-    const tasks = [
-      createTask("A"),
-      createTask("B", "Task B", [{ taskId: "A", type: "blocked_by" }]),
-    ];
-    const result = findInvalidDependencies(tasks);
-    expect(result).toEqual([]);
-  });
-
-  test("finds orphaned dependency references", () => {
-    const tasks = [
-      createTask("A", "Task A", [{ taskId: "non-existent", type: "blocked_by" }]),
-    ];
-    const result = findInvalidDependencies(tasks);
-    expect(result.length).toBe(1);
-    expect(result[0]!.taskId).toBe("A");
-    expect(result[0]!.taskTitle).toBe("Task A");
-    expect(result[0]!.invalidDependencyId).toBe("non-existent");
-    expect(result[0]!.type).toBe("blocked_by");
-  });
-
-  test("finds multiple invalid references across tasks", () => {
-    const tasks = [
-      createTask("A", "Task A", [{ taskId: "deleted-1", type: "blocked_by" }]),
-      createTask("B", "Task B", [
-        { taskId: "A", type: "blocked_by" },
-        { taskId: "deleted-2", type: "blocks" },
-      ]),
-    ];
-    const result = findInvalidDependencies(tasks);
-    expect(result.length).toBe(2);
-    expect(result.map((r) => r.invalidDependencyId).sort()).toEqual([
-      "deleted-1",
-      "deleted-2",
-    ]);
-  });
-
-  test("returns empty array for tasks without dependencies", () => {
-    const tasks = [createTask("A"), createTask("B")];
-    const result = findInvalidDependencies(tasks);
-    expect(result).toEqual([]);
-  });
-});
-
-describe("findSelfDependencies", () => {
-  test("returns empty array when no self-dependencies exist", () => {
-    const tasks = [
-      createTask("A"),
-      createTask("B", "Task B", [{ taskId: "A", type: "blocked_by" }]),
-    ];
-    const result = findSelfDependencies(tasks);
-    expect(result).toEqual([]);
-  });
-
-  test("finds task with self-dependency", () => {
-    const tasks = [
-      createTask("A", "Task A", [{ taskId: "A", type: "blocked_by" }]),
-    ];
-    const result = findSelfDependencies(tasks);
-    expect(result).toEqual(["A"]);
-  });
-
-  test("finds multiple self-dependencies", () => {
-    const tasks = [
-      createTask("A", "Task A", [{ taskId: "A", type: "blocked_by" }]),
-      createTask("B"),
-      createTask("C", "Task C", [{ taskId: "C", type: "blocks" }]),
-    ];
-    const result = findSelfDependencies(tasks);
-    expect(result.sort()).toEqual(["A", "C"]);
-  });
-});
-
-describe("detectCircularDependencies", () => {
-  test("returns empty array when no cycles exist", () => {
-    const tasks = [
-      createTask("A"),
-      createTask("B", "Task B", [{ taskId: "A", type: "blocked_by" }]),
-      createTask("C", "Task C", [{ taskId: "B", type: "blocked_by" }]),
-    ];
-    const result = detectCircularDependencies(tasks);
-    expect(result).toEqual([]);
-  });
-
-  test("detects direct circular dependency (A -> B -> A)", () => {
-    const tasks = [
-      createTask("A", "Task A", [{ taskId: "B", type: "blocked_by" }]),
-      createTask("B", "Task B", [{ taskId: "A", type: "blocked_by" }]),
-    ];
-    const result = detectCircularDependencies(tasks);
-    expect(result.length).toBe(1);
-    expect(result[0]!.sort()).toEqual(["A", "B"]);
-  });
-
-  test("detects longer cycle (A -> B -> C -> A)", () => {
-    const tasks = [
-      createTask("A", "Task A", [{ taskId: "B", type: "blocked_by" }]),
-      createTask("B", "Task B", [{ taskId: "C", type: "blocked_by" }]),
-      createTask("C", "Task C", [{ taskId: "A", type: "blocked_by" }]),
-    ];
-    const result = detectCircularDependencies(tasks);
-    expect(result.length).toBe(1);
-    expect(result[0]!.sort()).toEqual(["A", "B", "C"]);
-  });
-
-  test("ignores non-blocking dependency types for cycle detection", () => {
-    const tasks = [
-      createTask("A", "Task A", [{ taskId: "B", type: "related" }]),
-      createTask("B", "Task B", [{ taskId: "A", type: "related" }]),
-    ];
-    const result = detectCircularDependencies(tasks);
-    expect(result).toEqual([]);
-  });
-
-  test("handles tasks with missing dependency targets", () => {
-    const tasks = [
-      createTask("A", "Task A", [{ taskId: "non-existent", type: "blocked_by" }]),
-    ];
-    const result = detectCircularDependencies(tasks);
-    expect(result).toEqual([]);
-  });
-});
-
-describe("checkDependencyIntegrity", () => {
-  test("returns valid for healthy task set", () => {
-    const tasks = [
-      createTask("A"),
-      createTask("B", "Task B", [{ taskId: "A", type: "blocked_by" }]),
-      createTask("C", "Task C", [{ taskId: "B", type: "blocked_by" }]),
-    ];
-    const result = checkDependencyIntegrity(tasks);
-    expect(result.valid).toBe(true);
-    expect(result.totalTasks).toBe(3);
-    expect(result.totalDependencies).toBe(2);
-    expect(result.issues.selfDependencies).toEqual([]);
-    expect(result.issues.invalidReferences).toEqual([]);
-    expect(result.issues.circularDependencies).toEqual([]);
-    expect(result.summary).toContain("All 2 dependencies");
-    expect(result.summary).toContain("valid");
-  });
-
-  test("detects self-dependency issues", () => {
-    const tasks = [
-      createTask("A", "Task A", [{ taskId: "A", type: "blocked_by" }]),
-    ];
-    const result = checkDependencyIntegrity(tasks);
-    expect(result.valid).toBe(false);
-    expect(result.issues.selfDependencies).toEqual(["A"]);
-    expect(result.summary).toContain("self-dependencies");
-  });
-
-  test("detects invalid reference issues", () => {
-    const tasks = [
-      createTask("A", "Task A", [{ taskId: "deleted", type: "blocked_by" }]),
-    ];
-    const result = checkDependencyIntegrity(tasks);
-    expect(result.valid).toBe(false);
-    expect(result.issues.invalidReferences.length).toBe(1);
-    expect(result.summary).toContain("invalid references");
-  });
-
-  test("detects circular dependency issues", () => {
-    const tasks = [
-      createTask("A", "Task A", [{ taskId: "B", type: "blocked_by" }]),
-      createTask("B", "Task B", [{ taskId: "A", type: "blocked_by" }]),
-    ];
-    const result = checkDependencyIntegrity(tasks);
-    expect(result.valid).toBe(false);
-    expect(result.issues.circularDependencies.length).toBe(1);
-    expect(result.summary).toContain("circular dependency");
-  });
-
-  test("reports multiple issue types", () => {
-    const tasks = [
-      createTask("A", "Task A", [
-        { taskId: "A", type: "blocked_by" }, // self-dependency
-        { taskId: "deleted", type: "blocked_by" }, // invalid reference
-      ]),
-      createTask("B", "Task B", [{ taskId: "C", type: "blocked_by" }]),
-      createTask("C", "Task C", [{ taskId: "B", type: "blocked_by" }]), // circular
-    ];
-    const result = checkDependencyIntegrity(tasks);
-    expect(result.valid).toBe(false);
-    expect(result.issues.selfDependencies.length).toBeGreaterThan(0);
-    expect(result.issues.invalidReferences.length).toBeGreaterThan(0);
-    expect(result.issues.circularDependencies.length).toBeGreaterThan(0);
-    expect(result.summary).toContain("self-dependencies");
-    expect(result.summary).toContain("invalid references");
-    expect(result.summary).toContain("circular dependency");
-  });
-
-  test("handles empty task array", () => {
-    const result = checkDependencyIntegrity([]);
-    expect(result.valid).toBe(true);
-    expect(result.totalTasks).toBe(0);
-    expect(result.totalDependencies).toBe(0);
-  });
-
-  test("handles tasks with no dependencies", () => {
-    const tasks = [createTask("A"), createTask("B"), createTask("C")];
-    const result = checkDependencyIntegrity(tasks);
-    expect(result.valid).toBe(true);
-    expect(result.totalTasks).toBe(3);
-    expect(result.totalDependencies).toBe(0);
-  });
-});