@ronkovic/aad 0.5.1 → 0.6.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ronkovic/aad",
-  "version": "0.5.1",
+  "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/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