@ronkovic/aad 0.4.0 → 0.5.1

package/src/__tests__/e2e/retry-e2e.test.ts

@@ -0,0 +1,285 @@
+/**
+ * E2E Test: Task retry mechanism with retryContext propagation
+ */
+import { describe, test, expect, beforeEach } from "bun:test";
+import { EventBus } from "@aad/shared/events";
+import { Dispatcher } from "@aad/task-queue";
+import { createStores, type Stores } from "@aad/persistence";
+import {
+  createRunId,
+  createTaskId,
+  createWorkerId,
+  type Task,
+} from "@aad/shared/types";
+import {
+  MockClaudeProvider,
+  createMockLogger,
+  createMockConfig,
+  waitFor,
+  collectEvents,
+} from "../helpers";
+import { PlanningService, type FileChecker } from "@aad/planning";
+
+const mockFileChecker: FileChecker = {
+  exists: async () => false,
+  readText: async () => "",
+  glob: async () => [],
+};
+
+describe("E2E Task Retry", () => {
+  let eventBus: EventBus;
+  let stores: Stores;
+  let dispatcher: Dispatcher;
+  let mockProvider: MockClaudeProvider;
+
+  beforeEach(() => {
+    eventBus = new EventBus();
+    stores = createStores("memory");
+    mockProvider = new MockClaudeProvider();
+
+    dispatcher = new Dispatcher({
+      taskStore: stores.taskStore,
+      workerStore: stores.workerStore,
+      runStore: stores.runStore,
+      eventBus,
+      config: { maxRetries: 2 },
+      logger: createMockLogger(),
+    });
+  });
+
+  test("retry increments retryCount and preserves previousFailure", async () => {
+    const config = createMockConfig();
+    const runId = createRunId("retry-run-1");
+
+    // Create 1-task plan
+    mockProvider.setSuccessResponse({
+      run_id: "retry-run-1",
+      parent_branch: "main",
+      tasks: [
+        {
+          task_id: "retry-task-1",
+          title: "Retry Task",
+          description: "Will fail then retry",
+          files_to_modify: ["a.ts"],
+          depends_on: [],
+          priority: 1,
+        },
+      ],
+    });
+
+    const planningService = new PlanningService(
+      mockProvider,
+      eventBus,
+      config,
+      createMockLogger(),
+      { fileChecker: mockFileChecker }
+    );
+
+    const taskPlan = await planningService.planTasks({
+      runId,
+      parentBranch: "main",
+      requirementsPath: "/fake/req.md",
+      targetDocsDir: "/fake/docs",
+    });
+
+    await dispatcher.initialize(taskPlan);
+
+    const events = collectEvents(eventBus, "task:retry");
+
+    // Simulate failure
+    await dispatcher.handleTaskFailed(
+      createTaskId("retry-task-1"),
+      "Test failure"
+    );
+
+    // Verify retry event
+    await waitFor(() => events.length > 0, 1000);
+    expect(events).toHaveLength(1);
+    expect(events[0]?.type).toBe("task:retry");
+    if (events[0]?.type === "task:retry") {
+      expect(events[0]?.retryCount).toBe(1);
+    }
+
+    // Verify task state
+    const task = await stores.taskStore.get(createTaskId("retry-task-1"));
+    expect(task?.status).toBe("pending");
+    expect(task?.retryCount).toBe(1);
+    expect(task?.failureReason).toBe("Test failure");
+    expect(task?.previousFailure).toBeDefined();
+    expect(task?.previousFailure?.error).toBe("Test failure");
+  }, 15_000);
+
+  test("retry reaches maxRetries and marks task as failed", async () => {
+    const config = createMockConfig();
+    const runId = createRunId("retry-run-2");
+
+    mockProvider.setSuccessResponse({
+      run_id: "retry-run-2",
+      parent_branch: "main",
+      tasks: [
+        {
+          task_id: "fail-task",
+          title: "Fail Task",
+          description: "Will fail permanently",
+          files_to_modify: [],
+          depends_on: [],
+          priority: 1,
+        },
+      ],
+    });
+
+    const planningService = new PlanningService(
+      mockProvider,
+      eventBus,
+      config,
+      createMockLogger(),
+      { fileChecker: mockFileChecker }
+    );
+
+    const taskPlan = await planningService.planTasks({
+      runId,
+      parentBranch: "main",
+      requirementsPath: "/fake/req.md",
+      targetDocsDir: "/fake/docs",
+    });
+
+    await dispatcher.initialize(taskPlan);
+
+    const events = collectEvents(eventBus, "task:failed", "task:retry");
+
+    // Fail 3 times (maxRetries = 2)
+    await dispatcher.handleTaskFailed(createTaskId("fail-task"), "Error 1");
+    await dispatcher.handleTaskFailed(createTaskId("fail-task"), "Error 2");
+    await dispatcher.handleTaskFailed(createTaskId("fail-task"), "Error 3");
+
+    // Wait for retry events (should be 2)
+    await waitFor(() => events.filter((e) => e.type === "task:retry").length >= 2, 1000);
+
+    const retryEvents = events.filter((e) => e.type === "task:retry");
+
+    expect(retryEvents).toHaveLength(2);
+
+    // Verify task is permanently failed (no task:failed event, check store directly)
+    const task = await stores.taskStore.get(createTaskId("fail-task"));
+    expect(task?.status).toBe("failed");
+    expect(task?.retryCount).toBe(2);
+    expect(task?.endTime).toBeDefined();
+  }, 15_000);
+
+  test("retryContext propagates through task execution (mock)", async () => {
+    // This test verifies previousFailure structure is saved
+    const task: Task = {
+      taskId: createTaskId("context-task"),
+      title: "Context Task",
+      description: "Test context",
+      filesToModify: [],
+      dependsOn: [],
+      priority: 1,
+      status: "failed",
+      retryCount: 1,
+      failureReason: "Phase Red failed",
+      previousFailure: {
+        phase: "Red",
+        error: "Phase Red failed",
+        testOutput: "test output here",
+        retryCount: 1,
+      },
+    };
+
+    await stores.taskStore.save(task);
+
+    const saved = await stores.taskStore.get(createTaskId("context-task"));
+    expect(saved?.previousFailure).toBeDefined();
+    expect(saved?.previousFailure?.phase).toBe("Red");
+    expect(saved?.previousFailure?.testOutput).toBe("test output here");
+  }, 15_000);
+
+  test("retry resets task status from running to pending", async () => {
+    const task: Task = {
+      taskId: createTaskId("reset-task"),
+      title: "Reset Task",
+      description: "Running task",
+      filesToModify: [],
+      dependsOn: [],
+      priority: 1,
+      status: "running",
+      retryCount: 0,
+      workerId: createWorkerId("worker-1"),
+    };
+
+    await stores.taskStore.save(task);
+
+    const dispatcher = new Dispatcher({
+      taskStore: stores.taskStore,
+      workerStore: stores.workerStore,
+      runStore: stores.runStore,
+      eventBus,
+      config: { maxRetries: 1 },
+      logger: createMockLogger(),
+    });
+
+    // Initialize taskMap (dispatcher needs this)
+    const runId = createRunId("reset-run");
+    await dispatcher.initialize({
+      runId,
+      parentBranch: "main",
+      tasks: [task],
+    });
+
+    // Fail task → should reset to pending
+    await dispatcher.handleTaskFailed(createTaskId("reset-task"), "Test error");
+
+    const saved = await stores.taskStore.get(createTaskId("reset-task"));
+    expect(saved?.status).toBe("pending");
+    expect(saved?.retryCount).toBe(1);
+    expect(saved?.workerId).toBeUndefined();
+  }, 15_000);
+
+  test("retry emits task:retry event with correct retryCount", async () => {
+    const task: Task = {
+      taskId: createTaskId("emit-task"),
+      title: "Emit Task",
+      description: "Event test",
+      filesToModify: [],
+      dependsOn: [],
+      priority: 1,
+      status: "running",
+      retryCount: 0,
+    };
+
+    await stores.taskStore.save(task);
+
+    const dispatcher = new Dispatcher({
+      taskStore: stores.taskStore,
+      workerStore: stores.workerStore,
+      runStore: stores.runStore,
+      eventBus,
+      config: { maxRetries: 3, staleTaskCheckInterval: 60000, staleTaskThreshold: 5400000 },
+      logger: createMockLogger(),
+      getIdleWorkerIds: () => [],
+    });
+
+    const runId = createRunId("emit-run");
+    await dispatcher.initialize({
+      runId,
+      parentBranch: "main",
+      tasks: [task],
+    });
+
+    const events = collectEvents(eventBus, "task:retry");
+
+    // Fail twice
+    await dispatcher.handleTaskFailed(createTaskId("emit-task"), "Error 1");
+    await dispatcher.handleTaskFailed(createTaskId("emit-task"), "Error 2");
+
+    await waitFor(() => events.length >= 2, 1000);
+
+    expect(events).toHaveLength(2);
+    if (events[0]?.type === "task:retry") {
+      expect(events[0]?.retryCount).toBe(1);
+    }
+    if (events[1]?.type === "task:retry") {
+      expect(events[1]?.retryCount).toBe(2);
+    }
+  }, 15_000);
+});

