@ronkovic/aad 0.3.9 → 0.5.0

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

@@ -43,6 +43,9 @@ describe("executeTddPipeline", () => {
       teams: { splitter: false, reviewer: false },
       memorySync: true,
       dashboard: { enabled: true, port: 7333, host: "localhost" },
+      git: { autoPush: false },
+      skipCompleted: true,
+      strictTdd: true,
     };
 
     const mockProvider: ClaudeProvider = {
@@ -139,6 +142,9 @@ describe("executeTddPipeline", () => {
       teams: { splitter: false, reviewer: false },
       memorySync: true,
       dashboard: { enabled: true, port: 7333, host: "localhost" },
+      git: { autoPush: false },
+      skipCompleted: true,
+      strictTdd: true,
     };
 
     let callCount = 0;
@@ -225,6 +231,9 @@ describe("executeTddPipeline", () => {
       teams: { splitter: false, reviewer: false },
       memorySync: true,
       dashboard: { enabled: true, port: 7333, host: "localhost" },
+      git: { autoPush: false },
+      skipCompleted: true,
+      strictTdd: true,
     };
 
     const mockProvider: ClaudeProvider = {
@@ -315,6 +324,9 @@ describe("executeTddPipeline", () => {
       teams: { splitter: false, reviewer: false },
       memorySync: true,
       dashboard: { enabled: true, port: 7333, host: "localhost" },
+      git: { autoPush: false },
+      skipCompleted: true,
+      strictTdd: true,
     };
 
     let phaseCount = 0;
@@ -416,6 +428,9 @@ describe("executeTddPipeline", () => {
       teams: { splitter: false, reviewer: false },
       memorySync: true,
       dashboard: { enabled: true, port: 7333, host: "localhost" },
+      git: { autoPush: false },
+      skipCompleted: true,
+      strictTdd: true,
     };
 
     const mockProvider: ClaudeProvider = {
@@ -512,6 +527,9 @@ describe("executeTddPipeline", () => {
       teams: { splitter: false, reviewer: false },
       memorySync: true,
       dashboard: { enabled: true, port: 7333, host: "localhost" },
+      git: { autoPush: false },
+      skipCompleted: true,
+      strictTdd: true,
     };
 
     let callCount = 0;
@@ -572,6 +590,9 @@ describe("executeTddPipeline", () => {
       teams: { splitter: false, reviewer: false },
       memorySync: true,
       dashboard: { enabled: true, port: 7333, host: "localhost" },
+      git: { autoPush: false },
+      skipCompleted: true,
+      strictTdd: true,
     };
 
     const mockProvider: ClaudeProvider = {
@@ -629,6 +650,9 @@ describe("executeTddPipeline", () => {
       teams: { splitter: false, reviewer: false },
       memorySync: true,
       dashboard: { enabled: true, port: 7333, host: "localhost" },
+      git: { autoPush: false },
+      skipCompleted: true,
+      strictTdd: true,
     };
 
     const mockProvider: ClaudeProvider = {
@@ -687,6 +711,9 @@ describe("executeTddPipeline", () => {
       teams: { splitter: false, reviewer: false },
       memorySync: true,
       dashboard: { enabled: true, port: 7333, host: "localhost" },
+      git: { autoPush: false },
+      skipCompleted: true,
+      strictTdd: true,
     };
 
     const mockProvider: ClaudeProvider = {
@@ -738,6 +765,9 @@ describe("executeTddPipeline", () => {
       teams: { splitter: false, reviewer: false },
       memorySync: true,
       dashboard: { enabled: true, port: 7333, host: "localhost" },
+      git: { autoPush: false },
+      skipCompleted: true,
+      strictTdd: true,
     };
 
     const mockProvider: ClaudeProvider = {
@@ -757,4 +787,470 @@ describe("executeTddPipeline", () => {
     expect(result.status).toBe("failed");
     expect(result.error).toBe("Unknown error");
   });
+
+  test("emits warn log events when commit fails (invalid workspace)", async () => {
+    const task: Task = {
+      taskId: createTaskId("task-commit-warn"),
+      title: "Commit warning test",
+      description: "Test warn logs on commit failure",
+      filesToModify: [],
+      dependsOn: [],
+      priority: 1,
+      status: "running",
+      retryCount: 0,
+    };
+
+    // workspace.path が無効 → git add/commit は全て失敗する想定
+    const workspace: WorkspaceInfo = {
+      path: "/nonexistent-invalid-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, message: "Merged" };
+      },
+    } as unknown as MergeService;
+
+    const events: Array<{ type: string; entry?: { level?: string; message?: string } }> = [];
+    const mockEventBus = {
+      on() {},
+      off() {},
+      emit(event: any) {
+        events.push(event);
+      },
+    } as unknown as EventBus;
+
+    const mockSpawner = {
+      async spawn() {
+        return { exitCode: 0, stdout: "OK", stderr: "" };
+      },
+    };
+
+    await executeTddPipeline(
+      task, workspace, "branch", "main", "/parent", createRunId("run-cw"), config,
+      mockProvider, mockMergeService, mockEventBus, mockSpawner
+    );
+
+    const warnEvents = events.filter(
+      (e) => e.type === "log:entry" && e.entry?.level === "warn"
+    );
+
+    // Red/Green 両フェーズのコミット失敗 warn が発火
+    expect(warnEvents.length).toBeGreaterThanOrEqual(2);
+    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/__tests__/tester-verify.test.ts

@@ -200,16 +200,17 @@ describe("buildTestCommand", () => {
     expect(buildTestCommand(workspace)).toEqual(["./gradlew", "test"]);
   });
 
-  test("throws error for unknown test framework", () => {
+  test("returns fallback for unknown test framework", () => {
     const workspace: WorkspaceInfo = {
       path: "/path/to/workspace",
       language: "unknown",
-      packageManager: "unknown",
+      packageManager: "npm",
       framework: "unknown",
       testFramework: "unknown",
     };
 
-    expect(() => buildTestCommand(workspace)).toThrow("Unsupported test framework");
+    // After fallback implementation, unknown should return npm test
+    expect(buildTestCommand(workspace)).toEqual(["npm", "test"]);
   });
 });