@ronkovic/aad 0.3.0

package/src/modules/cli/__tests__/cleanup.test.ts

@@ -0,0 +1,111 @@
+/**
+ * Cleanup Command Tests
+ */
+
+import { describe, test, expect, beforeEach, mock } from "bun:test";
+import type { App } from "../app";
+import { cleanupWorktrees } from "../commands/cleanup";
+
+describe("cleanupWorktrees", () => {
+  let mockApp: App;
+
+  beforeEach(() => {
+    mockApp = {
+      config: {} as any,
+      eventBus: {} as any,
+      logger: {
+        info: mock(() => {}),
+        debug: mock(() => {}),
+      } as any,
+      stores: {} as any,
+      dispatcher: {} as any,
+      processManager: {} as any,
+      planningService: {} as any,
+      providerRegistry: {} as any,
+      worktreeManager: {
+        listWorktrees: mock(async () => [
+          {
+            path: `${process.cwd()}/.aad/worktrees/task-1`,
+            branch: "aad/task-1",
+            head: "abc123",
+          },
+          {
+            path: `${process.cwd()}/.aad/worktrees/task-2`,
+            branch: "aad/task-2",
+            head: "def456",
+          },
+        ]),
+        removeWorktree: mock(async () => {}),
+        pruneWorktrees: mock(async () => {}),
+      } as any,
+      branchManager: {
+        cleanupOrphanBranches: mock(async () => ["aad-task-1", "aad-task-2"]),
+      } as any,
+      mergeService: {} as any,
+      pluginManager: { runHook: mock(async (_p: string, d: unknown) => d), deactivateAll: mock(async () => {}), register: mock(async () => {}), loadFromConfig: mock(async () => {}), addHook: mock(() => {}), list: mock(() => []) } as any,
+      shutdown: mock(async () => {}),
+    };
+  });
+
+  test("cleans up all AAD worktrees", async () => {
+    await cleanupWorktrees(mockApp);
+
+    expect(mockApp.worktreeManager.listWorktrees).toHaveBeenCalled();
+    expect(mockApp.worktreeManager.removeWorktree).toHaveBeenCalledTimes(2);
+    expect(mockApp.worktreeManager.pruneWorktrees).toHaveBeenCalled();
+    expect(mockApp.branchManager.cleanupOrphanBranches).toHaveBeenCalled();
+  });
+
+  test("cleans up worktrees with force flag", async () => {
+    await cleanupWorktrees(mockApp, undefined, true);
+
+    expect(mockApp.worktreeManager.removeWorktree).toHaveBeenCalledWith(
+      expect.stringContaining(".aad/worktrees"),
+      true
+    );
+  });
+
+  test("filters worktrees by runId", async () => {
+    mockApp.worktreeManager.listWorktrees = mock(async () => [
+      {
+        path: `${process.cwd()}/.aad/worktrees/run-123/task-1`,
+        branch: "aad/run-123/task-1",
+        head: "abc123",
+      },
+      {
+        path: `${process.cwd()}/.aad/worktrees/run-456/task-2`,
+        branch: "aad/run-456/task-2",
+        head: "def456",
+      },
+    ]);
+
+    await cleanupWorktrees(mockApp, "run-123");
+
+    // Should only remove worktrees matching run-123
+    expect(mockApp.worktreeManager.removeWorktree).toHaveBeenCalledTimes(1);
+    expect(mockApp.worktreeManager.removeWorktree).toHaveBeenCalledWith(
+      expect.stringContaining("run-123"),
+      false
+    );
+  });
+
+  test("handles empty worktree list", async () => {
+    mockApp.worktreeManager.listWorktrees = mock(async () => []);
+
+    await cleanupWorktrees(mockApp);
+    // Should complete without throwing
+    expect(mockApp.worktreeManager.removeWorktree).not.toHaveBeenCalled();
+  });
+
+  test("continues on individual worktree removal failure", async () => {
+    mockApp.worktreeManager.removeWorktree = mock(async (path: string) => {
+      if (path.includes("task-1")) {
+        throw new Error("Failed to remove");
+      }
+    });
+
+    await cleanupWorktrees(mockApp);
+    // Should have attempted both despite error
+    expect(mockApp.worktreeManager.removeWorktree).toHaveBeenCalledTimes(2);
+  });
+});