package/src/__tests__/e2e/status-e2e.test.ts

@@ -0,0 +1,227 @@
+/**
+ * E2E Test: Status command (displayStatus with stores)
+ */
+import { describe, test, expect, beforeEach } from "bun:test";
+import { createStores, type Stores } from "@aad/persistence";
+import { EventBus } from "@aad/shared/events";
+import { displayStatus, type App } from "@aad/cli";
+import {
+  createRunId,
+  createTaskId,
+  type RunState,
+  type Task,
+} from "@aad/shared/types";
+import { createMockLogger } from "../helpers";
+
+describe("E2E Status Command", () => {
+  let stores: Stores;
+  let eventBus: EventBus;
+
+  beforeEach(() => {
+    // Use in-memory stores for status tests (FSRunStore has single-file limitation)
+    stores = createStores("memory");
+    eventBus = new EventBus();
+  });
+
+  function createApp(): App {
+    return {
+      stores,
+      logger: createMockLogger(),
+      eventBus,
+    } as App;
+  }
+
+  test("displayStatus reads from FS store and displays progress", async () => {
+    const runId = createRunId("status-run-1");
+
+    // Create run state
+    const runState: RunState = {
+      runId,
+      parentBranch: "main",
+      totalTasks: 3,
+      pending: 1,
+      running: 1,
+      completed: 1,
+      failed: 0,
+      startTime: new Date().toISOString(),
+    };
+    await stores.runStore.save(runState);
+
+    // Create tasks
+    const tasks: Task[] = [
+      {
+        taskId: createTaskId("task-1"),
+        title: "Task 1",
+        description: "First task",
+        filesToModify: ["a.ts"],
+        dependsOn: [],
+        priority: 1,
+        status: "completed",
+        retryCount: 0,
+      },
+      {
+        taskId: createTaskId("task-2"),
+        title: "Task 2",
+        description: "Second task",
+        filesToModify: ["b.ts"],
+        dependsOn: [],
+        priority: 2,
+        status: "running",
+        retryCount: 0,
+      },
+      {
+        taskId: createTaskId("task-3"),
+        title: "Task 3",
+        description: "Third task",
+        filesToModify: ["c.ts"],
+        dependsOn: [],
+        priority: 3,
+        status: "pending",
+        retryCount: 0,
+      },
+    ];
+    for (const t of tasks) {
+      await stores.taskStore.save(t);
+    }
+
+    const app = createApp();
+
+    // Should not throw
+    await expect(displayStatus(app, "status-run-1")).resolves.toBeUndefined();
+
+    // Verify stores were read
+    const savedRun = await stores.runStore.get(runId);
+    expect(savedRun).toBeDefined();
+    expect(savedRun?.totalTasks).toBe(3);
+    expect(savedRun?.completed).toBe(1);
+  }, 15_000);
+
+  test("displayStatus handles multiple runs (latest vs specific runId)", async () => {
+    // Create multiple runs with tasks
+    await stores.runStore.save({
+      runId: createRunId("old-run"),
+      parentBranch: "main",
+      totalTasks: 1,
+      pending: 0,
+      running: 0,
+      completed: 1,
+      failed: 0,
+      startTime: new Date(Date.now() - 10000).toISOString(),
+    });
+
+    await stores.taskStore.save({
+      taskId: createTaskId("old-task-1"),
+      title: "Old Task",
+      description: "From old run",
+      filesToModify: [],
+      dependsOn: [],
+      priority: 1,
+      status: "completed",
+      retryCount: 0,
+    });
+
+    await stores.runStore.save({
+      runId: createRunId("latest-run"),
+      parentBranch: "main",
+      totalTasks: 2,
+      pending: 1,
+      running: 1,
+      completed: 0,
+      failed: 0,
+      startTime: new Date().toISOString(),
+    });
+
+    await stores.taskStore.save({
+      taskId: createTaskId("latest-task-1"),
+      title: "Latest Task 1",
+      description: "From latest run",
+      filesToModify: [],
+      dependsOn: [],
+      priority: 1,
+      status: "running",
+      retryCount: 0,
+    });
+
+    await stores.taskStore.save({
+      taskId: createTaskId("latest-task-2"),
+      title: "Latest Task 2",
+      description: "From latest run",
+      filesToModify: [],
+      dependsOn: [],
+      priority: 2,
+      status: "pending",
+      retryCount: 0,
+    });
+
+    const app = createApp();
+
+    // Without runId arg, should use latest
+    await displayStatus(app);
+
+    // With specific runId, should use that one
+    await displayStatus(app, "old-run");
+
+    // Verify correct run was retrieved
+    const oldRun = await stores.runStore.get(createRunId("old-run"));
+    expect(oldRun).toBeDefined();
+    expect(oldRun?.totalTasks).toBe(1);
+  }, 15_000);
+
+  test("displayStatus shows per-task details when requested", async () => {
+    const runId = createRunId("task-detail-run");
+
+    await stores.runStore.save({
+      runId,
+      parentBranch: "main",
+      totalTasks: 2,
+      pending: 0,
+      running: 0,
+      completed: 2,
+      failed: 0,
+      startTime: new Date().toISOString(),
+    });
+
+    const tasks: Task[] = [
+      {
+        taskId: createTaskId("detail-task-1"),
+        title: "Detailed Task 1",
+        description: "First detailed",
+        filesToModify: ["x.ts"],
+        dependsOn: [],
+        priority: 1,
+        status: "completed",
+        retryCount: 0,
+      },
+      {
+        taskId: createTaskId("detail-task-2"),
+        title: "Detailed Task 2",
+        description: "Second detailed",
+        filesToModify: ["y.ts"],
+        dependsOn: [createTaskId("detail-task-1")],
+        priority: 2,
+        status: "completed",
+        retryCount: 1,
+      },
+    ];
+    for (const t of tasks) {
+      await stores.taskStore.save(t);
+    }
+
+    const app = createApp();
+    await expect(displayStatus(app, "task-detail-run")).resolves.toBeUndefined();
+
+    // Verify tasks can be retrieved
+    const allTasks = await stores.taskStore.getAll();
+    expect(allTasks).toHaveLength(2);
+    expect(allTasks[1]?.retryCount).toBe(1);
+  }, 15_000);
+
+  test("displayStatus returns error when runId not found", async () => {
+    const app = createApp();
+
+    // No runs exist
+    await expect(displayStatus(app, "nonexistent-run")).rejects.toThrow(
+      "Run not found: nonexistent-run"
+    );
+  }, 15_000);
+});