@ronkovic/aad 0.3.0

package/src/modules/task-queue/__tests__/task-plan.test.ts

@@ -0,0 +1,122 @@
+import { describe, test, expect, beforeEach, afterEach } from "bun:test";
+import { rm, mkdir } from "node:fs/promises";
+import { join } from "node:path";
+import { parseTaskPlan, loadTaskPlan } from "../task-plan";
+
+const TEST_DIR = join(import.meta.dir, ".tmp-task-plan-test");
+
+describe("task-plan", () => {
+  beforeEach(async () => {
+    await rm(TEST_DIR, { recursive: true, force: true });
+    await mkdir(TEST_DIR, { recursive: true });
+  });
+
+  afterEach(async () => {
+    await rm(TEST_DIR, { recursive: true, force: true });
+  });
+
+  describe("parseTaskPlan", () => {
+    test("parses snake_case task plan JSON", () => {
+      const json = {
+        run_id: "run-123",
+        parent_branch: "main",
+        title: "Test Plan",
+        description: "A test plan",
+        tasks: [
+          {
+            task_id: "task-1",
+            title: "Task 1",
+            description: "First task",
+            files_to_modify: ["file1.ts"],
+            depends_on: [],
+            priority: 1,
+          },
+          {
+            task_id: "task-2",
+            title: "Task 2",
+            description: "Second task",
+            files_to_modify: ["file2.ts"],
+            depends_on: ["task-1"],
+            priority: 2,
+          },
+        ],
+      };
+
+      const plan = parseTaskPlan(json);
+
+      expect(plan.runId as string).toBe("run-123");
+      expect(plan.parentBranch).toBe("main");
+      expect(plan.title).toBe("Test Plan");
+      expect(plan.tasks).toHaveLength(2);
+      expect(plan.tasks[0]?.taskId as string).toBe("task-1");
+      expect(plan.tasks[1]?.dependsOn.map((id) => id as string)).toEqual(["task-1"]);
+    });
+
+    test("handles minimal task plan", () => {
+      const json = {
+        run_id: "run-456",
+        parent_branch: "develop",
+        tasks: [],
+      };
+
+      const plan = parseTaskPlan(json);
+
+      expect(plan.runId as string).toBe("run-456");
+      expect(plan.parentBranch).toBe("develop");
+      expect(plan.title).toBeUndefined();
+      expect(plan.description).toBeUndefined();
+      expect(plan.tasks).toHaveLength(0);
+    });
+
+    test("throws on invalid JSON", () => {
+      const invalidJson = {
+        run_id: "",
+        tasks: [],
+      };
+
+      expect(() => parseTaskPlan(invalidJson)).toThrow();
+    });
+  });
+
+  describe("loadTaskPlan", () => {
+    test("loads and parses task plan from file", async () => {
+      const taskPlanPath = join(TEST_DIR, "task_plan.json");
+      const json = {
+        run_id: "run-789",
+        parent_branch: "feature/test",
+        title: "File Test Plan",
+        tasks: [
+          {
+            task_id: "task-1",
+            title: "Task 1",
+            description: "Task from file",
+            files_to_modify: [],
+            depends_on: [],
+            priority: 1,
+          },
+        ],
+      };
+
+      await Bun.write(taskPlanPath, JSON.stringify(json, null, 2));
+
+      const plan = await loadTaskPlan(taskPlanPath);
+
+      expect(plan.runId as string).toBe("run-789");
+      expect(plan.title).toBe("File Test Plan");
+      expect(plan.tasks).toHaveLength(1);
+    });
+
+    test("throws on non-existent file", async () => {
+      const nonExistentPath = join(TEST_DIR, "non-existent.json");
+
+      await expect(loadTaskPlan(nonExistentPath)).rejects.toThrow();
+    });
+
+    test("throws on invalid JSON file", async () => {
+      const invalidPath = join(TEST_DIR, "invalid.json");
+      await Bun.write(invalidPath, "{ invalid json");
+
+      await expect(loadTaskPlan(invalidPath)).rejects.toThrow();
+    });
+  });
+});

package/src/modules/task-queue/__tests__/task.test.ts

