@task-mcp/shared 1.0.20 → 1.0.21

package/src/algorithms/tech-analysis.test.ts

@@ -1,413 +0,0 @@
-import { describe, test, expect } from "bun:test";
-import {
-  suggestSafeOrder,
-  findBreakingChanges,
-  findHighRiskTasks,
-  groupByTechArea,
-  getComplexitySummary,
-  getTechStackSummary,
-  suggestSubtaskCount,
-} from "./tech-analysis.js";
-import type { Task, TechArea, RiskLevel } from "../schemas/task.js";
-
-// Helper to create mock tasks with tech stack analysis
-function createTask(
-  id: string,
-  options: {
-    priority?: "critical" | "high" | "medium" | "low";
-    status?: "pending" | "in_progress" | "completed" | "blocked" | "cancelled";
-    areas?: TechArea[];
-    riskLevel?: RiskLevel;
-    hasBreakingChange?: boolean;
-    complexityScore?: number;
-  } = {}
-): Task {
-  const task: Task = {
-    id,
-    title: `Task ${id}`,
-    status: options.status ?? "pending",
-    priority: options.priority ?? "medium",
-    workspace: "test-workspace",
-    createdAt: new Date().toISOString(),
-    updatedAt: new Date().toISOString(),
-  };
-
-  if (options.areas || options.riskLevel !== undefined || options.hasBreakingChange !== undefined) {
-    task.techStack = {};
-    if (options.areas) {
-      task.techStack.areas = options.areas;
-    }
-    if (options.riskLevel !== undefined) {
-      task.techStack.riskLevel = options.riskLevel;
-    }
-    if (options.hasBreakingChange !== undefined) {
-      task.techStack.hasBreakingChange = options.hasBreakingChange;
-    }
-  }
-
-  if (options.complexityScore !== undefined) {
-    task.complexity = {
-      score: options.complexityScore,
-    };
-  }
-
-  return task;
-}
-
-describe("suggestSafeOrder", () => {
-  test("returns empty result for empty input", () => {
-    const result = suggestSafeOrder([]);
-    expect(result.orderedTasks).toEqual([]);
-    expect(result.phases).toEqual([]);
-    expect(result.summary.totalTasks).toBe(0);
-  });
-
-  test("returns empty for all completed tasks", () => {
-    const tasks = [createTask("A", { status: "completed" })];
-    const result = suggestSafeOrder(tasks);
-    expect(result.orderedTasks).toEqual([]);
-  });
-
-  test("orders by tech level (schema before backend)", () => {
-    const tasks = [
-      createTask("backend-task", { areas: ["backend"] }),
-      createTask("schema-task", { areas: ["schema"] }),
-    ];
-    const result = suggestSafeOrder(tasks);
-
-    expect(result.orderedTasks[0]!.id).toBe("schema-task");
-    expect(result.orderedTasks[1]!.id).toBe("backend-task");
-  });
-
-  test("orders by tech level (full chain)", () => {
-    const tasks = [
-      createTask("frontend", { areas: ["frontend"] }),
-      createTask("backend", { areas: ["backend"] }),
-      createTask("schema", { areas: ["schema"] }),
-      createTask("test", { areas: ["test"] }),
-      createTask("devops", { areas: ["devops"] }),
-    ];
-    const result = suggestSafeOrder(tasks);
-
-    const order = result.orderedTasks.map((t) => t.id);
-    expect(order).toEqual(["schema", "devops", "backend", "frontend", "test"]);
-  });
-
-  test("orders by risk level within same tech level", () => {
-    const tasks = [
-      createTask("high-risk", { areas: ["backend"], riskLevel: "high" }),
-      createTask("low-risk", { areas: ["backend"], riskLevel: "low" }),
-      createTask("medium-risk", { areas: ["backend"], riskLevel: "medium" }),
-    ];
-    const result = suggestSafeOrder(tasks);
-
-    const order = result.orderedTasks.map((t) => t.id);
-    expect(order).toEqual(["low-risk", "medium-risk", "high-risk"]);
-  });
-
-  test("puts breaking changes last within same tech/risk level", () => {
-    const tasks = [
-      createTask("breaking", { areas: ["backend"], riskLevel: "low", hasBreakingChange: true }),
-      createTask("safe", { areas: ["backend"], riskLevel: "low", hasBreakingChange: false }),
-    ];
-    const result = suggestSafeOrder(tasks);
-
-    expect(result.orderedTasks[0]!.id).toBe("safe");
-    expect(result.orderedTasks[1]!.id).toBe("breaking");
-  });
-
-  test("uses priority as tiebreaker", () => {
-    const tasks = [
-      createTask("low-priority", { areas: ["backend"], priority: "low" }),
-      createTask("high-priority", { areas: ["backend"], priority: "high" }),
-    ];
-    const result = suggestSafeOrder(tasks);
-
-    expect(result.orderedTasks[0]!.id).toBe("high-priority");
-    expect(result.orderedTasks[1]!.id).toBe("low-priority");
-  });
-
-  test("groups tasks into phases by tech level", () => {
-    const tasks = [
-      createTask("schema1", { areas: ["schema"] }),
-      createTask("schema2", { areas: ["schema"] }),
-      createTask("backend1", { areas: ["backend"] }),
-    ];
-    const result = suggestSafeOrder(tasks);
-
-    expect(result.phases.length).toBe(2);
-    expect(result.phases[0]!.primaryArea).toBe("schema");
-    expect(result.phases[0]!.tasks.length).toBe(2);
-    expect(result.phases[1]!.primaryArea).toBe("backend");
-    expect(result.phases[1]!.tasks.length).toBe(1);
-  });
-
-  test("calculates summary statistics correctly", () => {
-    const tasks = [
-      createTask("t1", { areas: ["backend"], hasBreakingChange: true }),
-      createTask("t2", { areas: ["backend"], riskLevel: "high" }),
-      createTask("t3", { areas: ["backend"], riskLevel: "critical" }),
-      createTask("t4", { areas: ["backend"] }),
-    ];
-    const result = suggestSafeOrder(tasks);
-
-    expect(result.summary.totalTasks).toBe(4);
-    expect(result.summary.breakingChanges).toBe(1);
-    expect(result.summary.highRiskCount).toBe(2);
-  });
-});
-
-describe("findBreakingChanges", () => {
-  test("returns empty for no breaking changes", () => {
-    const tasks = [
-      createTask("t1", { areas: ["backend"], hasBreakingChange: false }),
-      createTask("t2", { areas: ["backend"] }),
-    ];
-    const result = findBreakingChanges(tasks);
-    expect(result).toEqual([]);
-  });
-
-  test("finds tasks with breaking changes", () => {
-    const tasks = [
-      createTask("t1", { areas: ["backend"], hasBreakingChange: true }),
-      createTask("t2", { areas: ["backend"], hasBreakingChange: false }),
-      createTask("t3", { areas: ["schema"], hasBreakingChange: true }),
-    ];
-    const result = findBreakingChanges(tasks);
-    expect(result.length).toBe(2);
-    expect(result.map((t) => t.id).sort()).toEqual(["t1", "t3"]);
-  });
-
-  test("excludes completed tasks", () => {
-    const tasks = [
-      createTask("t1", { status: "completed", areas: ["backend"], hasBreakingChange: true }),
-      createTask("t2", { status: "pending", areas: ["backend"], hasBreakingChange: true }),
-    ];
-    const result = findBreakingChanges(tasks);
-    expect(result.length).toBe(1);
-    expect(result[0]!.id).toBe("t2");
-  });
-});
-
-describe("findHighRiskTasks", () => {
-  test("returns empty for no high-risk tasks", () => {
-    const tasks = [
-      createTask("t1", { areas: ["backend"], riskLevel: "low" }),
-      createTask("t2", { areas: ["backend"], riskLevel: "medium" }),
-    ];
-    const result = findHighRiskTasks(tasks);
-    expect(result).toEqual([]);
-  });
-
-  test("finds high and critical risk tasks", () => {
-    const tasks = [
-      createTask("t1", { areas: ["backend"], riskLevel: "low" }),
-      createTask("t2", { areas: ["backend"], riskLevel: "high" }),
-      createTask("t3", { areas: ["backend"], riskLevel: "critical" }),
-    ];
-    const result = findHighRiskTasks(tasks);
-    expect(result.length).toBe(2);
-    expect(result.map((t) => t.id).sort()).toEqual(["t2", "t3"]);
-  });
-});
-
-describe("groupByTechArea", () => {
-  test("returns all areas with empty arrays for empty input", () => {
-    const result = groupByTechArea([]);
-    expect(result.get("schema")).toEqual([]);
-    expect(result.get("backend")).toEqual([]);
-    expect(result.get("frontend")).toEqual([]);
-  });
-
-  test("groups tasks by their tech areas", () => {
-    const tasks = [
-      createTask("t1", { areas: ["backend"] }),
-      createTask("t2", { areas: ["backend"] }),
-      createTask("t3", { areas: ["frontend"] }),
-    ];
-    const result = groupByTechArea(tasks);
-
-    expect(result.get("backend")!.length).toBe(2);
-    expect(result.get("frontend")!.length).toBe(1);
-    expect(result.get("schema")!.length).toBe(0);
-  });
-
-  test("task appears in multiple groups if it spans multiple areas", () => {
-    const tasks = [
-      createTask("fullstack", { areas: ["backend", "frontend"] }),
-    ];
-    const result = groupByTechArea(tasks);
-
-    expect(result.get("backend")!.length).toBe(1);
-    expect(result.get("frontend")!.length).toBe(1);
-    expect(result.get("backend")![0]!.id).toBe("fullstack");
-  });
-
-  test("defaults to backend if no area specified", () => {
-    const tasks = [createTask("t1", {})];
-    const result = groupByTechArea(tasks);
-    expect(result.get("backend")!.length).toBe(1);
-  });
-
-  test("excludes completed tasks", () => {
-    const tasks = [
-      createTask("t1", { status: "completed", areas: ["backend"] }),
-      createTask("t2", { status: "pending", areas: ["backend"] }),
-    ];
-    const result = groupByTechArea(tasks);
-    expect(result.get("backend")!.length).toBe(1);
-  });
-});
-
-describe("getComplexitySummary", () => {
-  test("returns empty summary for no tasks", () => {
-    const result = getComplexitySummary([]);
-    expect(result.distribution).toEqual({ low: 0, medium: 0, high: 0 });
-    expect(result.needsBreakdown).toEqual([]);
-    expect(result.averageScore).toBe(0);
-    expect(result.unanalyzed).toEqual([]);
-  });
-
-  test("calculates distribution correctly", () => {
-    const tasks = [
-      createTask("t1", { complexityScore: 2 }), // low
-      createTask("t2", { complexityScore: 3 }), // low
-      createTask("t3", { complexityScore: 5 }), // medium
-      createTask("t4", { complexityScore: 8 }), // high
-    ];
-    const result = getComplexitySummary(tasks);
-
-    expect(result.distribution.low).toBe(2);
-    expect(result.distribution.medium).toBe(1);
-    expect(result.distribution.high).toBe(1);
-  });
-
-  test("identifies tasks needing breakdown (score >= 7)", () => {
-    const tasks = [
-      createTask("t1", { complexityScore: 6 }),
-      createTask("t2", { complexityScore: 7 }),
-      createTask("t3", { complexityScore: 9 }),
-    ];
-    const result = getComplexitySummary(tasks);
-
-    expect(result.needsBreakdown.length).toBe(2);
-    expect(result.needsBreakdown.map((t) => t.id).sort()).toEqual(["t2", "t3"]);
-  });
-
-  test("calculates average score correctly", () => {
-    const tasks = [
-      createTask("t1", { complexityScore: 2 }),
-      createTask("t2", { complexityScore: 6 }),
-      createTask("t3", { complexityScore: 10 }),
-    ];
-    const result = getComplexitySummary(tasks);
-
-    expect(result.averageScore).toBe(6); // (2+6+10)/3
-  });
-
-  test("identifies unanalyzed tasks", () => {
-    const tasks = [
-      createTask("analyzed", { complexityScore: 5 }),
-      createTask("not-analyzed", {}),
-    ];
-    const result = getComplexitySummary(tasks);
-
-    expect(result.unanalyzed.length).toBe(1);
-    expect(result.unanalyzed[0]!.id).toBe("not-analyzed");
-  });
-
-  test("excludes completed tasks", () => {
-    const tasks = [
-      createTask("t1", { status: "completed", complexityScore: 10 }),
-      createTask("t2", { status: "pending", complexityScore: 5 }),
-    ];
-    const result = getComplexitySummary(tasks);
-
-    expect(result.distribution.high).toBe(0);
-    expect(result.distribution.medium).toBe(1);
-  });
-});
-
-describe("getTechStackSummary", () => {
-  test("returns empty summary for no tasks", () => {
-    const result = getTechStackSummary([]);
-    expect(result.areaCounts.schema).toBe(0);
-    expect(result.breakingChanges).toEqual([]);
-    expect(result.unanalyzed).toEqual([]);
-  });
-
-  test("counts tasks by area correctly", () => {
-    const tasks = [
-      createTask("t1", { areas: ["backend"] }),
-      createTask("t2", { areas: ["backend", "frontend"] }),
-      createTask("t3", { areas: ["schema"] }),
-    ];
-    const result = getTechStackSummary(tasks);
-
-    expect(result.areaCounts.backend).toBe(2);
-    expect(result.areaCounts.frontend).toBe(1);
-    expect(result.areaCounts.schema).toBe(1);
-  });
-
-  test("tracks risk distribution", () => {
-    const tasks = [
-      createTask("t1", { areas: ["backend"], riskLevel: "low" }),
-      createTask("t2", { areas: ["backend"], riskLevel: "medium" }),
-      createTask("t3", { areas: ["backend"], riskLevel: "high" }),
-    ];
-    const result = getTechStackSummary(tasks);
-
-    expect(result.riskDistribution.low).toBe(1);
-    expect(result.riskDistribution.medium).toBe(1);
-    expect(result.riskDistribution.high).toBe(1);
-  });
-
-  test("identifies breaking changes", () => {
-    const tasks = [
-      createTask("t1", { areas: ["backend"], hasBreakingChange: true }),
-      createTask("t2", { areas: ["backend"], hasBreakingChange: false }),
-    ];
-    const result = getTechStackSummary(tasks);
-
-    expect(result.breakingChanges.length).toBe(1);
-    expect(result.breakingChanges[0]!.id).toBe("t1");
-  });
-
-  test("identifies unanalyzed tasks", () => {
-    const tasks = [
-      createTask("analyzed", { areas: ["backend"] }),
-      createTask("not-analyzed", {}),
-    ];
-    const result = getTechStackSummary(tasks);
-
-    expect(result.unanalyzed.length).toBe(1);
-    expect(result.unanalyzed[0]!.id).toBe("not-analyzed");
-  });
-});
-
-describe("suggestSubtaskCount", () => {
-  test("returns 0 for very low complexity (1-2)", () => {
-    expect(suggestSubtaskCount(1)).toBe(0);
-    expect(suggestSubtaskCount(2)).toBe(0);
-  });
-
-  test("returns 2 for low complexity (3-4)", () => {
-    expect(suggestSubtaskCount(3)).toBe(2);
-    expect(suggestSubtaskCount(4)).toBe(2);
-  });
-
-  test("returns 3-4 for medium complexity (5-6)", () => {
-    expect(suggestSubtaskCount(5)).toBe(4);
-    expect(suggestSubtaskCount(6)).toBe(4);
-  });
-
-  test("returns 5-6 for high complexity (7-8)", () => {
-    expect(suggestSubtaskCount(7)).toBe(6);
-    expect(suggestSubtaskCount(8)).toBe(6);
-  });
-
-  test("returns 7-10 for very high complexity (9-10)", () => {
-    expect(suggestSubtaskCount(9)).toBe(9);
-    expect(suggestSubtaskCount(10)).toBe(10);
-  });
-});

