@ronkovic/aad 0.3.5 → 0.3.7

package/src/modules/cli/commands/interactive/prompts.ts

@@ -0,0 +1,75 @@
+/**
+ * Interactive UI utility wrappers around @inquirer/prompts
+ */
+import { confirm, input, select, password } from "@inquirer/prompts";
+
+export interface Choice<T> {
+  name: string;
+  value: T;
+  description?: string;
+}
+
+export async function askConfirm(
+  message: string,
+  defaultValue = true,
+): Promise<boolean> {
+  return confirm({ message, default: defaultValue });
+}
+
+export async function askInput(
+  message: string,
+  opts?: { default?: string; validate?: (v: string) => string | true },
+): Promise<string> {
+  return input({
+    message,
+    default: opts?.default,
+    validate: opts?.validate,
+  });
+}
+
+export async function askSelect<T>(
+  message: string,
+  choices: Array<Choice<T>>,
+): Promise<T> {
+  return select({ message, choices });
+}
+
+export async function askPassword(message: string): Promise<string> {
+  return password({ message, mask: "•" });
+}
+
+export function printBox(lines: string[], title?: string): void {
+  const maxLen = Math.max(
+    title?.length ?? 0,
+    ...lines.map((l) => stripAnsi(l).length),
+  );
+  const width = maxLen + 2;
+  const border = "─".repeat(width);
+
+  console.log(`┌${border}┐`);
+  if (title) {
+    console.log(`│ ${title.padEnd(width - 1)}│`);
+    console.log(`├${border}┤`);
+  }
+  for (const line of lines) {
+    const pad = width - 1 - stripAnsi(line).length;
+    console.log(`│ ${line}${" ".repeat(Math.max(0, pad))}│`);
+  }
+  console.log(`└${border}┘`);
+}
+
+function stripAnsi(str: string): string {
+  return str.replace(/\x1b\[[0-9;]*m/g, "");
+}
+
+export function success(msg: string): void {
+  console.log(`  \x1b[32m✓\x1b[0m ${msg}`);
+}
+
+export function warn(msg: string): void {
+  console.log(`  \x1b[33m⚠\x1b[0m ${msg}`);
+}
+
+export function error(msg: string): void {
+  console.log(`  \x1b[31m✗\x1b[0m ${msg}`);
+}

package/src/modules/cli/commands/interactive.ts

@@ -0,0 +1,38 @@
+/**
+ * Interactive mode — main entry point
+ * Launched when `aad` is run with no arguments
+ */
+import type { Command } from "commander";
+import { runAuthStep } from "./interactive/auth-step.js";
+import { runProjectStep } from "./interactive/project-step.js";
+import { runLaunchStep } from "./interactive/launch-step.js";
+
+export function registerInteractiveCommand(program: Command): void {
+  program
+    .command("interactive")
+    .description("Interactive setup wizard for multi-project AAD execution")
+    .action(async () => {
+      console.log();
+      console.log("  ┌─────────────────────────────────────┐");
+      console.log("  │  AAD Interactive Mode                │");
+      console.log("  └─────────────────────────────────────┘");
+      console.log();
+
+      // Phase 1: Auth
+      console.log("  ── Step 1: 認証設定 ──\n");
+      await runAuthStep();
+
+      // Phase 2: Project setup
+      console.log("\n  ── Step 2: プロジェクト設定 ──");
+      const projects = await runProjectStep();
+
+      if (projects.length === 0) {
+        console.log("\n  プロジェクトが設定されていません。終了します。\n");
+        return;
+      }
+
+      // Phase 3: Launch
+      console.log("\n  ── Step 3: 実行 ──\n");
+      await runLaunchStep(projects);
+    });
+}

package/src/modules/cli/commands/resume.ts

@@ -125,11 +125,27 @@ export async function resumeRun(app: App, runIdStr: string): Promise<void> {
   // Check if parent worktree exists from a previous run
   const parentWorktreePath = `${process.cwd()}/.aad/worktrees/parent-${runId}`;
   const parentWorktreeExists = await Bun.file(`${parentWorktreePath}/.git`).exists();
+  // Detect feature branch name from parent worktree
+  let featureBranchName: string | undefined;
+  if (parentWorktreeExists) {
+    try {
+      const branchResult = await import("../../git-workspace").then(
+        (m) => m.getCurrentBranch(parentWorktreePath),
+      );
+      if (branchResult && /^(feat|fix|docs|style|refactor|perf|test|chore)\//.test(branchResult)) {
+        featureBranchName = branchResult;
+      }
+    } catch {
+      // Fallback: no feature branch detection
+    }
+  }
+
   registerTaskDispatchHandler({
     app,
     runId,
     parentBranch: runState.parentBranch,
     parentWorktreePath: parentWorktreeExists ? parentWorktreePath : undefined,
+    featureBranchName,
   });
 
   // 6. Dispatcher.start()

package/src/modules/cli/commands/run.ts

@@ -12,6 +12,7 @@ import { getCurrentBranch, cleanupOrphanedFromPreviousRuns } from "../../git-wor
 import { checkMemoryAndWarn } from "../../../shared/memory-check";
 import { installShutdownHandler } from "../../../shared/shutdown-handler";
 import { registerTaskDispatchHandler } from "./task-dispatch-handler";
+import { generateFeatureName } from "../../planning/feature-name-generator";
 
 export function createRunCommand(getApp: () => App): Command {
   const command = new Command("run")
@@ -44,7 +45,7 @@ export function createRunCommand(getApp: () => App): Command {
  * メインパイプライン実行
  */
 export async function runPipeline(app: App, requirementsPath: string, keepWorktrees = false): Promise<void> {
-  const { config, logger, eventBus, planningService, dispatcher, processManager, worktreeManager, stores, branchManager } = app;
+  const { config, logger, eventBus, planningService, dispatcher, processManager, worktreeManager, stores, branchManager, providerRegistry } = app;
 
   // Validate requirements file exists
   const reqFile = Bun.file(requirementsPath);
@@ -144,17 +145,27 @@ export async function runPipeline(app: App, requirementsPath: string, keepWorktr
     logger,
   });
 
-  // 5. Create parent worktree for merging task branches
+  // 5. Generate feature name and create parent worktree with real branch
   let parentWorktreePath: string | undefined;
+  let featureBranchName: string | undefined;
   try {
-    parentWorktreePath = await worktreeManager.createParentWorktree(runId, parentBranch);
-    logger.info({ parentWorktreePath }, "Parent worktree created for merging");
+    const { prefix, name: featureName } = await generateFeatureName(
+      requirementsPath,
+      providerRegistry.getProvider("implementer"),
+      logger,
+    );
+    featureBranchName = `${prefix}/${featureName}/parent`;
+    const result = await worktreeManager.createParentWorktree(runId, parentBranch, featureBranchName);
+    parentWorktreePath = result.worktreePath;
+    featureBranchName = result.branch;
+    logger.info({ parentWorktreePath, featureBranchName }, "Parent worktree created for merging");
+    console.log(`🌿 Feature Branch: ${featureBranchName}`);
   } catch (error) {
     logger.warn({ error }, "Failed to create parent worktree, using repo root as fallback");
   }
 
   // 5.5. Register task dispatch handler (shared with resume)
-  registerTaskDispatchHandler({ app, runId, parentBranch, parentWorktreePath });
+  registerTaskDispatchHandler({ app, runId, parentBranch, parentWorktreePath, featureBranchName });
 
   // 6. 進捗表示
   const progressSpinner = createSpinner("Executing tasks...");
@@ -219,7 +230,7 @@ export async function runPipeline(app: App, requirementsPath: string, keepWorktr
       const worktreeBase = `${process.cwd()}/.aad/worktrees`;
       const runWorktrees = worktrees.filter(
         (wt) => wt.path.startsWith(worktreeBase) 
-             && wt.branch.includes(runId)  // Check branch name for runId
+             && (wt.branch.includes(runId) || (featureBranchName && wt.branch.startsWith(featureBranchName.replace(/\/parent$/, ""))))  // Match by runId or feature name
              && !wt.path.includes(`parent-${runId}`)  // Keep parent worktree (contains merge results)
       );
 
@@ -239,7 +250,17 @@ export async function runPipeline(app: App, requirementsPath: string, keepWorktr
       await worktreeManager.pruneWorktrees();
 
       // Cleanup orphaned branches for this run (force delete merged branches)
-      const deletedBranches = await branchManager.cleanupOrphanBranches(runId, true);
+      let deletedBranches = await branchManager.cleanupOrphanBranches(runId, true);
+
+      // Also cleanup feature-named branches if applicable
+      if (featureBranchName) {
+        const featurePrefix = featureBranchName.replace(/\/parent$/, "");
+        const featureBranches = await branchManager.cleanupOrphanBranches(
+          createRunId(featurePrefix.replace(/^[^/]+\//, "")),
+          true,
+        );
+        deletedBranches = [...deletedBranches, ...featureBranches];
+      }
 
       console.log(`  Removed ${removed} worktree(s)`);
       console.log(`  Deleted ${deletedBranches.length} branch(es)`);

package/src/modules/cli/commands/task-dispatch-handler.ts

@@ -28,6 +28,9 @@ export interface TaskDispatchContext {
   /** Path to the parent worktree where task branches are merged into.
    *  If not provided, falls back to process.cwd() (repo root). */
   parentWorktreePath?: string;
+  /** Feature branch name (e.g. feat/auth-feature/parent).
+   *  Task branches are created from this branch. */
+  featureBranchName?: string;
 }
 
 /**
@@ -35,7 +38,7 @@ export interface TaskDispatchContext {
  * Handles memory gate, worker state, worktree creation, and TDD pipeline execution.
  */
 export function registerTaskDispatchHandler(ctx: TaskDispatchContext): void {
-  const { app, runId, parentBranch, parentWorktreePath } = ctx;
+  const { app, runId, parentBranch, parentWorktreePath, featureBranchName } = ctx;
   const mergeTarget = parentWorktreePath ?? process.cwd();
   const { eventBus, logger, config, processManager, worktreeManager, providerRegistry, stores } = app;
 
@@ -57,8 +60,13 @@ export function registerTaskDispatchHandler(ctx: TaskDispatchContext): void {
         throw new Error(`Task not found: ${taskId}`);
       }
 
-      const branchName = `aad/${runId}/${taskId}`;
-      const worktreePath = await worktreeManager.createTaskWorktree(taskId, branchName);
+      // Derive task branch name from feature branch or runId
+      // e.g. feat/auth-feature/task-001 (from feat/auth-feature/parent)
+      const branchPrefix = featureBranchName
+        ? featureBranchName.replace(/\/parent$/, "")
+        : `feat/${runId}`;
+      const branchName = `${branchPrefix}/${taskId}`;
+      const worktreePath = await worktreeManager.createTaskWorktree(taskId, branchName, featureBranchName);
       logger.info({ taskId, worktreePath, branchName }, "Worktree created");
 
       const workspace = await detectWorkspace(worktreePath, logger);

package/src/modules/cli/commands/update.ts

@@ -0,0 +1,119 @@
+/**
+ * `aad update` — Self-update AAD to the latest version
+ */
+import { Command } from "commander";
+import packageJson from "../../../../package.json" with { type: "json" };
+
+interface UpdateOptions {
+  check: boolean;
+}
+
+async function exec(
+  cmd: string[],
+): Promise<{ stdout: string; stderr: string; exitCode: number }> {
+  const proc = Bun.spawn(cmd, {
+    stdout: "pipe",
+    stderr: "pipe",
+  });
+  const [stdout, stderr, exitCode] = await Promise.all([
+    new Response(proc.stdout).text(),
+    new Response(proc.stderr).text(),
+    proc.exited,
+  ]);
+  return { stdout: stdout.trim(), stderr: stderr.trim(), exitCode };
+}
+
+async function getLatestVersion(): Promise<string | null> {
+  try {
+    const result = await exec(["npm", "view", "@ronkovic/aad", "version"]);
+    if (result.exitCode === 0 && result.stdout) {
+      return result.stdout;
+    }
+  } catch {
+    // ignore
+  }
+  return null;
+}
+
+function compareVersions(current: string, latest: string): number {
+  const c = current.split(".").map(Number);
+  const l = latest.split(".").map(Number);
+  for (let i = 0; i < 3; i++) {
+    if ((c[i] ?? 0) < (l[i] ?? 0)) return -1;
+    if ((c[i] ?? 0) > (l[i] ?? 0)) return 1;
+  }
+  return 0;
+}
+
+function detectPackageManager(): "bun" | "npm" {
+  if (process.env.BUN_INSTALL || process.argv[0]?.includes("bun")) {
+    return "bun";
+  }
+  return "npm";
+}
+
+async function clearBunxCache(): Promise<boolean> {
+  const cacheDir = `/private/tmp/bunx-${process.getuid?.() ?? 502}-@ronkovic/`;
+  try {
+    const result = await exec(["rm", "-rf", cacheDir]);
+    return result.exitCode === 0;
+  } catch {
+    return false;
+  }
+}
+
+export function createUpdateCommand(): Command {
+  return new Command("update")
+    .description("Update AAD to the latest version")
+    .option("--check", "Check for updates without installing", false)
+    .action(async (opts: UpdateOptions) => {
+      const currentVersion = packageJson.version;
+      console.log(`\n  現在のバージョン: v${currentVersion}`);
+
+      console.log("  最新バージョンを確認中...");
+      const latestVersion = await getLatestVersion();
+
+      if (!latestVersion) {
+        console.log("  \x1b[31m✗\x1b[0m レジストリからバージョン情報を取得できませんでした\n");
+        process.exit(1);
+      }
+
+      console.log(`  最新バージョン:   v${latestVersion}`);
+
+      const cmp = compareVersions(currentVersion, latestVersion);
+      if (cmp >= 0) {
+        console.log("  \x1b[32m✓\x1b[0m 最新バージョンです\n");
+        return;
+      }
+
+      if (opts.check) {
+        console.log(`  \x1b[33m⚠\x1b[0m 更新可能: v${currentVersion} → v${latestVersion}\n`);
+        return;
+      }
+
+      // Perform update
+      const pm = await detectPackageManager();
+      console.log(`\n  パッケージマネージャ: ${pm}`);
+
+      if (pm === "bun") {
+        console.log("  bunxキャッシュをクリア中...");
+        await clearBunxCache();
+        console.log("  \x1b[32m✓\x1b[0m キャッシュクリア完了");
+        console.log(`\n  次回 \`bunx @ronkovic/aad\` 実行時にv${latestVersion}が使用されます\n`);
+      } else {
+        console.log("  npm install中...");
+        const result = await exec([
+          "npm",
+          "install",
+          "-g",
+          `@ronkovic/aad@${latestVersion}`,
+        ]);
+        if (result.exitCode === 0) {
+          console.log(`  \x1b[32m✓\x1b[0m v${latestVersion}にアップデートしました\n`);
+        } else {
+          console.log(`  \x1b[31m✗\x1b[0m アップデート失敗: ${result.stderr}\n`);
+          process.exit(1);
+        }
+      }
+    });
+}

package/src/modules/cli/index.ts

@@ -21,6 +21,7 @@ export { createRunCommand, runPipeline } from "./commands/run";
 export { createResumeCommand, resumeRun } from "./commands/resume";
 export { createStatusCommand, displayStatus } from "./commands/status";
 export { createCleanupCommand, cleanupWorktrees } from "./commands/cleanup";
+export { createUpdateCommand } from "./commands/update";
 
 export {
   createShutdownManager,

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

@@ -34,11 +34,15 @@ describe("cleanupOrphanedFromPreviousRuns", () => {
           };
         }
         if (args[0] === "branch" && args[1] === "--list") {
-          return {
-            stdout: "  aad/run1/task-001\n  aad/run1/task-002\n",
-            stderr: "",
-            exitCode: 0,
-          };
+          // Only return branches for matching prefix pattern
+          if (args[2] === "aad/*") {
+            return {
+              stdout: "  aad/run1/task-001\n  aad/run1/task-002\n",
+              stderr: "",
+              exitCode: 0,
+            };
+          }
+          return { stdout: "", stderr: "", exitCode: 0 };
         }
         return { stdout: "", stderr: "", exitCode: 0 };
       }),

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

@@ -71,15 +71,30 @@ describe("WorktreeManager", () => {
   });
 
   describe("createParentWorktree", () => {
-    test("creates worktree on existing branch", async () => {
+    test("creates worktree with feature branch", async () => {
       const runId = createRunId("run-001");
       const parentBranch = "main";
+      const featureBranch = "feat/auth-feature/parent";
 
-      const worktreePath = await worktreeManager.createParentWorktree(runId, parentBranch);
+      const result = await worktreeManager.createParentWorktree(runId, parentBranch, featureBranch);
 
-      expect(worktreePath).toBe("/test/worktrees/parent-run-001");
+      expect(result.worktreePath).toBe("/test/worktrees/parent-run-001");
+      expect(result.branch).toBe(featureBranch);
       expect(mockGitOps.gitExec).toHaveBeenCalledWith(
-        ["worktree", "add", "/test/worktrees/parent-run-001", parentBranch],
+        ["worktree", "add", "-b", featureBranch, "/test/worktrees/parent-run-001", parentBranch],
+        expect.objectContaining({ cwd: repoRoot })
+      );
+    });
+
+    test("uses default branch name when featureBranch not provided", async () => {
+      const runId = createRunId("run-001");
+      const parentBranch = "main";
+
+      const result = await worktreeManager.createParentWorktree(runId, parentBranch);
+
+      expect(result.branch).toBe("feat/run-001/parent");
+      expect(mockGitOps.gitExec).toHaveBeenCalledWith(
+        ["worktree", "add", "-b", "feat/run-001/parent", "/test/worktrees/parent-run-001", parentBranch],
         expect.objectContaining({ cwd: repoRoot })
       );
     });

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

@@ -137,10 +137,17 @@ export class BranchManager {
    * Cleanup orphaned AAD branches (branches without worktrees)
    */
   async cleanupOrphanBranches(runId?: RunId, force = false): Promise<string[]> {
-    // Support both aad/* (slash) and aad-* (hyphen) patterns for backward compatibility
+    // Support aad/*, conventional commit prefixes (feat/*, fix/*, etc.), and legacy aad-* patterns
+    const conventionalPrefixes = ["aad", "feat", "fix", "docs", "style", "refactor", "perf", "test", "chore"];
     const patterns = runId
-      ? [`aad/${runId as string}/*`, `aad-*-${runId as string}*`]
-      : ["aad/*", "aad-*"];
+      ? [
+          ...conventionalPrefixes.map((p) => `${p}/${runId as string}/*`),
+          `aad-*-${runId as string}*`,
+        ]
+      : [
+          ...conventionalPrefixes.map((p) => `${p}/*`),
+          "aad-*",
+        ];
 
     this.logger?.info({ patterns, force }, "Cleaning up orphan branches");
 

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

@@ -41,10 +41,11 @@ export class WorktreeManager {
   /**
    * Create worktree for a task
    */
-  async createTaskWorktree(taskId: TaskId, branch: string): Promise<string> {
+  async createTaskWorktree(taskId: TaskId, branch: string, baseBranch?: string): Promise<string> {
     const worktreePath = join(this.worktreeBase, taskId as string);
+    const startPoint = baseBranch ?? "HEAD";
 
-    this.logger?.info({ taskId, branch, worktreePath }, "Creating task worktree");
+    this.logger?.info({ taskId, branch, baseBranch: startPoint, worktreePath }, "Creating task worktree");
 
     try {
       // Ensure worktree base directory exists
@@ -53,9 +54,9 @@ export class WorktreeManager {
       // Clean up stale worktree/branch if they already exist
       await this.cleanupStaleWorktree(worktreePath, branch);
 
-      // Create worktree with new branch
+      // Create worktree with new branch from baseBranch (parent feature branch)
       await this.gitOps.gitExec(
-        ["worktree", "add", "-b", branch, worktreePath, "HEAD"],
+        ["worktree", "add", "-b", branch, worktreePath, startPoint],
         { cwd: this.repoRoot, logger: this.logger }
       );
 
@@ -75,11 +76,11 @@ export class WorktreeManager {
    * Handles cases where a previous run left behind artifacts.
    */
   private async cleanupStaleWorktree(worktreePath: string, branch: string): Promise<void> {
-    // 1. Remove existing worktree directory if it exists
+    // 1. Remove existing worktree directory if it exists (no logger to suppress error-level output)
     try {
       await this.gitOps.gitExec(
         ["worktree", "remove", worktreePath, "--force"],
-        { cwd: this.repoRoot, logger: this.logger }
+        { cwd: this.repoRoot }
       );
       this.logger?.info({ worktreePath }, "Removed stale worktree");
     } catch {
@@ -98,11 +99,11 @@ export class WorktreeManager {
       // Non-critical
     }
 
-    // 3. Delete stale branch if it exists
+    // 3. Delete stale branch if it exists (no logger to suppress error-level git output)
     try {
       await this.gitOps.gitExec(
         ["branch", "-D", branch],
-        { cwd: this.repoRoot, logger: this.logger }
+        { cwd: this.repoRoot }
       );
       this.logger?.info({ branch }, "Deleted stale branch");
     } catch {
@@ -113,25 +114,32 @@ export class WorktreeManager {
   /**
    * Create worktree for parent branch (used for merging)
    */
-  async createParentWorktree(runId: RunId, parentBranch: string): Promise<string> {
+  async createParentWorktree(
+    runId: RunId,
+    parentBranch: string,
+    featureBranch?: string,
+  ): Promise<{ worktreePath: string; branch: string }> {
     const worktreePath = join(this.worktreeBase, `parent-${runId as string}`);
+    const branch = featureBranch ?? `feat/${runId as string}/parent`;
 
-    this.logger?.info({ runId, parentBranch, worktreePath }, "Creating parent worktree");
+    this.logger?.info({ runId, parentBranch, branch, worktreePath }, "Creating parent worktree");
 
     try {
       await this.fsOps.mkdir(this.worktreeBase, { recursive: true });
 
-      // Create worktree on existing branch (no -b flag)
+      // 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(
-        ["worktree", "add", worktreePath, parentBranch],
+        ["worktree", "add", "-b", branch, worktreePath, parentBranch],
         { cwd: this.repoRoot, logger: this.logger }
       );
 
-      return worktreePath;
+      return { worktreePath, branch };
     } catch (error) {
       throw new GitWorkspaceError("Failed to create parent worktree", {
         runId: runId as string,
         parentBranch,
+        branch,
         worktreePath,
         error: error instanceof Error ? error.message : String(error),
       });
@@ -279,28 +287,36 @@ export async function cleanupOrphanedFromPreviousRuns(
     // non-critical
   }
 
-  // 3. Delete all branches matching aad/*
+  // 3. Delete all branches matching aad/*, feat/*, fix/*, etc.
+  const branchPrefixes = ["aad", "feat", "fix", "docs", "style", "refactor", "perf", "test", "chore"];
   try {
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     const gitOps = (worktreeManager as any).gitOps as GitOps;
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     const repoRoot = (worktreeManager as any).repoRoot as string;
-    const result = await gitOps.gitExec(
-      ["branch", "--list", "aad/*"],
-      { cwd: repoRoot, logger },
-    );
-    const branches = result.stdout
-      .split("\n")
-      .map((b: string) => b.trim().replace(/^\* /, ""))
-      .filter((b: string) => b.length > 0);
 
-    for (const branch of branches) {
+    for (const prefix of branchPrefixes) {
       try {
-        await gitOps.gitExec(["branch", "-D", branch], { cwd: repoRoot, logger });
-        deletedBranches++;
-        logger.debug({ branch }, "Deleted orphaned branch");
+        const result = await gitOps.gitExec(
+          ["branch", "--list", `${prefix}/*`],
+          { cwd: repoRoot },
+        );
+        const branches = result.stdout
+          .split("\n")
+          .map((b: string) => b.trim().replace(/^[*+]\s*/, ""))
+          .filter((b: string) => b.length > 0);
+
+        for (const branch of branches) {
+          try {
+            await gitOps.gitExec(["branch", "-D", branch], { cwd: repoRoot });
+            deletedBranches++;
+            logger.debug({ branch }, "Deleted orphaned branch");
+          } catch {
+            logger.debug({ branch }, "Failed to delete orphaned branch (ignored)");
+          }
+        }
       } catch {
-        logger.debug({ branch }, "Failed to delete orphaned branch (ignored)");
+        // Pattern didn't match any branches
       }
     }
   } catch (error) {