package/src/modules/cli/__tests__/commands.test.ts

@@ -0,0 +1,186 @@
+/**
+ * CLI Commands Tests (Resume, Status, Cleanup)
+ */
+
+import { describe, test, expect, mock } from "bun:test";
+import type { App } from "../app";
+import { resumeRun } from "../commands/resume";
+import { displayStatus } from "../commands/status";
+import { cleanupWorktrees } from "../commands/cleanup";
+import { createRunId, createTaskId, type Task, type RunState } from "../../../shared/types";
+import { EventBus } from "../../../shared/events";
+
+describe("Resume Command", () => {
+  test("resumes run with pending tasks", async () => {
+    const mockRunId = createRunId("test-run-id");
+    const mockRunState: RunState = {
+      runId: mockRunId,
+      parentBranch: "main",
+      totalTasks: 1,
+      pending: 0,
+      running: 1,
+      completed: 0,
+      failed: 0,
+      startTime: new Date().toISOString(),
+    };
+
+    const mockTask: Task = {
+      taskId: createTaskId("task-test-run-id-1"),
+      title: "Test",
+      description: "Test",
+      filesToModify: [],
+      dependsOn: [],
+      priority: 1,
+      status: "running",
+      retryCount: 0,
+    };
+
+    const eventBus = new EventBus();
+
+    const mockApp: App = {
+      eventBus,
+      logger: {
+        info: mock(() => {}),
+        error: mock(() => {}),
+      } as any,
+      stores: {
+        runStore: {
+          get: mock(async () => mockRunState),
+        } as any,
+        taskStore: {
+          list: mock(async () => [mockTask]),
+          getAll: mock(async () => [mockTask]),
+          save: mock(async () => {}),
+        } as any,
+      } as any,
+      dispatcher: {
+        initialize: mock(async () => {}),
+        start: mock(() => {}),
+      } as any,
+      processManager: {
+        initializePool: mock(async () => {}),
+      } as any,
+      config: {
+        workers: { num: 2, max: 8 },
+        timeouts: { claude: 1200, test: 600, staleTask: 5400 },
+      } as any,
+      shutdown: mock(async () => {}),
+    } as any;
+
+    // Emit run:completed to unblock resumeRun
+    setTimeout(() => {
+      eventBus.emit({ type: "run:completed", runId: mockRunId });
+    }, 10);
+
+    await resumeRun(mockApp, "test-run-id");
+
+    expect(mockApp.stores.runStore.get).toHaveBeenCalledTimes(1);
+    expect(mockApp.stores.taskStore.save).toHaveBeenCalledTimes(1);
+    expect(mockApp.dispatcher.initialize).toHaveBeenCalledTimes(1);
+    expect(mockApp.dispatcher.start).toHaveBeenCalledTimes(1);
+    expect(mockApp.shutdown).toHaveBeenCalledTimes(1);
+  });
+});
+
+describe("Status Command", () => {
+  test("displays status for existing run", async () => {
+    const mockRunId = createRunId("test-run-id");
+    const mockRunState: RunState = {
+      runId: mockRunId,
+      parentBranch: "main",
+      totalTasks: 1,
+      pending: 0,
+      running: 0,
+      completed: 1,
+      failed: 0,
+      startTime: new Date().toISOString(),
+      endTime: new Date().toISOString(),
+    };
+
+    const mockApp: App = {
+      logger: {
+        info: mock(() => {}),
+      } as any,
+      stores: {
+        runStore: {
+          get: mock(async () => mockRunState),
+        } as any,
+        taskStore: {
+          getAll: mock(async () => []),
+        } as any,
+      } as any,
+    } as any;
+
+    await displayStatus(mockApp, "test-run-id");
+
+    expect(mockApp.stores.runStore.get).toHaveBeenCalledTimes(1);
+    expect(mockApp.stores.taskStore.getAll).toHaveBeenCalledTimes(1);
+  });
+
+  test("throws error for non-existent run", async () => {
+    const mockApp: App = {
+      logger: {
+        info: mock(() => {}),
+      } as any,
+      stores: {
+        runStore: {
+          get: mock(async () => null),
+        } as any,
+      } as any,
+    } as any;
+
+    await expect(displayStatus(mockApp, "non-existent")).rejects.toThrow("Run not found");
+  });
+});
+
+describe("Cleanup Command", () => {
+  test("cleans up worktrees and branches", async () => {
+    const mockApp: App = {
+      logger: {
+        info: mock(() => {}),
+        debug: mock(() => {}),
+      } as any,
+      worktreeManager: {
+        listWorktrees: mock(async () => [
+          { path: `${process.cwd()}/.aad/worktrees/task-1`, branch: "aad/run/task-1" },
+        ]),
+        removeWorktree: mock(async () => {}),
+        pruneWorktrees: mock(async () => {}),
+      } as any,
+      branchManager: {
+        cleanupOrphanBranches: mock(async () => ["aad/run/task-1"]),
+      } as any,
+    } as any;
+
+    await cleanupWorktrees(mockApp, undefined, false);
+
+    expect(mockApp.worktreeManager.listWorktrees).toHaveBeenCalledTimes(1);
+    expect(mockApp.worktreeManager.removeWorktree).toHaveBeenCalledTimes(1);
+    expect(mockApp.branchManager.cleanupOrphanBranches).toHaveBeenCalledTimes(1);
+  });
+
+  test("filters by runId when specified", async () => {
+    const mockApp: App = {
+      logger: {
+        info: mock(() => {}),
+        debug: mock(() => {}),
+      } as any,
+      worktreeManager: {
+        listWorktrees: mock(async () => [
+          { path: `${process.cwd()}/.aad/worktrees/task-run1-1`, branch: "aad/run1/task-1" },
+          { path: `${process.cwd()}/.aad/worktrees/task-run2-1`, branch: "aad/run2/task-1" },
+        ]),
+        removeWorktree: mock(async () => {}),
+        pruneWorktrees: mock(async () => {}),
+      } as any,
+      branchManager: {
+        cleanupOrphanBranches: mock(async () => []),
+      } as any,
+    } as any;
+
+    await cleanupWorktrees(mockApp, "run1", false);
+
+    // Should only remove worktrees matching run1
+    expect(mockApp.worktreeManager.removeWorktree).toHaveBeenCalledTimes(1);
+  });
+});

