@ronkovic/aad 0.3.9 → 0.5.0

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

@@ -0,0 +1,302 @@
+import { mkdir, readdir, cp, stat } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import type { Logger } from "pino";
+import { loadAndMergeSettings, saveSettings } from "./settings-merge";
+
+export interface CopyTemplatesOptions {
+  targetDir: string; // worktreeパス
+  projectRoot: string;
+  templateDir?: string; // default: resolveTemplateDir(projectRoot)
+  logger?: Logger;
+}
+
+const PROJECT_CONTEXT_HEADER = "# プロジェクト固有コンテキスト\n\n";
+
+/**
+ * Resolve template directory path:
+ * 1. Project local override: {projectRoot}/.aad/templates/ (if exists)
+ * 2. Package bundled: {packageRoot}/templates/
+ */
+export function resolveTemplateDir(projectRoot: string): string {
+  const localTemplateDir = join(projectRoot, ".aad", "templates");
+
+  // Check if local override exists
+  if (existsSync(localTemplateDir)) {
+    return localTemplateDir;
+  }
+
+  // Fallback to package bundled templates
+  // src/modules/git-workspace/ -> ../../../.aad/templates
+  const packageRoot = join(import.meta.dir, "..", "..", "..");
+  return join(packageRoot, ".aad", "templates");
+}
+
+/**
+ * Copy templates from .aad/templates/ to target worktree
+ * Implements overlay merge strategy:
+ * - CLAUDE.md: template base + project-specific append
+ * - .claude/: project base + template overlay (agents, hooks, rules, skills)
+ * - settings.json: deep merge
+ * - .gitignore: copy from template
+ */
+export async function copyTemplatesToWorktree(
+  options: CopyTemplatesOptions
+): Promise<void> {
+  const {
+    targetDir,
+    projectRoot,
+    templateDir = resolveTemplateDir(projectRoot),
+    logger,
+  } = options;
+
+  logger?.info({ targetDir, templateDir }, "Copying templates to worktree");
+
+  // Ensure target directory exists
+  await mkdir(targetDir, { recursive: true });
+
+  // Each step is non-critical, continue on errors
+  try {
+    // (a) CLAUDE.md: template base + project CLAUDE.md appended
+    await copyCLAUDEmd({
+      templateDir,
+      projectRoot,
+      targetDir,
+      logger,
+    });
+  } catch (error) {
+    logger?.debug({ error }, "CLAUDE.md copy failed (non-critical)");
+  }
+
+  try {
+    // (b) .claude/: overlay merge (agents, hooks, rules, skills)
+    await copyClaudeDir({
+      templateDir,
+      projectRoot,
+      targetDir,
+      logger,
+    });
+  } catch (error) {
+    logger?.debug({ error }, ".claude/ copy failed (non-critical)");
+  }
+
+  try {
+    // (c) settings.json: deep merge
+    await mergeSettingsJson({
+      templateDir,
+      projectRoot,
+      targetDir,
+      logger,
+    });
+  } catch (error) {
+    logger?.debug({ error }, "settings.json merge failed (non-critical)");
+  }
+
+  try {
+    // (d) .gitignore: copy from template
+    await copyGitignore({
+      templateDir,
+      targetDir,
+      logger,
+    });
+  } catch (error) {
+    logger?.debug({ error }, ".gitignore copy failed (non-critical)");
+  }
+
+  logger?.info({ targetDir }, "Template copy completed");
+}
+
+/**
+ * Copy CLAUDE.md: template base + project content appended
+ */
+async function copyCLAUDEmd(opts: {
+  templateDir: string;
+  projectRoot: string;
+  targetDir: string;
+  logger?: Logger;
+}): Promise<void> {
+  const { templateDir, projectRoot, targetDir, logger } = opts;
+
+  const templateCLAUDE = join(templateDir, "CLAUDE.md");
+  const projectCLAUDE = join(projectRoot, "CLAUDE.md");
+  const targetCLAUDE = join(targetDir, "CLAUDE.md");
+
+  let content = "";
+
+  // Start with template CLAUDE.md if exists
+  try {
+    content = await Bun.file(templateCLAUDE).text();
+    logger?.debug({ templateCLAUDE }, "Loaded template CLAUDE.md");
+  } catch {
+    logger?.debug({ templateCLAUDE }, "No template CLAUDE.md found (skipping)");
+  }
+
+  // Append project CLAUDE.md if exists
+  try {
+    const projectContent = await Bun.file(projectCLAUDE).text();
+    if (projectContent.trim()) {
+      content += "\n\n" + PROJECT_CONTEXT_HEADER + projectContent;
+      logger?.debug({ projectCLAUDE }, "Appended project CLAUDE.md");
+    }
+  } catch {
+    logger?.debug({ projectCLAUDE }, "No project CLAUDE.md found (skipping)");
+  }
+
+  // Write to target
+  if (content.trim()) {
+    await Bun.write(targetCLAUDE, content);
+    logger?.debug({ targetCLAUDE }, "Written CLAUDE.md");
+  }
+}
+
+/**
+ * Copy .claude/ directory: project base + template overlay
+ * Overlay: agents, hooks, rules, skills from template
+ * Preserve: agent-memory from project (existing wins)
+ */
+async function copyClaudeDir(opts: {
+  templateDir: string;
+  projectRoot: string;
+  targetDir: string;
+  logger?: Logger;
+}): Promise<void> {
+  const { templateDir, projectRoot, targetDir, logger } = opts;
+
+  const projectClaudeDir = join(projectRoot, ".claude");
+  const templateClaudeDir = join(templateDir, ".claude");
+  const targetClaudeDir = join(targetDir, ".claude");
+
+  // Ensure target .claude/ exists
+  await mkdir(targetClaudeDir, { recursive: true });
+
+  // Copy project .claude/ subdirectories as base layer (if exists), excluding agent-memory
+  // We manually copy subdirectories to exclude agent-memory
+  try {
+    let projectClaudeExists = false;
+    try {
+      const stats = await stat(projectClaudeDir);
+      projectClaudeExists = stats.isDirectory();
+    } catch {
+      projectClaudeExists = false;
+    }
+
+    if (projectClaudeExists) {
+      const entries = await readdir(projectClaudeDir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (entry.name === "agent-memory") {
+          continue; // Skip agent-memory, will handle separately
+        }
+        const src = join(projectClaudeDir, entry.name);
+        const dest = join(targetClaudeDir, entry.name);
+        if (entry.isDirectory()) {
+          await cp(src, dest, { recursive: true });
+        } else {
+          await cp(src, dest);
+        }
+      }
+      logger?.debug({ projectClaudeDir }, "Copied project .claude/ as base (excluding agent-memory)");
+    }
+  } catch (error) {
+    logger?.debug({ projectClaudeDir, error }, "No project .claude/ found or copy failed");
+  }
+
+  // Overlay template subdirectories (agents, hooks, rules, skills)
+  const overlayDirs = ["agents", "hooks", "rules", "skills"];
+
+  for (const subdir of overlayDirs) {
+    const templateSubdir = join(templateClaudeDir, subdir);
+    const targetSubdir = join(targetClaudeDir, subdir);
+
+    try {
+      // Ensure target subdir exists
+      await mkdir(targetSubdir, { recursive: true });
+
+      // Copy template files (overwrite)
+      await cp(templateSubdir, targetSubdir, { recursive: true });
+      logger?.debug({ templateSubdir, targetSubdir }, `Overlayed ${subdir}/`);
+    } catch {
+      logger?.debug({ templateSubdir }, `No template ${subdir}/ found (skipping)`);
+    }
+  }
+
+  // Handle agent-memory: existing (project) wins, don't overwrite
+  const projectMemoryDir = join(projectClaudeDir, "agent-memory");
+  const templateMemoryDir = join(templateClaudeDir, "agent-memory");
+  const targetMemoryDir = join(targetClaudeDir, "agent-memory");
+
+  try {
+    // Check if project has agent-memory directory
+    let projectMemoryExists = false;
+    try {
+      const stats = await stat(projectMemoryDir);
+      projectMemoryExists = stats.isDirectory();
+    } catch {
+      projectMemoryExists = false;
+    }
+
+    if (projectMemoryExists) {
+      // Copy project agent-memory
+      await cp(projectMemoryDir, targetMemoryDir, { recursive: true });
+      logger?.debug({ projectMemoryDir }, "Preserved project agent-memory/");
+    } else {
+      // No project memory, copy template if exists
+      try {
+        await cp(templateMemoryDir, targetMemoryDir, { recursive: true });
+        logger?.debug({ templateMemoryDir }, "Copied template agent-memory/");
+      } catch {
+        logger?.debug("No template agent-memory found");
+      }
+    }
+  } catch (error) {
+    logger?.debug({ error }, "No agent-memory to handle");
+  }
+}
+
+/**
+ * Merge settings.json: project + template deep merge
+ */
+async function mergeSettingsJson(opts: {
+  templateDir: string;
+  projectRoot: string;
+  targetDir: string;
+  logger?: Logger;
+}): Promise<void> {
+  const { templateDir, projectRoot, targetDir, logger } = opts;
+
+  const projectSettings = join(projectRoot, ".claude", "settings.json");
+  const templateSettings = join(templateDir, "settings.json");
+  const targetSettings = join(targetDir, ".claude", "settings.json");
+
+  // Load and merge settings
+  const merged = await loadAndMergeSettings(
+    [projectSettings, templateSettings],
+    logger
+  );
+
+  // Save to target
+  await mkdir(join(targetDir, ".claude"), { recursive: true });
+  await saveSettings(targetSettings, merged, logger);
+
+  logger?.debug({ targetSettings }, "Merged and saved settings.json");
+}
+
+/**
+ * Copy .gitignore from template
+ */
+async function copyGitignore(opts: {
+  templateDir: string;
+  targetDir: string;
+  logger?: Logger;
+}): Promise<void> {
+  const { templateDir, targetDir, logger } = opts;
+
+  const templateGitignore = join(templateDir, ".gitignore");
+  const targetGitignore = join(targetDir, ".gitignore");
+
+  try {
+    await cp(templateGitignore, targetGitignore, { force: true });
+    logger?.debug({ templateGitignore, targetGitignore }, "Copied .gitignore");
+  } catch {
+    logger?.debug({ templateGitignore }, "No template .gitignore found (skipping)");
+  }
+}

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

