@ronkovic/aad 0.5.0 → 0.6.0

package/package.json

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

package/src/modules/claude-provider/__tests__/claude-sdk.adapter.test.ts

@@ -350,4 +350,79 @@ describe("ClaudeSdkAdapter", () => {
     expect(response.exitCode).toBe(0);
     expect(response.result).toBe("Final result");
   });
+
+  test("call() - ANTHROPIC_API_KEY が env に渡される", async () => {
+    const originalKey = process.env.ANTHROPIC_API_KEY;
+    process.env.ANTHROPIC_API_KEY = "sk-ant-test-key";
+    try {
+      await adapter.call({ prompt: "Test" });
+      const callArgs = mockQuery.mock.calls[0] as unknown as [
+        { prompt: string; options: { env?: Record<string, string> } }
+      ];
+      expect(callArgs[0]!.options.env?.ANTHROPIC_API_KEY).toBe("sk-ant-test-key");
+    } finally {
+      if (originalKey) process.env.ANTHROPIC_API_KEY = originalKey;
+      else delete process.env.ANTHROPIC_API_KEY;
+    }
+  });
+
+  test("call() - CLAUDE_CODE_OAUTH_TOKEN が env に渡される", async () => {
+    const originalToken = process.env.CLAUDE_CODE_OAUTH_TOKEN;
+    process.env.CLAUDE_CODE_OAUTH_TOKEN = "oauth-test-token";
+    try {
+      await adapter.call({ prompt: "Test" });
+      const callArgs = mockQuery.mock.calls[0] as unknown as [
+        { prompt: string; options: { env?: Record<string, string> } }
+      ];
+      expect(callArgs[0]!.options.env?.CLAUDE_CODE_OAUTH_TOKEN).toBe("oauth-test-token");
+    } finally {
+      if (originalToken) process.env.CLAUDE_CODE_OAUTH_TOKEN = originalToken;
+      else delete process.env.CLAUDE_CODE_OAUTH_TOKEN;
+    }
+  });
+
+  test("call() - タイムアウトで AbortError が発生する", async () => {
+    mockQuery.mockImplementationOnce(
+      (params: { prompt: string; options?: unknown }) => {
+        const abortController = (params.options as { abortController?: AbortController })?.abortController;
+        return (async function* () {
+          // AbortControllerのabortを監視
+          if (abortController) {
+            await new Promise((_, reject) => {
+              abortController.signal.addEventListener("abort", () => {
+                reject(new Error("The operation was aborted"));
+              });
+              // 長時間待機
+              setTimeout(() => {}, 5000);
+            });
+          }
+          yield { type: "result", subtype: "success", result: "late" } as MockSDKMessage;
+        })() as AsyncGenerator<MockSDKMessage, void, unknown>;
+      }
+    );
+
+    await expect(adapter.call({ prompt: "Test", timeout: 50 })).rejects.toThrow();
+  }, 10_000);
+
+  test("call() - effortLevel がレスポンスに反映される", async () => {
+    const response = await adapter.call({ prompt: "Test", effortLevel: "low" });
+    expect(response.effortLevel).toBe("low");
+  });
+
+  test("call() - model override がレスポンスに反映される", async () => {
+    mockQuery.mockReturnValueOnce(
+      (async function* () {
+        yield {
+          type: "assistant",
+          message: {
+            model: "claude-haiku-4-5-20251001",
+            content: [{ type: "text", text: "Response" }],
+          },
+        } as MockSDKMessage;
+        yield { type: "result", subtype: "success", result: "Response" } as MockSDKMessage;
+      })() as AsyncGenerator<MockSDKMessage, void, unknown>
+    );
+    const response = await adapter.call({ prompt: "Test", model: "claude-haiku-4-5-20251001" });
+    expect(response.model).toContain("haiku");
+  });
 });

package/src/modules/git-workspace/__tests__/.tmp-template-copy-test/npm-install-test/node_modules/aad/templates/CLAUDE.md