package/src/algorithms/topological-sort.test.ts

@@ -1,190 +0,0 @@
-import { describe, test, expect } from "bun:test";
-import {
-  priorityToNumber,
-  topologicalSort,
-  wouldCreateCycle,
-  findDependents,
-  findDependencies,
-} from "./topological-sort.js";
-import type { Task } from "../schemas/task.js";
-
-// Helper to create mock tasks
-function createTask(id: string, priority: string = "medium", deps: string[] = []): Task {
-  return {
-    id,
-    title: `Task ${id}`,
-    status: "pending",
-    priority: priority as Task["priority"],
-    workspace: "test-workspace",
-    createdAt: new Date().toISOString(),
-    updatedAt: new Date().toISOString(),
-    dependencies: deps.map((depId) => ({ taskId: depId, type: "blocked_by" as const })),
-  };
-}
-
-describe("priorityToNumber", () => {
-  test("converts critical to 4", () => {
-    expect(priorityToNumber("critical")).toBe(4);
-  });
-
-  test("converts high to 3", () => {
-    expect(priorityToNumber("high")).toBe(3);
-  });
-
-  test("converts medium to 2", () => {
-    expect(priorityToNumber("medium")).toBe(2);
-  });
-
-  test("converts low to 1", () => {
-    expect(priorityToNumber("low")).toBe(1);
-  });
-
-  test("defaults to 2 for unknown priority", () => {
-    expect(priorityToNumber("unknown")).toBe(2);
-  });
-});
-
-describe("topologicalSort", () => {
-  test("returns empty array for empty input", () => {
-    const result = topologicalSort([]);
-    expect(result).toEqual([]);
-  });
-
-  test("returns single task unchanged", () => {
-    const tasks = [createTask("A")];
-    const result = topologicalSort(tasks);
-    expect(result.length).toBe(1);
-    expect(result[0]!.id).toBe("A");
-  });
-
-  test("sorts by dependency order", () => {
-    // B depends on A, so A should come first
-    const tasks = [createTask("B", "high", ["A"]), createTask("A", "low")];
-    const result = topologicalSort(tasks);
-    expect(result[0]!.id).toBe("A");
-    expect(result[1]!.id).toBe("B");
-  });
-
-  test("respects priority when no dependencies", () => {
-    const tasks = [
-      createTask("A", "low"),
-      createTask("B", "critical"),
-      createTask("C", "high"),
-    ];
-    const result = topologicalSort(tasks);
-    expect(result[0]!.id).toBe("B"); // critical first
-    expect(result[1]!.id).toBe("C"); // then high
-    expect(result[2]!.id).toBe("A"); // then low
-  });
-
-  test("handles chain of dependencies", () => {
-    // C -> B -> A (C depends on B, B depends on A)
-    const tasks = [
-      createTask("C", "critical", ["B"]),
-      createTask("B", "high", ["A"]),
-      createTask("A", "low"),
-    ];
-    const result = topologicalSort(tasks);
-    expect(result.map((t) => t.id)).toEqual(["A", "B", "C"]);
-  });
-
-  test("throws on circular dependency", () => {
-    // A -> B -> A
-    const tasks = [createTask("A", "medium", ["B"]), createTask("B", "medium", ["A"])];
-    expect(() => topologicalSort(tasks)).toThrow(/Circular dependency/);
-  });
-
-  test("handles diamond dependency", () => {
-    // D depends on B and C, both depend on A
-    const tasks = [
-      createTask("D", "medium", ["B", "C"]),
-      createTask("B", "high", ["A"]),
-      createTask("C", "low", ["A"]),
-      createTask("A", "medium"),
-    ];
-    const result = topologicalSort(tasks);
-    // A must come first, D must come last
-    expect(result[0]!.id).toBe("A");
-    expect(result[3]!.id).toBe("D");
-  });
-});
-
-describe("wouldCreateCycle", () => {
-  test("returns false for valid dependency", () => {
-    const tasks = [createTask("A"), createTask("B")];
-    // Adding B blocked_by A should not create cycle
-    expect(wouldCreateCycle(tasks, "B", "A")).toBe(false);
-  });
-
-  test("returns true for direct cycle", () => {
-    const tasks = [createTask("A", "medium", ["B"]), createTask("B")];
-    // B is already blocking A, so A blocking B would create cycle
-    expect(wouldCreateCycle(tasks, "B", "A")).toBe(true);
-  });
-
-  test("returns true for indirect cycle", () => {
-    const tasks = [
-      createTask("A", "medium", ["B"]),
-      createTask("B", "medium", ["C"]),
-      createTask("C"),
-    ];
-    // A <- B <- C, adding C <- A would create cycle
-    expect(wouldCreateCycle(tasks, "C", "A")).toBe(true);
-  });
-});
-
-describe("findDependents", () => {
-  test("returns empty for task with no dependents", () => {
-    const tasks = [createTask("A"), createTask("B")];
-    const result = findDependents(tasks, "A");
-    expect(result).toEqual([]);
-  });
-
-  test("finds direct dependents", () => {
-    const tasks = [
-      createTask("A"),
-      createTask("B", "medium", ["A"]),
-      createTask("C", "medium", ["A"]),
-    ];
-    const result = findDependents(tasks, "A");
-    expect(result.map((t) => t.id).sort()).toEqual(["B", "C"]);
-  });
-
-  test("finds transitive dependents", () => {
-    const tasks = [
-      createTask("A"),
-      createTask("B", "medium", ["A"]),
-      createTask("C", "medium", ["B"]),
-    ];
-    const result = findDependents(tasks, "A");
-    expect(result.map((t) => t.id).sort()).toEqual(["B", "C"]);
-  });
-});
-
-describe("findDependencies", () => {
-  test("returns empty for task with no dependencies", () => {
-    const tasks = [createTask("A"), createTask("B")];
-    const result = findDependencies(tasks, "A");
-    expect(result).toEqual([]);
-  });
-
-  test("finds direct dependencies", () => {
-    const tasks = [
-      createTask("A"),
-      createTask("B"),
-      createTask("C", "medium", ["A", "B"]),
-    ];
-    const result = findDependencies(tasks, "C");
-    expect(result.map((t) => t.id).sort()).toEqual(["A", "B"]);
-  });
-
-  test("finds transitive dependencies", () => {
-    const tasks = [
-      createTask("A"),
-      createTask("B", "medium", ["A"]),
-      createTask("C", "medium", ["B"]),
-    ];
-    const result = findDependencies(tasks, "C");
-    expect(result.map((t) => t.id).sort()).toEqual(["A", "B"]);
-  });
-});