@@ -0,0 +1,130 @@
+import { describe, test, expect } from "bun:test";
+import { parseTask, serializeTask } from "../task";
+import { createTaskId } from "@aad/shared/types";
+
+describe("task", () => {
+  describe("parseTask", () => {
+    test("parses snake_case JSON to Task", () => {
+      const json = {
+        task_id: "task-1",
+        title: "Test Task",
+        description: "A test task",
+        files_to_modify: ["file1.ts", "file2.ts"],
+        depends_on: ["task-0"],
+        priority: 1,
+        status: "pending",
+        retry_count: 0,
+      };
+
+      const task = parseTask(json);
+
+      expect(task.taskId as string).toBe("task-1");
+      expect(task.title).toBe("Test Task");
+      expect(task.filesToModify).toEqual(["file1.ts", "file2.ts"]);
+      expect(task.dependsOn.map((id) => id as string)).toEqual(["task-0"]);
+      expect(task.priority).toBe(1);
+      expect(task.status).toBe("pending");
+      expect(task.retryCount).toBe(0);
+    });
+
+    test("handles optional fields", () => {
+      const json = {
+        task_id: "task-2",
+        title: "Task 2",
+        description: "Running task",
+        files_to_modify: [],
+        depends_on: [],
+        priority: 2,
+        status: "running",
+        worker_id: "worker-1",
+        start_time: "2025-01-01T00:00:00Z",
+        retry_count: 1,
+        failure_reason: "Previous timeout",
+      };
+
+      const task = parseTask(json);
+
+      expect(task.workerId as string | undefined).toBe("worker-1");
+      expect(task.startTime).toBe("2025-01-01T00:00:00Z");
+      expect(task.retryCount).toBe(1);
+      expect(task.failureReason).toBe("Previous timeout");
+    });
+
+    test("defaults status to pending", () => {
+      const json = {
+        task_id: "task-3",
+        title: "Task 3",
+        description: "Task",
+        files_to_modify: [],
+        depends_on: [],
+        priority: 1,
+        retry_count: 0,
+      };
+
+      const task = parseTask(json);
+      expect(task.status).toBe("pending");
+      expect(task.retryCount).toBe(0);
+    });
+
+    test("throws on invalid JSON", () => {
+      const invalidJson = {
+        task_id: "",
+        title: "Task",
+        description: "",
+        files_to_modify: [],
+        depends_on: [],
+        priority: 1,
+      };
+
+      expect(() => parseTask(invalidJson)).toThrow();
+    });
+  });
+
+  describe("serializeTask", () => {
+    test("serializes Task to snake_case JSON", () => {
+      const task = {
+        taskId: createTaskId("task-1"),
+        title: "Test Task",
+        description: "A test task",
+        filesToModify: ["file1.ts"],
+        dependsOn: [createTaskId("task-0")],
+        priority: 1,
+        status: "completed" as const,
+        workerId: "worker-1" as any,
+        startTime: "2025-01-01T00:00:00Z",
+        endTime: "2025-01-01T00:10:00Z",
+        retryCount: 0,
+      };
+
+      const json = serializeTask(task);
+
+      expect(json.task_id).toBe("task-1");
+      expect(json.files_to_modify).toEqual(["file1.ts"]);
+      expect(json.depends_on).toEqual(["task-0"]);
+      expect(json.status).toBe("completed");
+      expect(json.worker_id).toBe("worker-1");
+      expect(json.start_time).toBe("2025-01-01T00:00:00Z");
+      expect(json.end_time).toBe("2025-01-01T00:10:00Z");
+    });
+
+    test("handles undefined optional fields", () => {
+      const task = {
+        taskId: createTaskId("task-2"),
+        title: "Task 2",
+        description: "Pending task",
+        filesToModify: [],
+        dependsOn: [],
+        priority: 1,
+        status: "pending" as const,
+        retryCount: 0,
+      };
+
+      const json = serializeTask(task);
+
+      expect(json.worker_id).toBeUndefined();
+      expect(json.start_time).toBeUndefined();
+      expect(json.end_time).toBeUndefined();
+      expect(json.failure_reason).toBeUndefined();
+    });
+  });
+});

package/src/modules/task-queue/dependency-resolver.ts