package/src/modules/cli/__tests__/output.test.ts

@@ -0,0 +1,329 @@
+import { describe, test, expect } from "bun:test";
+import {
+  formatProgress,
+  formatTaskTable,
+  formatRunStatus,
+  formatError,
+  formatDuration,
+  createSpinner,
+} from "../output";
+import type { ProgressState, Task, RunState } from "@aad/shared/types";
+import { createTaskId, createWorkerId, createRunId } from "@aad/shared/types";
+
+describe("formatProgress", () => {
+  test("formats progress state with all counts", () => {
+    const state: ProgressState = {
+      total: 10,
+      pending: 2,
+      running: 3,
+      completed: 4,
+      failed: 1,
+    };
+
+    const result = formatProgress(state);
+
+    expect(result).toContain("40%");
+    expect(result).toContain("2 pending");
+    expect(result).toContain("3 running");
+    expect(result).toContain("4 completed");
+    expect(result).toContain("1 failed");
+  });
+
+  test("formats progress state with zero failed", () => {
+    const state: ProgressState = {
+      total: 10,
+      pending: 5,
+      running: 2,
+      completed: 3,
+      failed: 0,
+    };
+
+    const result = formatProgress(state);
+
+    expect(result).toContain("30%");
+    expect(result).not.toContain("failed");
+  });
+
+  test("handles empty progress state", () => {
+    const state: ProgressState = {
+      total: 0,
+      pending: 0,
+      running: 0,
+      completed: 0,
+      failed: 0,
+    };
+
+    const result = formatProgress(state);
+
+    expect(result).toContain("0%");
+  });
+
+  test("contains ANSI color codes", () => {
+    const state: ProgressState = {
+      total: 10,
+      pending: 2,
+      running: 3,
+      completed: 4,
+      failed: 1,
+    };
+
+    const result = formatProgress(state);
+
+    // Check for ANSI escape sequences
+    expect(result).toMatch(/\x1b\[[0-9;]*m/);
+  });
+});
+
+describe("formatTaskTable", () => {
+  test("formats empty task list", () => {
+    const result = formatTaskTable([]);
+    expect(result).toContain("No tasks found");
+  });
+
+  test("formats single task", () => {
+    const tasks: Task[] = [
+      {
+        taskId: createTaskId("task-001"),
+        title: "Implement feature X",
+        description: "Add new feature",
+        filesToModify: ["src/main.ts"],
+        dependsOn: [],
+        priority: 1,
+        status: "completed",
+        workerId: createWorkerId("worker-001"),
+        startTime: "2024-01-01T00:00:00Z",
+        endTime: "2024-01-01T00:05:00Z",
+        retryCount: 0,
+      },
+    ];
+
+    const result = formatTaskTable(tasks);
+
+    expect(result).toContain("task-001");
+    expect(result).toContain("Implement feature X");
+    expect(result).toContain("completed");
+    expect(result).toContain("worker-0");
+  });
+
+  test("formats multiple tasks", () => {
+    const tasks: Task[] = [
+      {
+        taskId: createTaskId("task-001"),
+        title: "Task 1",
+        description: "First task",
+        filesToModify: [],
+        dependsOn: [],
+        priority: 1,
+        status: "completed",
+        retryCount: 0,
+      },
+      {
+        taskId: createTaskId("task-002"),
+        title: "Task 2",
+        description: "Second task",
+        filesToModify: [],
+        dependsOn: [],
+        priority: 2,
+        status: "running",
+        workerId: createWorkerId("worker-001"),
+        startTime: new Date().toISOString(),
+        retryCount: 0,
+      },
+    ];
+
+    const result = formatTaskTable(tasks);
+
+    expect(result).toContain("task-001");
+    expect(result).toContain("task-002");
+    expect(result).toContain("Task 1");
+    expect(result).toContain("Task 2");
+  });
+
+  test("truncates long titles", () => {
+    const tasks: Task[] = [
+      {
+        taskId: createTaskId("task-001"),
+        title: "This is a very long task title that should be truncated",
+        description: "Test truncation",
+        filesToModify: [],
+        dependsOn: [],
+        priority: 1,
+        status: "pending",
+        retryCount: 0,
+      },
+    ];
+
+    const result = formatTaskTable(tasks);
+
+    expect(result).toContain("...");
+    expect(result.indexOf("This is a very long task title")).toBeGreaterThan(
+      -1
+    );
+  });
+
+  test("handles task without worker", () => {
+    const tasks: Task[] = [
+      {
+        taskId: createTaskId("task-001"),
+        title: "Task without worker",
+        description: "Test",
+        filesToModify: [],
+        dependsOn: [],
+        priority: 1,
+        status: "pending",
+        retryCount: 0,
+      },
+    ];
+
+    const result = formatTaskTable(tasks);
+
+    expect(result).toContain("task-001");
+    expect(result).toContain("-"); // Worker column should show "-"
+  });
+});
+
+describe("formatRunStatus", () => {
+  test("formats run state with all fields", () => {
+    const state: RunState = {
+      runId: createRunId("run-12345"),
+      parentBranch: "main",
+      totalTasks: 10,
+      pending: 2,
+      running: 3,
+      completed: 4,
+      failed: 1,
+      startTime: "2024-01-01T00:00:00Z",
+      endTime: "2024-01-01T01:00:00Z",
+    };
+
+    const result = formatRunStatus(state);
+
+    expect(result).toContain("run-12345");
+    expect(result).toContain("main");
+    expect(result).toContain("40%"); // Progress percentage
+  });
+
+  test("formats ongoing run without endTime", () => {
+    const state: RunState = {
+      runId: createRunId("run-67890"),
+      parentBranch: "feature/test",
+      totalTasks: 5,
+      pending: 1,
+      running: 2,
+      completed: 2,
+      failed: 0,
+      startTime: new Date(Date.now() - 10000).toISOString(), // 10 seconds ago
+    };
+
+    const result = formatRunStatus(state);
+
+    expect(result).toContain("run-67890");
+    expect(result).toContain("feature/test");
+    expect(result).toMatch(/\d+s/); // Should show duration in seconds
+  });
+});
+
+describe("formatError", () => {
+  test("formats error with message", () => {
+    const error = new Error("Something went wrong");
+    const result = formatError(error);
+
+    expect(result).toContain("Error:");
+    expect(result).toContain("Something went wrong");
+  });
+
+  test("formats error with stack trace", () => {
+    const error = new Error("Test error");
+    Error.captureStackTrace(error);
+
+    const result = formatError(error);
+
+    expect(result).toContain("Error:");
+    expect(result).toContain("Test error");
+    // Stack trace should be included
+    expect(result.split("\n").length).toBeGreaterThan(1);
+  });
+
+  test("contains ANSI color codes", () => {
+    const error = new Error("Colored error");
+    const result = formatError(error);
+
+    expect(result).toMatch(/\x1b\[[0-9;]*m/);
+  });
+});
+
+describe("formatDuration", () => {
+  test("formats seconds", () => {
+    expect(formatDuration(5000)).toBe("5s");
+    expect(formatDuration(30000)).toBe("30s");
+    expect(formatDuration(59000)).toBe("59s");
+  });
+
+  test("formats minutes and seconds", () => {
+    expect(formatDuration(60000)).toBe("1m 0s");
+    expect(formatDuration(90000)).toBe("1m 30s");
+    expect(formatDuration(3599000)).toBe("59m 59s");
+  });
+
+  test("formats hours and minutes", () => {
+    expect(formatDuration(3600000)).toBe("1h 0m");
+    expect(formatDuration(5400000)).toBe("1h 30m");
+    expect(formatDuration(7200000)).toBe("2h 0m");
+  });
+
+  test("handles zero duration", () => {
+    expect(formatDuration(0)).toBe("0s");
+  });
+
+  test("handles negative duration", () => {
+    expect(formatDuration(-1000)).toBe("0s");
+  });
+
+  test("handles sub-second duration", () => {
+    expect(formatDuration(500)).toBe("0s");
+    expect(formatDuration(999)).toBe("0s");
+  });
+});
+
+describe("createSpinner", () => {
+  test("creates spinner object with required methods", () => {
+    const spinner = createSpinner("Loading...");
+
+    expect(spinner).toHaveProperty("start");
+    expect(spinner).toHaveProperty("stop");
+    expect(spinner).toHaveProperty("succeed");
+    expect(spinner).toHaveProperty("fail");
+    expect(typeof spinner.start).toBe("function");
+    expect(typeof spinner.stop).toBe("function");
+    expect(typeof spinner.succeed).toBe("function");
+    expect(typeof spinner.fail).toBe("function");
+  });
+
+  test("spinner can be started and stopped", () => {
+    const spinner = createSpinner("Processing...");
+
+    expect(() => spinner.start()).not.toThrow();
+    expect(() => spinner.stop()).not.toThrow();
+  });
+
+  test("spinner can succeed with custom message", () => {
+    const spinner = createSpinner("Working...");
+
+    spinner.start();
+    expect(() => spinner.succeed("Done!")).not.toThrow();
+  });
+
+  test("spinner can fail with custom message", () => {
+    const spinner = createSpinner("Attempting...");
+
+    spinner.start();
+    expect(() => spinner.fail("Failed!")).not.toThrow();
+  });
+
+  test("spinner can succeed without custom message", () => {
+    const spinner = createSpinner("Default message");
+
+    spinner.start();
+    expect(() => spinner.succeed()).not.toThrow();
+  });
+});