@ronkovic/aad 0.6.0 → 0.6.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ronkovic/aad",
-  "version": "0.6.0",
+  "version": "0.6.1",
   "description": "Autonomous Agent Development Orchestrator - Multi-agent TDD pipeline powered by Claude",
   "module": "src/main.ts",
   "type": "module",

package/src/modules/git-workspace/__tests__/dependency-installer.test.ts

@@ -94,3 +94,25 @@ describe("resolveAvailableCommand", () => {
     expect(result).toBe("npx");
   });
 });
+
+describe("installDependencies integration", () => {
+  test("integrates with resolveAvailableCommand", async () => {
+    // This test verifies that installDependencies calls resolveAvailableCommand
+    // Actual fallback behavior is tested in resolveAvailableCommand tests above
+    const { buildInstallCommand } = await import("../dependency-installer");
+
+    const workspace: WorkspaceInfo = {
+      path: "/tmp/test",
+      language: "javascript",
+      packageManager: "yarn",
+      framework: "react",
+      testFramework: "jest",
+    };
+
+    const command = buildInstallCommand(workspace);
+    expect(command).toEqual(["yarn", "install", "--frozen-lockfile"]);
+
+    // The actual fallback is applied at runtime in installDependencies
+    // when yarn is not available in PATH, resolveAvailableCommand returns "npx"
+  });
+});

package/src/modules/git-workspace/dependency-installer.ts

@@ -76,11 +76,14 @@ export async function installDependencies(
     return { success: true, output: "", duration: 0, skipped: true };
   }
 
-  const [cmd, ...args] = command;
+  const [rawCmd, ...args] = command;
+
+  // Resolve command with fallback (e.g., yarn → npx if yarn not found)
+  const cmd = await resolveAvailableCommand(rawCmd!);
   logger.info({ cmd, args, cwd: workspace.path }, "Installing dependencies");
 
   // Bun.spawn で実行（default-spawner.ts と同パターン）
