@ronkovic/aad 0.4.0 → 0.5.1

package/src/modules/planning/__tests__/planning-service.test.ts

@@ -55,6 +55,8 @@ function createMockConfig(teamsEnabled: boolean = false): Config {
       host: "localhost",
     },
     git: { autoPush: false },
+      skipCompleted: true,
+      strictTdd: false,
   };
 }
 

package/src/modules/process-manager/__tests__/process-manager.test.ts

@@ -25,6 +25,8 @@ describe("ProcessManager", () => {
         memorySync: false,
         dashboard: { enabled: false, port: 7333, host: "localhost" },
         git: { autoPush: false },
+      skipCompleted: true,
+      strictTdd: false,
       },
       logger,
     });

package/src/modules/process-manager/process-manager.ts

@@ -29,7 +29,7 @@ export class ProcessManager {
   /**
    * Initialize worker pool
    */
-  async initializePool(numWorkers: number): Promise<void> {
+  initializePool(numWorkers: number): Promise<void> {
     if (this.initialized) {
       throw new ProcessManagerError("ProcessManager already initialized");
     }
@@ -49,6 +49,7 @@ export class ProcessManager {
 
     this.initialized = true;
     this.deps.logger.info({ numWorkers }, "Worker pool initialized");
+    return Promise.resolve();
   }
 
   /**

package/src/modules/task-execution/__tests__/executor.test.ts

@@ -43,7 +43,9 @@ describe("executeTddPipeline", () => {
       teams: { splitter: false, reviewer: false },
       memorySync: true,
       dashboard: { enabled: true, port: 7333, host: "localhost" },
-    git: { autoPush: false },
+      git: { autoPush: false },
+      skipCompleted: true,
+      strictTdd: true,
     };
 
     const mockProvider: ClaudeProvider = {
@@ -140,7 +142,9 @@ describe("executeTddPipeline", () => {
       teams: { splitter: false, reviewer: false },
       memorySync: true,
       dashboard: { enabled: true, port: 7333, host: "localhost" },
-    git: { autoPush: false },
+      git: { autoPush: false },
+      skipCompleted: true,
+      strictTdd: true,
     };
 
     let callCount = 0;
@@ -227,7 +231,9 @@ describe("executeTddPipeline", () => {
       teams: { splitter: false, reviewer: false },
       memorySync: true,
       dashboard: { enabled: true, port: 7333, host: "localhost" },
-    git: { autoPush: false },
+      git: { autoPush: false },
+      skipCompleted: true,
+      strictTdd: true,
     };
 
     const mockProvider: ClaudeProvider = {
@@ -318,7 +324,9 @@ describe("executeTddPipeline", () => {
       teams: { splitter: false, reviewer: false },
       memorySync: true,
       dashboard: { enabled: true, port: 7333, host: "localhost" },
-    git: { autoPush: false },
+      git: { autoPush: false },
+      skipCompleted: true,
+      strictTdd: true,
     };
 
     let phaseCount = 0;
@@ -420,7 +428,9 @@ describe("executeTddPipeline", () => {
       teams: { splitter: false, reviewer: false },
       memorySync: true,
       dashboard: { enabled: true, port: 7333, host: "localhost" },
-    git: { autoPush: false },
+      git: { autoPush: false },
+      skipCompleted: true,
+      strictTdd: true,
     };
 
     const mockProvider: ClaudeProvider = {
@@ -517,7 +527,9 @@ describe("executeTddPipeline", () => {
       teams: { splitter: false, reviewer: false },
       memorySync: true,
       dashboard: { enabled: true, port: 7333, host: "localhost" },
-    git: { autoPush: false },
+      git: { autoPush: false },
+      skipCompleted: true,
+      strictTdd: true,
     };
 
     let callCount = 0;
@@ -578,7 +590,9 @@ describe("executeTddPipeline", () => {
       teams: { splitter: false, reviewer: false },
       memorySync: true,
       dashboard: { enabled: true, port: 7333, host: "localhost" },
-    git: { autoPush: false },
+      git: { autoPush: false },
+      skipCompleted: true,
+      strictTdd: true,
     };
 
     const mockProvider: ClaudeProvider = {
@@ -636,7 +650,9 @@ describe("executeTddPipeline", () => {
       teams: { splitter: false, reviewer: false },
       memorySync: true,
       dashboard: { enabled: true, port: 7333, host: "localhost" },
-    git: { autoPush: false },
+      git: { autoPush: false },
+      skipCompleted: true,
+      strictTdd: true,
     };
 
     const mockProvider: ClaudeProvider = {
@@ -695,7 +711,9 @@ describe("executeTddPipeline", () => {
       teams: { splitter: false, reviewer: false },
       memorySync: true,
       dashboard: { enabled: true, port: 7333, host: "localhost" },
-    git: { autoPush: false },
+      git: { autoPush: false },
+      skipCompleted: true,
+      strictTdd: true,
     };
 
     const mockProvider: ClaudeProvider = {
@@ -747,7 +765,9 @@ describe("executeTddPipeline", () => {
       teams: { splitter: false, reviewer: false },
       memorySync: true,
       dashboard: { enabled: true, port: 7333, host: "localhost" },
-    git: { autoPush: false },
+      git: { autoPush: false },
+      skipCompleted: true,
+      strictTdd: true,
     };
 
     const mockProvider: ClaudeProvider = {
@@ -800,6 +820,8 @@ describe("executeTddPipeline", () => {
       memorySync: true,
       dashboard: { enabled: true, port: 7333, host: "localhost" },
       git: { autoPush: false },
+      skipCompleted: true,
+      strictTdd: true,
     };
 
     const mockProvider: ClaudeProvider = {
@@ -843,4 +865,392 @@ describe("executeTddPipeline", () => {
     expect(warnEvents.some((e) => e.entry?.message?.includes("Red phase"))).toBe(true);
     expect(warnEvents.some((e) => e.entry?.message?.includes("Green phase"))).toBe(true);
   });
+
+  test("skips pipeline when tests already pass (pre-check succeeds)", async () => {
+    const task: Task = {
+      taskId: createTaskId("task-skip-001"),
+      title: "Already passing task",
+      description: "Tests already pass",
+      filesToModify: ["src/feature.ts"],
+      dependsOn: [],
+      priority: 1,
+      status: "running",
+      retryCount: 0,
+    };
+
+    const workspace: WorkspaceInfo = {
+      path: "/workspace",
+      language: "typescript",
+      packageManager: "bun",
+      framework: "hono",
+      testFramework: "bun-test",
+    };
+
+    const config: Config = {
+      workers: { num: 2, max: 8 },
+      models: {},
+      timeouts: { claude: 1200, test: 600, staleTask: 5400 },
+      retry: { maxRetries: 2 },
+      debug: false,
+      adaptiveEffort: false,
+      teams: { splitter: false, reviewer: false },
+      memorySync: true,
+      dashboard: { enabled: true, port: 7333, host: "localhost" },
+      git: { autoPush: false },
+      skipCompleted: true,
+      strictTdd: false,
+    };
+
+    let claudeCallCount = 0;
+    const mockProvider: ClaudeProvider = {
+      async call(): Promise<ClaudeResponse> {
+        claudeCallCount++;
+        return {
+          result: "Should not be called",
+          exitCode: 0,
+          model: "claude-sonnet-4-5",
+          effortLevel: "medium",
+          duration: 1000,
+        };
+      },
+    };
+
+    const mockMergeService = {
+      async mergeToParent(): Promise<MergeResult> {
+        throw new Error("Should not reach merge");
+      },
+    } as unknown as MergeService;
+
+    const events: string[] = [];
+    const mockEventBus = {
+      on() {},
+      off() {},
+      emit(event: any) {
+        events.push(event.type);
+      },
+    } as unknown as EventBus;
+
+    // Pre-check always passes
+    const mockSpawner = {
+      async spawn() {
+        return { exitCode: 0, stdout: "All tests passed", stderr: "" };
+      },
+    };
+
+    const result = await executeTddPipeline(
+      task, workspace, "branch", "main", "/parent", createRunId("run-skip"), config,
+      mockProvider, mockMergeService, mockEventBus, mockSpawner
+    );
+
+    expect(result.status).toBe("completed");
+    expect(result.skipped).toBe(true);
+    expect(result.phasesExecuted).toEqual(["pre-check"]);
+    expect(claudeCallCount).toBe(0); // No Claude calls made
+    expect(events).toContain("execution:skipped");
+  });
+
+  test("runs full pipeline when tests fail pre-check", async () => {
+    const task: Task = {
+      taskId: createTaskId("task-run-full"),
+      title: "Tests need work",
+      description: "Pre-check fails, run full pipeline",
+      filesToModify: [],
+      dependsOn: [],
+      priority: 1,
+      status: "running",
+      retryCount: 0,
+    };
+
+    const workspace: WorkspaceInfo = {
+      path: "/workspace",
+      language: "typescript",
+      packageManager: "bun",
+      framework: "hono",
+      testFramework: "bun-test",
+    };
+
+    const config: Config = {
+      workers: { num: 2, max: 8 },
+      models: {},
+      timeouts: { claude: 1200, test: 600, staleTask: 5400 },
+      retry: { maxRetries: 2 },
+      debug: false,
+      adaptiveEffort: false,
+      teams: { splitter: false, reviewer: false },
+      memorySync: true,
+      dashboard: { enabled: true, port: 7333, host: "localhost" },
+      git: { autoPush: false },
+      skipCompleted: true,
+      strictTdd: false,
+    };
+
+    const mockProvider: ClaudeProvider = {
+      async call(): Promise<ClaudeResponse> {
+        return {
+          result: "OK",
+          exitCode: 0,
+          model: "claude-sonnet-4-5",
+          effortLevel: "medium",
+          duration: 1000,
+        };
+      },
+    };
+
+    const mockMergeService = {
+      async mergeToParent(): Promise<MergeResult> {
+        return { success: true };
+      },
+    } as unknown as MergeService;
+
+    const events: string[] = [];
+    const mockEventBus = {
+      on() {},
+      off() {},
+      emit(event: any) {
+        events.push(event.type);
+      },
+    } as unknown as EventBus;
+
+    let precheckDone = false;
+    const mockSpawner = {
+      async spawn() {
+        if (!precheckDone) {
+          precheckDone = true;
+          return { exitCode: 1, stdout: "", stderr: "Tests failed" };
+        }
+        return { exitCode: 0, stdout: "OK", stderr: "" };
+      },
+    };
+
+    const result = await executeTddPipeline(
+      task, workspace, "branch", "main", "/parent", createRunId("run-full"), config,
+      mockProvider, mockMergeService, mockEventBus, mockSpawner
+    );
+
+    expect(result.status).toBe("completed");
+    expect(result.skipped).toBeUndefined();
+    expect(events).toContain("execution:phase:started");
+    expect(events).not.toContain("execution:skipped");
+  });
+
+  test("respects strictTdd flag to skip pre-check", async () => {
+    const task: Task = {
+      taskId: createTaskId("task-strict"),
+      title: "Strict TDD mode",
+      description: "Always run full pipeline",
+      filesToModify: [],
+      dependsOn: [],
+      priority: 1,
+      status: "running",
+      retryCount: 0,
+    };
+
+    const workspace: WorkspaceInfo = {
+      path: "/workspace",
+      language: "typescript",
+      packageManager: "bun",
+      framework: "hono",
+      testFramework: "bun-test",
+    };
+
+    const config: Config = {
+      workers: { num: 2, max: 8 },
+      models: {},
+      timeouts: { claude: 1200, test: 600, staleTask: 5400 },
+      retry: { maxRetries: 2 },
+      debug: false,
+      adaptiveEffort: false,
+      teams: { splitter: false, reviewer: false },
+      memorySync: true,
+      dashboard: { enabled: true, port: 7333, host: "localhost" },
+      git: { autoPush: false },
+      skipCompleted: true,
+      strictTdd: true,
+    };
+
+    const mockProvider: ClaudeProvider = {
+      async call(): Promise<ClaudeResponse> {
+        return {
+          result: "OK",
+          exitCode: 0,
+          model: "claude-sonnet-4-5",
+          effortLevel: "medium",
+          duration: 1000,
+        };
+      },
+    };
+
+    const mockMergeService = {
+      async mergeToParent(): Promise<MergeResult> {
+        return { success: true };
+      },
+    } as unknown as MergeService;
+
+    const events: string[] = [];
+    const mockEventBus = {
+      on() {},
+      off() {},
+      emit(event: any) {
+        events.push(event.type);
+      },
+    } as unknown as EventBus;
+
+    const mockSpawner = {
+      async spawn() {
+        return { exitCode: 0, stdout: "OK", stderr: "" };
+      },
+    };
+
+    const result = await executeTddPipeline(
+      task, workspace, "branch", "main", "/parent", createRunId("run-strict"), config,
+      mockProvider, mockMergeService, mockEventBus, mockSpawner
+    );
+
+    expect(result.status).toBe("completed");
+    expect(result.skipped).toBeUndefined();
+    expect(events).toContain("execution:phase:started");
+    expect(events).not.toContain("execution:skipped");
+  });
+
+  test("emits execution:skipped event when skipping", async () => {
+    const task: Task = {
+      taskId: createTaskId("task-event-skip"),
+      title: "Event test",
+      description: "Test skip event",
+      filesToModify: [],
+      dependsOn: [],
+      priority: 1,
+      status: "running",
+      retryCount: 0,
+    };
+
+    const workspace: WorkspaceInfo = {
+      path: "/workspace",
+      language: "typescript",
+      packageManager: "bun",
+      framework: "hono",
+      testFramework: "bun-test",
+    };
+
+    const config: Config = {
+      workers: { num: 2, max: 8 },
+      models: {},
+      timeouts: { claude: 1200, test: 600, staleTask: 5400 },
+      retry: { maxRetries: 2 },
+      debug: false,
+      adaptiveEffort: false,
+      teams: { splitter: false, reviewer: false },
+      memorySync: true,
+      dashboard: { enabled: true, port: 7333, host: "localhost" },
+      git: { autoPush: false },
+      skipCompleted: true,
+      strictTdd: false,
+    };
+
+    const mockProvider: ClaudeProvider = {
+      async call(): Promise<ClaudeResponse> {
+        throw new Error("Should not be called");
+      },
+    };
+
+    const mockMergeService = {
+      async mergeToParent(): Promise<MergeResult> {
+        throw new Error("Should not reach merge");
+      },
+    } as unknown as MergeService;
+
+    const events: Array<{ type: string; taskId?: string }> = [];
+    const mockEventBus = {
+      on() {},
+      off() {},
+      emit(event: any) {
+        events.push(event);
+      },
+    } as unknown as EventBus;
+
+    const mockSpawner = {
+      async spawn() {
+        return { exitCode: 0, stdout: "Tests pass", stderr: "" };
+      },
+    };
+
+    await executeTddPipeline(
+      task, workspace, "branch", "main", "/parent", createRunId("run-evt"), config,
+      mockProvider, mockMergeService, mockEventBus, mockSpawner
+    );
+
+    const skipEvent = events.find((e) => e.type === "execution:skipped");
+    expect(skipEvent).toBeDefined();
+    expect(skipEvent?.taskId).toBe(task.taskId);
+  });
+
+  test("includes skipped flag in result when skipped", async () => {
+    const task: Task = {
+      taskId: createTaskId("task-result-flag"),
+      title: "Result flag test",
+      description: "Test result structure",
+      filesToModify: [],
+      dependsOn: [],
+      priority: 1,
+      status: "running",
+      retryCount: 0,
+    };
+
+    const workspace: WorkspaceInfo = {
+      path: "/workspace",
+      language: "typescript",
+      packageManager: "bun",
+      framework: "hono",
+      testFramework: "bun-test",
+    };
+
+    const config: Config = {
+      workers: { num: 2, max: 8 },
+      models: {},
+      timeouts: { claude: 1200, test: 600, staleTask: 5400 },
+      retry: { maxRetries: 2 },
+      debug: false,
+      adaptiveEffort: false,
+      teams: { splitter: false, reviewer: false },
+      memorySync: true,
+      dashboard: { enabled: true, port: 7333, host: "localhost" },
+      git: { autoPush: false },
+      skipCompleted: true,
+      strictTdd: false,
+    };
+
+    const mockProvider: ClaudeProvider = {
+      async call(): Promise<ClaudeResponse> {
+        throw new Error("Should not be called");
+      },
+    };
+
+    const mockMergeService = {
+      async mergeToParent(): Promise<MergeResult> {
+        throw new Error("Should not reach merge");
+      },
+    } as unknown as MergeService;
+
+    const mockEventBus = {
+      on() {},
+      off() {},
+      emit() {},
+    } as unknown as EventBus;
+
+    const mockSpawner = {
+      async spawn() {
+        return { exitCode: 0, stdout: "Pass", stderr: "" };
+      },
+    };
+
+    const result = await executeTddPipeline(
+      task, workspace, "branch", "main", "/parent", createRunId("run-flag"), config,
+      mockProvider, mockMergeService, mockEventBus, mockSpawner
+    );
+
+    expect(result.status).toBe("completed");
+    expect(result.skipped).toBe(true);
+    expect(result.phasesExecuted).toEqual(["pre-check"]);
+    expect(result.duration).toBeGreaterThanOrEqual(0);
+  });
 });

package/src/modules/task-execution/executor.ts

@@ -28,9 +28,22 @@ export interface RetryContext {
   previousFailure?: PreviousFailure;
 }
 
+/**
+ * Run pre-check to see if tests already pass
+ */
+async function runPreCheck(
+  workspace: WorkspaceInfo,
+  testSpawner: ProcessSpawner | undefined,
+  timeout: number
+): Promise<boolean> {
+  const result = await runTests(workspace, testSpawner, timeout);
+  return result.success;
+}
+
 /**
  * Execute full TDD pipeline for a task
  * Phases: Red → Green → Verify → Review → Merge
+ * Optionally skips pipeline if tests already pass (pre-check)
  */
 export async function executeTddPipeline(
   task: Task,
@@ -49,6 +62,68 @@ export async function executeTddPipeline(
   const startTime = Date.now();
 
   try {
+    // ===== Pre-check: Skip if tests already pass (unless strictTdd) =====
+    if (config.skipCompleted && !config.strictTdd) {
+      eventBus.emit({
+        type: "log:entry",
+        entry: {
+          level: "info",
+          service: "task-execution",
+          message: "Running pre-check to see if tests already pass",
+          timestamp: Date.now(),
+          taskId: task.taskId as string,
+        },
+      });
+
+      const testsAlreadyPass = await runPreCheck(
+        workspace,
+        testSpawner,
+        config.timeouts.test * 1000
+      );
+
+      if (testsAlreadyPass) {
+        const duration = Date.now() - startTime;
+
+        eventBus.emit({
+          type: "execution:skipped",
+          taskId: task.taskId,
+          reason: "Tests already pass",
+        });
+
+        eventBus.emit({
+          type: "log:entry",
+          entry: {
+            level: "info",
+            service: "task-execution",
+            message: "Tests already pass, skipping TDD pipeline",
+            timestamp: Date.now(),
+            taskId: task.taskId as string,
+            duration,
+          },
+        });
+
+        return {
+          taskId: task.taskId,
+          status: "completed",
+          duration,
+          output: "Skipped: tests already pass",
+          skipped: true,
+          phasesExecuted: ["pre-check"],
+        };
+      }
+
+      eventBus.emit({
+        type: "log:entry",
+        entry: {
+          level: "info",
+          service: "task-execution",
+          message: "Pre-check failed, running full TDD pipeline",
+          timestamp: Date.now(),
+          taskId: task.taskId as string,
+        },
+      });
+    }
+
     // Estimate task complexity for adaptive effort
     const complexity = estimateTaskComplexity(task);
     const testerEffort = getAdaptiveEffortLevel("tester", complexity, config);
@@ -365,6 +440,7 @@ export async function executeTddPipeline(
       status: "completed",
       duration,
       output: "TDD pipeline completed successfully",
+      phasesExecuted: ["red", "green", "verify", "review", "merge"],
     };
   } catch (error) {
     const duration = Date.now() - startTime;