@@ -169,16 +169,20 @@ export class WorktreeManager {
         }
       }
 
-      // Try to force remove directory as fallback
-      try {
-        await this.fsOps.rm(worktreePath, { recursive: true, force: true });
-        await this.gitOps.gitExec(["worktree", "prune"], { cwd: this.repoRoot, logger: this.logger });
-      } catch (cleanupError) {
-        this.logger?.debug({ cleanupError, worktreePath }, "Worktree cleanup fallback failed (ignored)");
+      // Try to force remove directory as fallback (only if force=true)
+      if (force) {
+        try {
+          await this.fsOps.rm(worktreePath, { recursive: true, force: true });
+          await this.gitOps.gitExec(["worktree", "prune"], { cwd: this.repoRoot, logger: this.logger });
+          return;
+        } catch (cleanupError) {
+          this.logger?.debug({ cleanupError, worktreePath }, "Worktree cleanup fallback failed");
+        }
       }
 
       throw new GitWorkspaceError("Failed to remove worktree", {
         worktreePath,
+        force,
         error: error instanceof Error ? error.message : String(error),
       });
     }
@@ -217,6 +221,15 @@ export class WorktreeManager {
       }
     }
 
+    // Push the last worktree if it hasn't been pushed yet
+    if (current.path && current.head) {
+      worktrees.push({
+        path: current.path,
+        branch: current.branch ?? "(detached)",
+        head: current.head,
+      });
+    }
+
     return worktrees;
   }
 