-  const proc = Bun.spawn([cmd!, ...args], {
+  const proc = Bun.spawn([cmd, ...args], {
     cwd: workspace.path,
     stdout: "pipe",
     stderr: "pipe",

package/src/modules/task-execution/__tests__/tester-verify.test.ts

@@ -1,13 +1,13 @@
 import { describe, test, expect } from "bun:test";
 import {
-  buildTestCommand,
+  buildTestCommandWithFallback,
   runTests,
   type ProcessSpawner,
 } from "../phases/tester-verify";
 import type { WorkspaceInfo } from "@aad/shared/types";
 
-describe("buildTestCommand", () => {
-  test("builds bun test command", () => {
+describe("buildTestCommandWithFallback", () => {
+  test("builds bun test command", async () => {
     const workspace: WorkspaceInfo = {
       path: "/path/to/workspace",
       language: "typescript",
@@ -16,10 +16,10 @@ describe("buildTestCommand", () => {
       testFramework: "bun-test",
     };
 
-    expect(buildTestCommand(workspace)).toEqual(["bun", "test"]);
+    expect(await buildTestCommandWithFallback(workspace)).toEqual(["bun", "test"]);
   });
 
-  test("builds vitest command", () => {
+  test("builds vitest command", async () => {
     const workspace: WorkspaceInfo = {
       path: "/path/to/workspace",
       language: "typescript",
@@ -28,10 +28,10 @@ describe("buildTestCommand", () => {
       testFramework: "vitest",
     };
 
-    expect(buildTestCommand(workspace)).toEqual(["npm", "run", "test"]);
+    expect(await buildTestCommandWithFallback(workspace)).toEqual(["npm", "run", "test"]);
   });
 
-  test("builds jest command", () => {
+  test("builds jest command", async () => {
     const workspace: WorkspaceInfo = {
       path: "/path/to/workspace",
       language: "javascript",
@@ -40,10 +40,10 @@ describe("buildTestCommand", () => {
       testFramework: "jest",
     };
 
-    expect(buildTestCommand(workspace)).toEqual(["yarn", "test"]);
+    expect(await buildTestCommandWithFallback(workspace)).toEqual(["yarn", "test"]);
   });
 
-  test("builds pytest command", () => {
+  test("builds pytest command", async () => {
     const workspace: WorkspaceInfo = {
       path: "/path/to/workspace",
       language: "python",
@@ -52,10 +52,10 @@ describe("buildTestCommand", () => {
       testFramework: "pytest",
     };
 
-    expect(buildTestCommand(workspace)).toEqual(["pytest", "-v"]);
+    expect(await buildTestCommandWithFallback(workspace)).toEqual(["pytest", "-v"]);
   });
 
-  test("builds go test command", () => {
+  test("builds go test command", async () => {
     const workspace: WorkspaceInfo = {
       path: "/path/to/workspace",
       language: "go",
@@ -64,10 +64,10 @@ describe("buildTestCommand", () => {
       testFramework: "go-test",
     };
 
-    expect(buildTestCommand(workspace)).toEqual(["go", "test", "./..."]);
+    expect(await buildTestCommandWithFallback(workspace)).toEqual(["go", "test", "./..."]);
   });
 
-  test("builds cargo test command", () => {
+  test("builds cargo test command", async () => {
     const workspace: WorkspaceInfo = {
       path: "/path/to/workspace",
       language: "rust",
@@ -76,10 +76,10 @@ describe("buildTestCommand", () => {
       testFramework: "cargo",
     };
 
-    expect(buildTestCommand(workspace)).toEqual(["cargo", "test"]);
+    expect(await buildTestCommandWithFallback(workspace)).toEqual(["cargo", "test"]);
   });
 
-  test("builds vitest command with yarn", () => {
+  test("builds vitest command with yarn", async () => {
     const workspace: WorkspaceInfo = {
       path: "/path",
       language: "typescript",
@@ -87,10 +87,10 @@ describe("buildTestCommand", () => {
       framework: "vite",
       testFramework: "vitest",
     };
-    expect(buildTestCommand(workspace)).toEqual(["yarn", "test"]);
+    expect(await buildTestCommandWithFallback(workspace)).toEqual(["yarn", "test"]);
   });
 
-  test("builds vitest command with pnpm", () => {
+  test("builds vitest command with pnpm", async () => {
     const workspace: WorkspaceInfo = {
       path: "/path",
       language: "typescript",
@@ -98,10 +98,10 @@ describe("buildTestCommand", () => {
       framework: "vite",
       testFramework: "vitest",
     };
-    expect(buildTestCommand(workspace)).toEqual(["pnpm", "test"]);
+    expect(await buildTestCommandWithFallback(workspace)).toEqual(["pnpm", "test"]);
   });
 
-  test("builds vitest command with default (npx)", () => {
+  test("builds vitest command with default (npx)", async () => {
     const workspace: WorkspaceInfo = {
       path: "/path",
       language: "typescript",
@@ -109,10 +109,10 @@ describe("buildTestCommand", () => {
       framework: "vite",
       testFramework: "vitest",
     };
-    expect(buildTestCommand(workspace)).toEqual(["npx", "vitest", "run"]);
+    expect(await buildTestCommandWithFallback(workspace)).toEqual(["npx", "vitest", "run"]);
   });
 
-  test("builds jest command with npm", () => {
+  test("builds jest command with npm", async () => {
     const workspace: WorkspaceInfo = {
       path: "/path",
       language: "javascript",
@@ -120,10 +120,10 @@ describe("buildTestCommand", () => {
       framework: "react",
       testFramework: "jest",
     };
-    expect(buildTestCommand(workspace)).toEqual(["npm", "test"]);
+    expect(await buildTestCommandWithFallback(workspace)).toEqual(["npm", "test"]);
   });
 
-  test("builds jest command with pnpm", () => {
+  test("builds jest command with pnpm", async () => {
     const workspace: WorkspaceInfo = {
       path: "/path",
       language: "javascript",
@@ -131,10 +131,10 @@ describe("buildTestCommand", () => {
       framework: "react",
       testFramework: "jest",
     };
-    expect(buildTestCommand(workspace)).toEqual(["pnpm", "test"]);
+    expect(await buildTestCommandWithFallback(workspace)).toEqual(["pnpm", "test"]);
   });
 
-  test("builds jest command with default (npx)", () => {
+  test("builds jest command with default (npx)", async () => {
     const workspace: WorkspaceInfo = {
       path: "/path",
       language: "javascript",
@@ -142,10 +142,10 @@ describe("buildTestCommand", () => {
       framework: "react",
       testFramework: "jest",
     };
-    expect(buildTestCommand(workspace)).toEqual(["npx", "jest"]);
+    expect(await buildTestCommandWithFallback(workspace)).toEqual(["npx", "jest"]);
   });
 
-  test("builds mocha command with npm", () => {
+  test("builds mocha command with npm", async () => {
     const workspace: WorkspaceInfo = {
       path: "/path",
       language: "javascript",
@@ -153,10 +153,10 @@ describe("buildTestCommand", () => {
       framework: "express",
       testFramework: "mocha",
     };
-    expect(buildTestCommand(workspace)).toEqual(["npm", "test"]);
+    expect(await buildTestCommandWithFallback(workspace)).toEqual(["npm", "test"]);
   });
 
-  test("builds mocha command with yarn", () => {
+  test("builds mocha command with yarn", async () => {
     const workspace: WorkspaceInfo = {
       path: "/path",
       language: "javascript",
@@ -164,10 +164,10 @@ describe("buildTestCommand", () => {
       framework: "express",
       testFramework: "mocha",
     };
-    expect(buildTestCommand(workspace)).toEqual(["yarn", "test"]);
+    expect(await buildTestCommandWithFallback(workspace)).toEqual(["yarn", "test"]);
   });
 
-  test("builds mocha command with default (npx)", () => {
+  test("builds mocha command with default (npx)", async () => {
     const workspace: WorkspaceInfo = {
       path: "/path",
       language: "javascript",
@@ -175,10 +175,10 @@ describe("buildTestCommand", () => {
       framework: "express",
       testFramework: "mocha",
     };
-    expect(buildTestCommand(workspace)).toEqual(["npx", "mocha"]);
+    expect(await buildTestCommandWithFallback(workspace)).toEqual(["npx", "mocha"]);
   });
 
-  test("builds maven test command", () => {
+  test("builds maven test command", async () => {
     const workspace: WorkspaceInfo = {
       path: "/path",
       language: "java",
@@ -186,10 +186,10 @@ describe("buildTestCommand", () => {
       framework: "spring",
       testFramework: "maven",
     };
-    expect(buildTestCommand(workspace)).toEqual(["mvn", "test"]);
+    expect(await buildTestCommandWithFallback(workspace)).toEqual(["mvn", "test"]);
   });
 
-  test("builds gradle test command", () => {
+  test("builds gradle test command", async () => {
     const workspace: WorkspaceInfo = {
       path: "/path",
       language: "java",
@@ -197,10 +197,10 @@ describe("buildTestCommand", () => {
       framework: "spring",
       testFramework: "gradle",
     };
-    expect(buildTestCommand(workspace)).toEqual(["./gradlew", "test"]);
+    expect(await buildTestCommandWithFallback(workspace)).toEqual(["./gradlew", "test"]);
   });
 
-  test("returns fallback for unknown test framework", () => {
+  test("returns fallback for unknown test framework", async () => {
     const workspace: WorkspaceInfo = {
       path: "/path/to/workspace",
       language: "unknown",
@@ -210,7 +210,7 @@ describe("buildTestCommand", () => {
     };
 
     // After fallback implementation, unknown should return npm test
-    expect(buildTestCommand(workspace)).toEqual(["npm", "test"]);
+    expect(await buildTestCommandWithFallback(workspace)).toEqual(["npm", "test"]);
   });
 
   test("builds vitest with fallback when yarn is unavailable", async () => {
@@ -230,7 +230,7 @@ describe("buildTestCommand", () => {
     };
 
     try {
-      const result = await (await import("../phases/tester-verify")).buildTestCommandWithFallback(workspace);
+      const result = await buildTestCommandWithFallback(workspace);
       expect(result).toEqual(["npx", "yarn", "test"]);
     } finally {
       Bun.which = originalWhich;
@@ -253,7 +253,7 @@ describe("buildTestCommand", () => {
     };
 
     try {
-      const result = await (await import("../phases/tester-verify")).buildTestCommandWithFallback(workspace);
+      const result = await buildTestCommandWithFallback(workspace);
       expect(result).toEqual(["npx", "pnpm", "test"]);
     } finally {
       Bun.which = originalWhich;

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

@@ -14,7 +14,7 @@ export {
 } from "./phases/implementer-green";
 export type { ImplementerGreenOptions } from "./phases/implementer-green";
 
-export { runTests, buildTestCommand } from "./phases/tester-verify";
+export { runTests, buildTestCommandWithFallback } from "./phases/tester-verify";
 export type {
   TestResult,
   ProcessSpawner,

package/src/modules/task-execution/phases/tester-verify.ts

@@ -111,79 +111,6 @@ export async function buildTestCommandWithFallback(workspace: WorkspaceInfo): Pr
   }
 }
 
-/**
- * Build test command based on detected test framework
- */
-export function buildTestCommand(workspace: WorkspaceInfo): string[] {
-  const { testFramework, packageManager } = workspace;
-
-  switch (testFramework) {
-    case "bun-test":
-      return ["bun", "test"];
-
-    case "vitest":
-      if (packageManager === "npm") return ["npm", "run", "test"];
-      if (packageManager === "yarn") return ["yarn", "test"];
-      if (packageManager === "pnpm") return ["pnpm", "test"];
-      return ["npx", "vitest", "run"];
-
-    case "jest":
-      if (packageManager === "npm") return ["npm", "test"];
-      if (packageManager === "yarn") return ["yarn", "test"];
-      if (packageManager === "pnpm") return ["pnpm", "test"];
-      return ["npx", "jest"];
-
-    case "mocha":
-      if (packageManager === "npm") return ["npm", "test"];
-      if (packageManager === "yarn") return ["yarn", "test"];
-      return ["npx", "mocha"];
-
-    case "pytest": {
-      const { packageManager } = workspace;
-      if (packageManager === "uv") return ["uv", "run", "pytest", "-v"];
-      if (packageManager === "poetry") return ["poetry", "run", "pytest", "-v"];
-      return ["pytest", "-v"];
-    }
-
-    case "go-test":
-      return ["go", "test", "./..."];
-
-    case "cargo":
-      return ["cargo", "test"];
-
-    case "maven":
-      return ["mvn", "test"];
-
-    case "gradle":
-      return ["./gradlew", "test"];
-
-    case "playwright":
-      return ["npx", "playwright", "test"];
-
-    case "terraform":
-      return ["terraform", "validate"];
-
-    case "unknown": {
-      // Fallback: use package manager-based test command
-      const { packageManager } = workspace;
-      if (packageManager === "bun") return ["bun", "test"];
-      if (packageManager === "npm") return ["npm", "test"];
-      if (packageManager === "yarn") return ["yarn", "test"];
-      if (packageManager === "pnpm") return ["pnpm", "test"];
-      if (packageManager === "uv") return ["uv", "run", "pytest", "-v"];
-      if (packageManager === "poetry") return ["poetry", "run", "pytest", "-v"];
-      return ["npm", "test"];
-    }
-
-    default: {
-      const exhaustive: never = testFramework;
-      throw new TestRunnerError(
-        `Unsupported test framework: ${exhaustive}`,
-        { testFramework }
-      );
-    }
-  }
-}
 
 /**
  * Run tests in workspace and return result
@@ -196,7 +123,7 @@ export async function runTests(
   spawner?: ProcessSpawner,
   timeout = 300000
 ): Promise<TestResult> {
-  const command = buildTestCommand(workspace);
+  const command = await buildTestCommandWithFallback(workspace);
   const [cmd, ...args] = command;
 
   if (!cmd) {