@@ -0,0 +1 @@
+NPM template

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

@@ -75,3 +75,22 @@ describe("buildInstallCommand", () => {
     });
   });
 });
+
+describe("resolveAvailableCommand", () => {
+  test("returns command if binary exists in PATH", async () => {
+    // Import the function
+    const { resolveAvailableCommand } = await import("../dependency-installer");
+
+    // bun should exist in PATH during tests
+    const result = await resolveAvailableCommand("bun");
+    expect(result).toBe("bun");
+  });
+
+  test("falls back to npx if binary does not exist in PATH", async () => {
+    const { resolveAvailableCommand } = await import("../dependency-installer");
+
+    // Use a non-existent binary name
+    const result = await resolveAvailableCommand("nonexistent-binary-xyz123");
+    expect(result).toBe("npx");
+  });
+});

package/src/modules/git-workspace/__tests__/template-copy.test.ts

@@ -186,4 +186,29 @@ describe("resolveTemplateDir", () => {
     expect(result).toContain("templates");
     expect(result).not.toContain("sandbox/templates");
   });
+
+  test("checks multiple fallback paths for npm distribution", async () => {
+    // Create test directory structure mimicking npm installation
+    const npmTestDir = join(testDir, "npm-install-test");
+    const fakeProjectRoot = join(npmTestDir, "user-project");
+    const packageRoot = join(npmTestDir, "node_modules", "aad");
+    const npmTemplateDir = join(packageRoot, "templates");
+
+    await mkdir(fakeProjectRoot, { recursive: true });
+    await mkdir(npmTemplateDir, { recursive: true });
+    await writeFile(join(npmTemplateDir, "CLAUDE.md"), "NPM template");
+
+    // Verify the actual project has templates/ at the root for npm distribution
+    // src/modules/git-workspace/__tests__/ -> ../../../../templates
+    const { existsSync } = await import("node:fs");
+    const actualProjectRoot = join(import.meta.dir, "..", "..", "..", "..");
+    const actualNpmTemplate = join(actualProjectRoot, "templates");
+
+    expect(existsSync(actualNpmTemplate)).toBe(true);
+
+    // Verify resolveTemplateDir returns templates/ when .aad/templates doesn't exist
+    const result = resolveTemplateDir(fakeProjectRoot);
+    // Should fallback to package templates/ since no local override exists
+    expect(result).toContain("templates");
+  });
 });

package/src/modules/git-workspace/__tests__/worktree-manager.test.ts

@@ -109,6 +109,89 @@ describe("WorktreeManager", () => {
         worktreeManager.createParentWorktree(runId, parentBranch)
       ).rejects.toThrow(GitWorkspaceError);
     });