@@ -0,0 +1,171 @@
+import type { Task, TaskId } from "@aad/shared/types";
+import { CircularDependencyError } from "@aad/shared/errors";
+
+export type DependencyStatus = "ready" | "waiting" | "blocked";
+
+export interface DependencyResult {
+  status: DependencyStatus;
+  blockedBy: TaskId[];
+  reason?: string;
+}
+
+/**
+ * Check if a task's dependencies are satisfied
+ */
+export function checkDependencies(
+  taskId: TaskId,
+  tasks: ReadonlyMap<TaskId, Task>
+): DependencyResult {
+  const task = tasks.get(taskId);
+
+  if (!task) {
+    return {
+      status: "blocked",
+      blockedBy: [],
+      reason: "Task not found",
+    };
+  }
+
+  if (task.dependsOn.length === 0) {
+    return {
+      status: "ready",
+      blockedBy: [],
+    };
+  }
+
+  const blockedBy: TaskId[] = [];
+
+  for (const depId of task.dependsOn) {
+    const depTask = tasks.get(depId);
+
+    if (!depTask) {
+      return {
+        status: "blocked",
+        blockedBy: [depId],
+        reason: `Dependency ${depId as string} not found`,
+      };
+    }
+
+    if (depTask.status === "failed") {
+      return {
+        status: "blocked",
+        blockedBy: [depId],
+        reason: `Dependency ${depId as string} failed`,
+      };
+    }
+
+    if (depTask.status !== "completed") {
+      blockedBy.push(depId);
+    }
+  }
+
+  if (blockedBy.length > 0) {
+    return {
+      status: "waiting",
+      blockedBy,
+    };
+  }
+
+  return {
+    status: "ready",
+    blockedBy: [],
+  };
+}
+
+/**
+ * Detect circular dependencies using DFS with 3-color algorithm
+ * Returns array of cycles if found, null if no cycles
+ */
+export function detectCircularDependencies(
+  tasks: ReadonlyMap<TaskId, Task>
+): TaskId[][] | null {
+  type Color = "white" | "gray" | "black";
+  const colors = new Map<TaskId, Color>();
+  const cycles: TaskId[][] = [];
+
+  // Initialize all nodes as white (unvisited)
+  for (const taskId of tasks.keys()) {
+    colors.set(taskId, "white");
+  }
+
+  function dfs(taskId: TaskId, path: TaskId[]): void {
+    colors.set(taskId, "gray"); // Mark as being visited
+    path.push(taskId);
+
+    const task = tasks.get(taskId);
+    if (!task) {
+      colors.set(taskId, "black");
+      return;
+    }
+
+    for (const depId of task.dependsOn) {
+      const color = colors.get(depId);
+
+      if (color === "gray") {
+        // Back edge found - cycle detected
+        const cycleStart = path.indexOf(depId);
+        if (cycleStart !== -1) {
+          const cycle = path.slice(cycleStart);
+          cycle.push(depId); // Complete the cycle
+          cycles.push(cycle);
+        }
+      } else if (color === "white") {
+        // Continue DFS
+        dfs(depId, [...path]);
+      }
+      // If black, already visited and no cycle in this path
+    }
+
+    colors.set(taskId, "black"); // Mark as fully visited
+  }
+
+  // Visit all unvisited nodes
+  for (const taskId of tasks.keys()) {
+    if (colors.get(taskId) === "white") {
+      dfs(taskId, []);
+    }
+  }
+
+  return cycles.length > 0 ? cycles : null;
+}
+
+/**
+ * Get all tasks that are ready to execute (no pending dependencies)
+ */
+export function getReadyTasks(tasks: ReadonlyMap<TaskId, Task>): Task[] {
+  const ready: Task[] = [];
+
+  for (const task of tasks.values()) {
+    if (task.status !== "pending") {
+      continue;
+    }
+
+    const result = checkDependencies(task.taskId, tasks);
+    if (result.status === "ready") {
+      ready.push(task);
+    }
+  }
+
+  // Sort by priority (higher priority first)
+  return ready.sort((a, b) => b.priority - a.priority);
+}
+
+/**
+ * Validate task plan for circular dependencies
+ * Throws CircularDependencyError if cycles detected
+ */
+export function validateTaskPlan(tasks: Task[]): void {
+  const taskMap = new Map(tasks.map((task) => [task.taskId, task]));
+  const cycles = detectCircularDependencies(taskMap);
+
+  if (cycles) {
+    const cycleStrings = cycles.map((cycle) =>
+      cycle.map((id) => id as string).join(" -> ")
+    );
+
+    throw new CircularDependencyError("Circular dependencies detected", {
+      cycles: cycleStrings,
+      count: cycles.length,
+    });
+  }
+}