@@ -256,16 +269,24 @@ export class WorktreeManager {
 export async function cleanupOrphanedFromPreviousRuns(
   worktreeManager: WorktreeManager,
   logger: Logger,
-): Promise<{ removedWorktrees: number; deletedBranches: number }> {
+): Promise<{ removedWorktrees: number; deletedBranches: number; preservedBranches: number }> {
   logger.info("Cleaning up orphaned worktrees/branches from previous runs");
 
   let removedWorktrees = 0;
   let deletedBranches = 0;
+  let preservedBranches = 0;
 
-  // 1. Remove all worktrees under .aad/worktrees/
+  // 1. Remove all worktrees under .aad/worktrees/ (except parent worktrees)
   try {
     const worktrees = await worktreeManager.listWorktrees();
-    const aadWorktrees = worktrees.filter((wt) => wt.path.includes("/.aad/worktrees/"));
+    const aadWorktrees = worktrees.filter((wt) => {
+      if (!wt.path.includes("/.aad/worktrees/")) return false;
+      if (/\/parent-[^/]+$/.test(wt.path)) {
+        logger.info({ path: wt.path }, "Preserving parent worktree (contains commit history)");
+        return false;
+      }
+      return true;
+    });
 
     for (const wt of aadWorktrees) {
       try {
@@ -307,6 +328,11 @@ export async function cleanupOrphanedFromPreviousRuns(
           .filter((b: string) => b.length > 0);
 
         for (const branch of branches) {
+          if (branch.endsWith("/parent")) {
+            logger.info({ branch }, "Preserving parent branch (contains commit history)");
+            preservedBranches++;
+            continue;
+          }
           try {
             await gitOps.gitExec(["branch", "-D", branch], { cwd: repoRoot });
             deletedBranches++;
@@ -323,6 +349,6 @@ export async function cleanupOrphanedFromPreviousRuns(
     logger.debug({ error }, "Failed to list branches during cleanup");
   }
 
-  logger.info({ removedWorktrees, deletedBranches }, "Orphaned cleanup completed");
-  return { removedWorktrees, deletedBranches };
+  logger.info({ removedWorktrees, deletedBranches, preservedBranches }, "Orphaned cleanup completed");
+  return { removedWorktrees, deletedBranches, preservedBranches };
 }

package/src/modules/planning/__tests__/planning-service.test.ts

@@ -54,6 +54,9 @@ function createMockConfig(teamsEnabled: boolean = false): Config {
       port: 7333,
       host: "localhost",
     },
+    git: { autoPush: false },
+      skipCompleted: true,
+      strictTdd: false,
   };
 }
 

package/src/modules/planning/__tests__/planning.service.test.ts

@@ -0,0 +1,149 @@
+/**
+ * Planning Service Tests
+ * Verifies task planning orchestration and task_plan.json persistence
+ */
+
+import { describe, test, expect, beforeEach, afterEach, mock } from "bun:test";
+import { PlanningService } from "../planning.service";
+import { EventBus } from "@aad/shared/events";
+import { loadConfig } from "@aad/shared/config";
+import { pino } from "pino";
+import { createRunId } from "@aad/shared/types";
+import { mkdir, readFile, writeFile, rm } from "node:fs/promises";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import type { ClaudeProvider } from "../../claude-provider";
+
+describe("PlanningService - task_plan.json persistence", () => {
+  let service: PlanningService;
+  let mockProvider: ClaudeProvider;
+  let eventBus: EventBus;
+  let logger: import("pino").Logger;
+  let testDocsDir: string;
+
+  beforeEach(async () => {
+    eventBus = new EventBus();
+    logger = pino({ level: "silent" });
+    const config = loadConfig({ AAD_NUM_WORKERS: "2" });
+
+    // Create temp docs directory for testing
+    testDocsDir = join(tmpdir(), `aad-test-docs-${Date.now()}`);
+    await mkdir(testDocsDir, { recursive: true });
+
+    // Mock Claude provider that writes valid task_plan.json
+    mockProvider = {
+      call: mock(async (request) => {
+        // Extract taskPlanFilePath from prompt
+        const match = request.prompt.match(/Write.*to the following path:\s*([^\n]+)/);
+        if (!match?.[1]) {
+          throw new Error("Could not find task_plan.json path in prompt");
+        }
+        const taskPlanFilePath = match[1].trim();
+
+        // Write valid task_plan.json
+        const taskPlan = {
+          run_id: "test-run-123",
+          parent_branch: "main",
+          tasks: [
+            {
+              task_id: "task-001",
+              title: "Test Task 1",
+              description: "Test description",
+              files_to_modify: ["file1.ts"],
+              depends_on: [],
+              priority: 1,
+            },
+          ],
+        };
+
+        await writeFile(taskPlanFilePath, JSON.stringify(taskPlan, null, 2));
+
+        return {
+          exitCode: 0,
+          result: "Task plan written successfully",
+        };
+      }) as any,
+    };
+
+    service = new PlanningService(mockProvider, eventBus, config, logger);
+  });
+
+  afterEach(async () => {
+    // Cleanup test docs directory
+    await rm(testDocsDir, { recursive: true, force: true });
+  });
+
+  test("persists task_plan.json to docs directory on successful planning", async () => {
+    const runId = createRunId("test-run-123");
+    const requirementsPath = join(testDocsDir, "requirements.md");
+    await writeFile(requirementsPath, "# Test Requirements\n\nTest content");
+
+    const taskPlan = await service.planTasks({
+      runId,
+      parentBranch: "main",
+      requirementsPath,
+      targetDocsDir: testDocsDir,
+      projectRoot: process.cwd(),
+    });
+
+    expect(taskPlan).toBeDefined();
+    expect(taskPlan.tasks.length).toBe(1);
+
+    // Verify task_plan.json was persisted to docs directory
+    const persistedPath = join(testDocsDir, "task_plan.json");
+    const persistedContent = await readFile(persistedPath, "utf-8");
+    const persistedPlan = JSON.parse(persistedContent);
+
+    expect(persistedPlan.run_id).toBe("test-run-123");
+    expect(persistedPlan.parent_branch).toBe("main");
+    expect(persistedPlan.tasks.length).toBe(1);
+    expect(persistedPlan.tasks[0].task_id).toBe("task-001");
+  });
+
+  test("handles persistence error gracefully (non-critical)", async () => {
+    const runId = createRunId("test-run-456");
+    const requirementsPath = join(testDocsDir, "requirements.md");
+    await writeFile(requirementsPath, "# Test Requirements\n\nTest content");
+
+    // Use invalid docs directory (permission denied scenario)
+    const invalidDocsDir = "/invalid/path/that/does/not/exist";
+
+    // Planning should succeed even if persistence fails
+    const taskPlan = await service.planTasks({
+      runId,
+      parentBranch: "main",
+      requirementsPath,
+      targetDocsDir: invalidDocsDir,
+      projectRoot: process.cwd(),
+    });
+
+    expect(taskPlan).toBeDefined();
+    expect(taskPlan.tasks.length).toBe(1);
+  });
+
+  test("creates target directory if it does not exist", async () => {
+    const runId = createRunId("test-run-789");
+    const requirementsPath = join(testDocsDir, "requirements.md");
+    await writeFile(requirementsPath, "# Test Requirements\n\nTest content");
+
+    // Use nested directory that doesn't exist yet
+    const nestedDocsDir = join(testDocsDir, "nested", "docs", "dir");
+
+    const taskPlan = await service.planTasks({
+      runId,
+      parentBranch: "main",
+      requirementsPath,
+      targetDocsDir: nestedDocsDir,
+      projectRoot: process.cwd(),
+    });
+
+    expect(taskPlan).toBeDefined();
+
+    // Verify directory was created and file was persisted
+    const persistedPath = join(nestedDocsDir, "task_plan.json");
+    const persistedContent = await readFile(persistedPath, "utf-8");
+    const persistedPlan = JSON.parse(persistedContent);
+
+    expect(persistedPlan.tasks.length).toBe(1);
+  });
+});

package/src/modules/planning/__tests__/project-detection.test.ts

@@ -162,7 +162,13 @@ describe("detectPackageManager", () => {
     expect(result).toBe("npm");
   });
 
-  test("detects bun", async () => {
+  test("detects bun (text lockfile)", async () => {
+    const checker = createMockFileChecker({ "bun.lock": "" });
+    const result = await detectPackageManager("/test", checker);
+    expect(result).toBe("bun");
+  });
+
+  test("detects bun (binary lockfile)", async () => {
     const checker = createMockFileChecker({ "bun.lockb": "" });
     const result = await detectPackageManager("/test", checker);
     expect(result).toBe("bun");

package/src/modules/planning/planning.service.ts

@@ -11,7 +11,7 @@ import { parseTaskPlan, validateTaskPlan } from "../task-queue";
 import { validateFileConflicts, formatConflictErrors } from "./file-conflict-validator";
 import { analyzeProject, createBunFileChecker, type FileChecker } from "./project-detection";
 import { join } from "node:path";
-import { mkdtemp, readFile, rm } from "node:fs/promises";
+import { mkdtemp, readFile, rm, mkdir } from "node:fs/promises";
 import { tmpdir } from "node:os";
 
 export interface PlanTasksParams {
@@ -141,6 +141,15 @@ export class PlanningService {
         taskCount: taskPlan.tasks.length,
       });
 
+      // Save task_plan.json to targetDocsDir
+      try {
+        await mkdir(targetDocsDir, { recursive: true });
+        await Bun.write(join(targetDocsDir, "task_plan.json"), taskPlanJsonStr);
+        this.logger.debug({ targetDocsDir }, "Persisted task_plan.json");
+      } catch (error) {
+        this.logger.warn({ error, targetDocsDir }, "Failed to persist task_plan.json (non-critical)");
+      }
+
       return taskPlan;
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
@@ -202,7 +211,12 @@ Parent branch: ${parentBranch}
 Instructions:
 1. Read the requirements file/directory
 2. Split into independent tasks with clear file assignments
-3. Set depends_on for tasks that modify the same files (later task depends on earlier)
+3. Set depends_on based on:
+   - File overlap: tasks that modify the same files (later task depends on earlier)
+   - Logical dependency: tasks whose output is consumed by another task
+     (e.g., DB schema → API that queries the DB → Frontend that calls the API)
+   - Import dependency: tasks that create modules imported by other tasks
+   If no dependency exists, use an empty array []
 4. Set priority (1 = highest)
 5. CRITICAL: Write the result as a JSON file to the following path:
    ${taskPlanFilePath}

package/src/modules/planning/project-detection.ts

@@ -36,6 +36,7 @@ export type TestFramework =
   | "jest"
   | "bun:test"
   | "mocha"
+  | "playwright"
   | "go-test"
   | "cargo-test"
   | "terraform-validate"
@@ -204,7 +205,8 @@ export async function detectPackageManager(
   if (await checker.exists(path.join(projectRoot, "pnpm-lock.yaml"))) return "pnpm";
   if (await checker.exists(path.join(projectRoot, "yarn.lock"))) return "yarn";
   if (await checker.exists(path.join(projectRoot, "package-lock.json"))) return "npm";
-  if (await checker.exists(path.join(projectRoot, "bun.lockb"))) return "bun";
+  if (await checker.exists(path.join(projectRoot, "bun.lock"))) return "bun"; // text format (v1.2+)
+  if (await checker.exists(path.join(projectRoot, "bun.lockb"))) return "bun"; // binary format (legacy)
 
   // Rust/Go
   if (await checker.exists(path.join(projectRoot, "Cargo.lock"))) return "cargo";
@@ -290,6 +292,7 @@ export async function detectTestFramework(
         if (content.includes('"bun-types"') || content.includes('"@types/bun"')) {
           return "bun:test";
         }
+        if (content.includes('"@playwright/test"')) return "playwright";
         if (content.includes('"vitest"')) return "vitest";
         if (content.includes('"jest"')) return "jest";
         if (content.includes('"mocha"')) return "mocha";

package/src/modules/process-manager/__tests__/process-manager.test.ts

@@ -24,6 +24,9 @@ describe("ProcessManager", () => {
         teams: { splitter: false, reviewer: false },
         memorySync: false,
         dashboard: { enabled: false, port: 7333, host: "localhost" },
+        git: { autoPush: false },
+      skipCompleted: true,
+      strictTdd: false,
       },
       logger,
     });

package/src/modules/process-manager/process-manager.ts

@@ -29,7 +29,7 @@ export class ProcessManager {
   /**
    * Initialize worker pool
    */
-  async initializePool(numWorkers: number): Promise<void> {
+  initializePool(numWorkers: number): Promise<void> {
     if (this.initialized) {
       throw new ProcessManagerError("ProcessManager already initialized");
     }
@@ -49,6 +49,7 @@ export class ProcessManager {
 
     this.initialized = true;
     this.deps.logger.info({ numWorkers }, "Worker pool initialized");
+    return Promise.resolve();
   }
 
   /**