+
+    test("cleans up stale parent worktree before creating new one", async () => {
+      const runId = createRunId("run-003");
+      const parentBranch = "main";
+      const featureBranch = "feat/run-003/parent";
+      const calls: string[][] = [];
+
+      mockGitOps.gitExec = mock(async (args: string[]) => {
+        calls.push(args);
+        return { stdout: "", stderr: "", exitCode: 0 };
+      });
+
+      await worktreeManager.createParentWorktree(runId, parentBranch, featureBranch);
+
+      // Should call worktree remove before worktree add
+      const removeIdx = calls.findIndex(c => c[0] === "worktree" && c[1] === "remove");
+      const addIdx = calls.findIndex(c => c[0] === "worktree" && c[1] === "add");
+      expect(removeIdx).toBeGreaterThanOrEqual(0);
+      expect(addIdx).toBeGreaterThan(removeIdx);
+      expect(calls[removeIdx]).toEqual(["worktree", "remove", "/test/worktrees/parent-run-003", "--force"]);
+    });
+
+    test("deletes stale parent branch before creating new one", async () => {
+      const runId = createRunId("run-004");
+      const parentBranch = "main";
+      const featureBranch = "feat/run-004/parent";
+      const calls: string[][] = [];
+
+      mockGitOps.gitExec = mock(async (args: string[]) => {
+        calls.push(args);
+        return { stdout: "", stderr: "", exitCode: 0 };
+      });
+
+      await worktreeManager.createParentWorktree(runId, parentBranch, featureBranch);
+
+      const branchDeleteCall = calls.find(c => c[0] === "branch" && c[1] === "-D");
+      expect(branchDeleteCall).toBeDefined();
+      expect(branchDeleteCall![2]).toBe(featureBranch);
+
+      // Branch delete should happen before worktree add
+      const branchIdx = calls.indexOf(branchDeleteCall!);
+      const addIdx = calls.findIndex(c => c[0] === "worktree" && c[1] === "add");
+      expect(branchIdx).toBeLessThan(addIdx);
+    });
+
+    test("handles gracefully when no stale parent worktree exists", async () => {
+      const runId = createRunId("run-005");
+      const parentBranch = "main";
+      const featureBranch = "feat/run-005/parent";
+
+      // Simulate: worktree remove fails, rm succeeds, prune succeeds, branch -D fails, add succeeds
+      mockGitOps.gitExec = mock(async (args: string[]) => {
+        if (args[1] === "remove") throw new Error("not a worktree");
+        if (args[0] === "branch" && args[1] === "-D") throw new Error("branch not found");
+        return { stdout: "", stderr: "", exitCode: 0 };
+      });
+
+      // Should not throw — cleanup errors are swallowed
+      const result = await worktreeManager.createParentWorktree(runId, parentBranch, featureBranch);
+      expect(result.worktreePath).toBe("/test/worktrees/parent-run-005");
+      expect(result.branch).toBe(featureBranch);
+    });
+
+    test("calls git worktree prune during parent cleanup", async () => {
+      const runId = createRunId("run-006");
+      const parentBranch = "main";
+      const calls: string[][] = [];
+
+      mockGitOps.gitExec = mock(async (args: string[]) => {
+        calls.push(args);
+        return { stdout: "", stderr: "", exitCode: 0 };
+      });
+
+      await worktreeManager.createParentWorktree(runId, parentBranch);
+
+      const pruneCall = calls.find(c => c[0] === "worktree" && c[1] === "prune");
+      expect(pruneCall).toBeDefined();
+
+      // Prune should happen before worktree add
+      const pruneIdx = calls.indexOf(pruneCall!);
+      const addIdx = calls.findIndex(c => c[0] === "worktree" && c[1] === "add");
+      expect(pruneIdx).toBeLessThan(addIdx);
+    });
   });
 
   describe("removeWorktree", () => {

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

@@ -5,6 +5,10 @@
 
 import type { WorkspaceInfo } from "../../shared/types";
 import type { Logger } from "pino";
+import { resolveAvailableCommand } from "../../shared/utils";
+
+// Re-export for external use
+export { resolveAvailableCommand };
 
 export interface InstallResult {
   success: boolean;

package/src/modules/git-workspace/template-copy.ts

@@ -16,7 +16,8 @@ const PROJECT_CONTEXT_HEADER = "# プロジェクト固有コンテキスト\n\n
 /**
  * Resolve template directory path:
  * 1. Project local override: {projectRoot}/.aad/templates/ (if exists)
- * 2. Package bundled: {packageRoot}/templates/
+ * 2. Package bundled (dev): {packageRoot}/.aad/templates/ (if exists)
+ * 3. Package bundled (npm): {packageRoot}/templates/ (for npm distribution)
  */
 export function resolveTemplateDir(projectRoot: string): string {
   const localTemplateDir = join(projectRoot, ".aad", "templates");
@@ -27,9 +28,17 @@ export function resolveTemplateDir(projectRoot: string): string {
   }
 
   // Fallback to package bundled templates
-  // src/modules/git-workspace/ -> ../../../.aad/templates
+  // src/modules/git-workspace/ -> ../../../
   const packageRoot = join(import.meta.dir, "..", "..", "..");
-  return join(packageRoot, ".aad", "templates");
+
+  // Try .aad/templates first (dev environment)
+  const devTemplateDir = join(packageRoot, ".aad", "templates");
+  if (existsSync(devTemplateDir)) {
+    return devTemplateDir;
+  }
+
+  // Fallback to templates/ (npm distribution)
+  return join(packageRoot, "templates");
 }
 
 /**

package/src/modules/git-workspace/worktree-manager.ts

@@ -127,6 +127,9 @@ export class WorktreeManager {
     try {
       await this.fsOps.mkdir(this.worktreeBase, { recursive: true });
 
+      // Clean up stale worktree/branch from previous runs
+      await this.cleanupStaleWorktree(worktreePath, branch);
+
       // Create worktree with a new branch based on parentBranch
       // e.g. git worktree add -b feat/auth-feature/parent <path> main
       await this.gitOps.gitExec(

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

@@ -212,6 +212,53 @@ describe("buildTestCommand", () => {
     // After fallback implementation, unknown should return npm test
     expect(buildTestCommand(workspace)).toEqual(["npm", "test"]);
   });
+
+  test("builds vitest with fallback when yarn is unavailable", async () => {
+    const workspace: WorkspaceInfo = {
+      path: "/path",
+      language: "typescript",
+      packageManager: "yarn",
+      framework: "vite",
+      testFramework: "vitest",
+    };
+
+    // Mock Bun.which to simulate yarn not available
+    const originalWhich = Bun.which;
+    Bun.which = (cmd: string) => {
+      if (cmd === "yarn") return null;
+      return originalWhich(cmd);
+    };
+
+    try {
+      const result = await (await import("../phases/tester-verify")).buildTestCommandWithFallback(workspace);
+      expect(result).toEqual(["npx", "yarn", "test"]);
+    } finally {
+      Bun.which = originalWhich;
+    }
+  });
+
+  test("builds jest with fallback when pnpm is unavailable", async () => {
+    const workspace: WorkspaceInfo = {
+      path: "/path",
+      language: "javascript",
+      packageManager: "pnpm",
+      framework: "react",
+      testFramework: "jest",
+    };
+
+    const originalWhich = Bun.which;
+    Bun.which = (cmd: string) => {
+      if (cmd === "pnpm") return null;
+      return originalWhich(cmd);
+    };
+
+    try {
+      const result = await (await import("../phases/tester-verify")).buildTestCommandWithFallback(workspace);
+      expect(result).toEqual(["npx", "pnpm", "test"]);
+    } finally {
+      Bun.which = originalWhich;
+    }
+  });
 });
 
 describe("runTests", () => {

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

@@ -1,5 +1,6 @@
 import type { WorkspaceInfo } from "@aad/shared/types";
 import { TestRunnerError } from "@aad/shared/errors";
+import { resolveAvailableCommand } from "@aad/shared/utils";
 
 export interface ProcessResult {
   exitCode: number;
@@ -21,6 +22,95 @@ export interface TestResult {
   error?: string;
 }
 
+/**
+ * Build test command with fallback support for unavailable package managers
+ */
+export async function buildTestCommandWithFallback(workspace: WorkspaceInfo): Promise<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") {
+        const cmd = await resolveAvailableCommand("yarn");
+        return cmd === "npx" ? ["npx", "yarn", "test"] : ["yarn", "test"];
+      }
+      if (packageManager === "pnpm") {
+        const cmd = await resolveAvailableCommand("pnpm");
+        return cmd === "npx" ? ["npx", "pnpm", "test"] : ["pnpm", "test"];
+      }
+      return ["npx", "vitest", "run"];
+    }
+
+    case "jest": {
+      if (packageManager === "npm") return ["npm", "test"];
+      if (packageManager === "yarn") {
+        const cmd = await resolveAvailableCommand("yarn");
+        return cmd === "npx" ? ["npx", "yarn", "test"] : ["yarn", "test"];
+      }
+      if (packageManager === "pnpm") {
+        const cmd = await resolveAvailableCommand("pnpm");
+        return cmd === "npx" ? ["npx", "pnpm", "test"] : ["pnpm", "test"];
+      }
+      return ["npx", "jest"];
+    }
+
+    case "mocha": {
+      if (packageManager === "npm") return ["npm", "test"];
+      if (packageManager === "yarn") {
+        const cmd = await resolveAvailableCommand("yarn");
+        return cmd === "npx" ? ["npx", "yarn", "test"] : ["yarn", "test"];
+      }
+      return ["npx", "mocha"];
+    }
+
+    case "pytest": {
+      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": {
+      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 }
+      );
+    }
+  }
+}
+
 /**
  * Build test command based on detected test framework
  */

package/src/shared/__tests__/utils.test.ts

@@ -1,5 +1,5 @@
 import { describe, test, expect } from "bun:test";
-import { capitalize, toLowerCase, trim, reverse, toUpperCase } from "../utils";
+import { capitalize, toLowerCase, trim, reverse, toUpperCase, resolveAvailableCommand } from "../utils";
 
 describe("capitalize", () => {
   test.each([
@@ -292,3 +292,23 @@ describe("toUpperCase", () => {
     expect(toUpperCase(input)).toBe(expected);
   });
 });
+
+describe("resolveAvailableCommand", () => {
+  test("returns command if binary exists in PATH", async () => {
+    // bun should exist in PATH during tests
+    const result = await resolveAvailableCommand("bun");
+    expect(result).toBe("bun");
+  });
+
+  test("falls back to npx if binary does not exist in PATH", async () => {
+    // Use a non-existent binary name
+    const result = await resolveAvailableCommand("nonexistent-binary-xyz123");
+    expect(result).toBe("npx");
+  });
+
+  test("handles common package managers", async () => {
+    // npm should always be available if bun is available
+    const npmResult = await resolveAvailableCommand("npm");
+    expect(npmResult).toBe("npm");
+  });
+});

package/src/shared/utils.ts

@@ -1,5 +1,16 @@
 // Utility functions for shared functionality
 
+/**
+ * コマンドのバイナリが $PATH に存在するか確認し、
+ * 存在しない場合は npx にフォールバックする
+ * @param command - The command to check
+ * @returns The command if available, otherwise "npx"
+ */
+export async function resolveAvailableCommand(command: string): Promise<string> {
+  const available = await Bun.which(command);
+  return available ? command : "npx";
+}
+
 /**
  * Capitalizes the first character of a string.
  * @param str - The string to capitalize

package/src/modules/claude-provider/__tests__/claude-sdk-real-env.test.ts

@@ -1,127 +0,0 @@
-import { describe, test, expect } from "bun:test";
-import { ClaudeSdkAdapter } from "../claude-sdk.adapter";
-import { loadConfig } from "../../../shared/config";
-import pino from "pino";
-import { ClaudeProviderError } from "../../../shared/errors";
-
-/**
- * 実環境バリデーションテスト
- * ANTHROPIC_API_KEY または CLAUDE_CODE_OAUTH_TOKEN が設定されている場合のみ実行
- */
-
-const hasApiKey = !!process.env.ANTHROPIC_API_KEY;
-const hasOAuth = !!process.env.CLAUDE_CODE_OAUTH_TOKEN;
-const hasAuth = hasApiKey || hasOAuth;
-
-const logger = pino({ level: "silent" });
-
-function createAdapter() {
-  const config = loadConfig();
-  return new ClaudeSdkAdapter(config, logger);
-}
-
-describe.skipIf(!hasAuth)("ClaudeSdkAdapter - Real Environment", () => {
-  test("simple query returns valid response", async () => {
-    const adapter = createAdapter();
-    const response = await adapter.call({
-      prompt: "Reply with exactly: PING",
-    });
-
-    expect(response.result).toBeDefined();
-    expect(response.result.length).toBeGreaterThan(0);
-    expect(response.exitCode).toBe(0);
-    expect(response.model).toBeDefined();
-    expect(response.duration).toBeGreaterThan(0);
-  }, 30_000);
-
-  test("detects authentication method", () => {
-    if (hasApiKey) {
-      expect(process.env.ANTHROPIC_API_KEY).toBeDefined();
-      console.log("Auth: ANTHROPIC_API_KEY");
-    }
-    if (hasOAuth) {
-      expect(process.env.CLAUDE_CODE_OAUTH_TOKEN).toBeDefined();
-      console.log("Auth: CLAUDE_CODE_OAUTH_TOKEN");
-    }
-  });
-
-  test("throws ClaudeProviderError on invalid auth", async () => {
-    const originalKey = process.env.ANTHROPIC_API_KEY;
-    const originalOAuth = process.env.CLAUDE_CODE_OAUTH_TOKEN;
-
-    try {
-      // 無効な認証情報に差し替え
-      process.env.ANTHROPIC_API_KEY = "sk-ant-invalid-key-for-testing";
-      delete process.env.CLAUDE_CODE_OAUTH_TOKEN;
-
-      const adapter = createAdapter();
-      await expect(
-        adapter.call({ prompt: "test" })
-      ).rejects.toThrow(ClaudeProviderError);
-    } finally {
-      // 復元
-      if (originalKey) process.env.ANTHROPIC_API_KEY = originalKey;
-      else delete process.env.ANTHROPIC_API_KEY;
-      if (originalOAuth) process.env.CLAUDE_CODE_OAUTH_TOKEN = originalOAuth;
-      else delete process.env.CLAUDE_CODE_OAUTH_TOKEN;
-    }
-  }, 15_000);
-
-  test("respects timeout/abort", async () => {
-    const adapter = createAdapter();
-
-    await expect(
-      adapter.call({
-        prompt: "Write a very long essay about the history of computing.",
-        timeout: 100, // 100ms — 即タイムアウト
-      })
-    ).rejects.toThrow();
-  }, 10_000);
-
-  test("passes effort level correctly", async () => {
-    const adapter = createAdapter();
-    const response = await adapter.call({
-      prompt: "Reply with exactly: OK",
-      effortLevel: "low",
-    });
-
-    expect(response.result).toBeDefined();
-    expect(response.exitCode).toBe(0);
-    expect(response.effortLevel).toBe("low");
-  }, 30_000);
-
-  test("respects model override", async () => {
-    const adapter = createAdapter();
-    const response = await adapter.call({
-      prompt: "Reply with exactly: HI",
-      model: "claude-haiku-4-5-20251001",
-    });
-
-    expect(response.result).toBeDefined();
-    expect(response.exitCode).toBe(0);
-    // model名はSDKが返す値に依存するが、haiku系であることを確認
-    expect(response.model).toContain("haiku");
-  }, 30_000);
-});
-
-describe.skipIf(!hasOAuth)("ClaudeSdkAdapter - OAuth Authentication", () => {
-  test("authenticates with CLAUDE_CODE_OAUTH_TOKEN", async () => {
-    const originalKey = process.env.ANTHROPIC_API_KEY;
-
-    try {
-      // API Keyを一時的に除外してOAuthのみで認証
-      delete process.env.ANTHROPIC_API_KEY;
-
-      const adapter = createAdapter();
-      const response = await adapter.call({
-        prompt: "Reply with exactly: OAUTH_OK",
-      });
-
-      expect(response.result).toBeDefined();
-      expect(response.exitCode).toBe(0);
-    } finally {
-      if (originalKey) process.env.ANTHROPIC_API_KEY = originalKey;
-      else delete process.env.ANTHROPIC_API_KEY;
-    }
-  }, 30_000);
-});