@ronkovic/aad 0.3.0 → 0.3.2

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

@@ -50,6 +50,9 @@ export class WorktreeManager {
       // Ensure worktree base directory exists
       await this.fsOps.mkdir(this.worktreeBase, { recursive: true });
 
+      // Clean up stale worktree/branch if they already exist
+      await this.cleanupStaleWorktree(worktreePath, branch);
+
       // Create worktree with new branch
       await this.gitOps.gitExec(
         ["worktree", "add", "-b", branch, worktreePath, "HEAD"],
@@ -67,6 +70,46 @@ export class WorktreeManager {
     }
   }
 
+  /**
+   * Clean up stale worktree path and branch before creating a new one.
+   * 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
+    try {
+      await this.gitOps.gitExec(
+        ["worktree", "remove", worktreePath, "--force"],
+        { cwd: this.repoRoot, logger: this.logger }
+      );
+      this.logger?.info({ worktreePath }, "Removed stale worktree");
+    } catch {
+      // Worktree doesn't exist or already removed — try direct directory removal
+      try {
+        await this.fsOps.rm(worktreePath, { recursive: true, force: true });
+      } catch {
+        // Directory doesn't exist, nothing to do
+      }
+    }
+
+    // 2. Prune worktree references
+    try {
+      await this.gitOps.gitExec(["worktree", "prune"], { cwd: this.repoRoot, logger: this.logger });
+    } catch {
+      // Non-critical
+    }
+
+    // 3. Delete stale branch if it exists
+    try {
+      await this.gitOps.gitExec(
+        ["branch", "-D", branch],
+        { cwd: this.repoRoot, logger: this.logger }
+      );
+      this.logger?.info({ branch }, "Deleted stale branch");
+    } catch {
+      // Branch doesn't exist, nothing to do
+    }
+  }
+
   /**
    * Create worktree for parent branch (used for merging)
    */
@@ -197,3 +240,73 @@ export class WorktreeManager {
     );
   }
 }
+
+/**
+ * Cleanup orphaned worktrees and branches from previous AAD runs.
+ * Called at startup before planning phase.
+ */
+export async function cleanupOrphanedFromPreviousRuns(
+  worktreeManager: WorktreeManager,
+  logger: Logger,
+): Promise<{ removedWorktrees: number; deletedBranches: number }> {
+  logger.info("Cleaning up orphaned worktrees/branches from previous runs");
+
+  let removedWorktrees = 0;
+  let deletedBranches = 0;
+
+  // 1. Remove all worktrees under .aad/worktrees/
+  try {
+    const worktrees = await worktreeManager.listWorktrees();
+    const aadWorktrees = worktrees.filter((wt) => wt.path.includes("/.aad/worktrees/"));
+
+    for (const wt of aadWorktrees) {
+      try {
+        await worktreeManager.removeWorktree(wt.path, true);
+        removedWorktrees++;
+        logger.debug({ path: wt.path }, "Removed orphaned worktree");
+      } catch {
+        logger.debug({ path: wt.path }, "Failed to remove orphaned worktree (ignored)");
+      }
+    }
+  } catch (error) {
+    logger.debug({ error }, "Failed to list worktrees during cleanup");
+  }
+
+  // 2. Prune worktree references
+  try {
+    await worktreeManager.pruneWorktrees();
+  } catch {
+    // non-critical
+  }
+
+  // 3. Delete all branches matching aad/*
+  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) {
+      try {
+        await gitOps.gitExec(["branch", "-D", branch], { cwd: repoRoot, logger });
+        deletedBranches++;
+        logger.debug({ branch }, "Deleted orphaned branch");
+      } catch {
+        logger.debug({ branch }, "Failed to delete orphaned branch (ignored)");
+      }
+    }
+  } catch (error) {
+    logger.debug({ error }, "Failed to list branches during cleanup");
+  }
+
+  logger.info({ removedWorktrees, deletedBranches }, "Orphaned cleanup completed");
+  return { removedWorktrees, deletedBranches };
+}

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

@@ -165,8 +165,8 @@ describe("PlanningService", () => {
     }
 
     expect(mockProvider.lastRequest).toBeDefined();
-    expect(mockProvider.lastRequest?.prompt).toContain("splitterエージェントとして");
-    expect(mockProvider.lastRequest?.prompt).not.toContain("サブエージェント");
+    expect(mockProvider.lastRequest?.prompt).toContain("task splitter agent");
+    expect(mockProvider.lastRequest?.prompt).toContain("CRITICAL");
   }, 15_000);
 
   test("planTasks calls ClaudeProvider with teams mode prompt", async () => {
@@ -197,7 +197,7 @@ describe("PlanningService", () => {
     }
 
     expect(mockProvider.lastRequest).toBeDefined();
-    expect(mockProvider.lastRequest?.prompt).toContain("サブエージェント");
+    expect(mockProvider.lastRequest?.prompt).toContain("task splitter agent");
     // Teams mode now uses subagents instead of prompt-only instructions
     expect(mockProvider.lastRequest?.subagents).toBeDefined();
     expect(mockProvider.lastRequest?.subagents).toHaveLength(3);
@@ -363,4 +363,157 @@ describe("PlanningService", () => {
 
     expect(failedEvent).toBeDefined();
   });
+
+  describe("file-write planning approach", () => {
+    test("reads task plan from temp file when it exists", async () => {
+      const config = createMockConfig();
+      const service = new PlanningService(mockProvider, eventBus, config, mockLogger, { fileChecker: mockFileChecker });
+
+      const taskPlanData = {
+        run_id: "test-run",
+        parent_branch: "feature/test-run",
+        tasks: [
+          {
+            task_id: "task-1",
+            title: "File-based task",
+            description: "Read from file",
+            files_to_modify: ["file1.ts"],
+            depends_on: [],
+            priority: 1,
+          },
+        ],
+      };
+
+      // Claude writes the file; the service reads it.
+      // We intercept the claude call to actually write the file at the path in the prompt.
+      mockProvider.call = async (request: ClaudeRequest) => {
+        // Extract the task_plan.json path from the prompt
+        const match = request.prompt.match(/\n\s+(\/[^\n]*task_plan\.json)/);
+        if (match?.[1]) {
+          const { writeFile } = await import("node:fs/promises");
+          await writeFile(match[1], JSON.stringify(taskPlanData));
+        }
+        return {
+          result: "I have written the task plan to the file.",
+          exitCode: 0,
+          model: "claude-sonnet-4-5" as const,
+          effortLevel: "medium" as const,
+          duration: 1000,
+        };
+      };
+
+      const result = await service.planTasks({
+        runId: createRunId("test-run"),
+        parentBranch: "feature/test-run",
+        requirementsPath: "/test/requirements.md",
+        targetDocsDir: "/test/docs",
+      });
+
+      expect(result.tasks).toHaveLength(1);
+      expect(result.tasks[0]!.title).toBe("File-based task");
+    });
+
+    test("falls back to stdout parsing when temp file does not exist", async () => {
+      const config = createMockConfig();
+      const service = new PlanningService(mockProvider, eventBus, config, mockLogger, { fileChecker: mockFileChecker });
+
+      // Claude does NOT write the file, but returns JSON in stdout
+      mockProvider.mockResponse = {
+        result: JSON.stringify({
+          run_id: "test-run",
+          parent_branch: "feature/test-run",
+          tasks: [
+            {
+              task_id: "task-1",
+              title: "Stdout task",
+              description: "Parsed from stdout",
+              files_to_modify: ["file1.ts"],
+              depends_on: [],
+              priority: 1,
+            },
+          ],
+        }),
+        exitCode: 0,
+        model: "claude-sonnet-4-5",
+        effortLevel: "medium" as const,
+        duration: 1000,
+      };
+
+      const result = await service.planTasks({
+        runId: createRunId("test-run"),
+        parentBranch: "feature/test-run",
+        requirementsPath: "/test/requirements.md",
+        targetDocsDir: "/test/docs",
+      });
+
+      expect(result.tasks).toHaveLength(1);
+      expect(result.tasks[0]!.title).toBe("Stdout task");
+    });
+
+    test("temp directory is cleaned up after planning (success)", async () => {
+      const config = createMockConfig();
+      const service = new PlanningService(mockProvider, eventBus, config, mockLogger, { fileChecker: mockFileChecker });
+      const { existsSync } = await import("node:fs");
+
+      let tempDirPath: string | null = null;
+
+      mockProvider.call = async (request: ClaudeRequest) => {
+        const match = request.prompt.match(/\n\s+(\/[^\n]*task_plan\.json)/);
+        if (match?.[1]) {
+          tempDirPath = match[1].replace("/task_plan.json", "");
+          const { writeFile } = await import("node:fs/promises");
+          await writeFile(match[1], JSON.stringify({
+            run_id: "test-run",
+            parent_branch: "feature/test-run",
+            tasks: [{
+              task_id: "task-1",
+              title: "Cleanup test",
+              description: "Test",
+              files_to_modify: ["f.ts"],
+              depends_on: [],
+              priority: 1,
+            }],
+          }));
+        }
+        return { result: "done", exitCode: 0, model: "claude-sonnet-4-5" as const, effortLevel: "medium" as const, duration: 1000 };
+      };
+
+      await service.planTasks({
+        runId: createRunId("test-run"),
+        parentBranch: "feature/test-run",
+        requirementsPath: "/test/requirements.md",
+        targetDocsDir: "/test/docs",
+      });
+
+      expect(tempDirPath).not.toBeNull();
+      // Temp directory should be cleaned up
+      expect(existsSync(tempDirPath!)).toBe(false);
+    });
+
+    test("temp directory is cleaned up after planning (failure)", async () => {
+      const config = createMockConfig();
+      const service = new PlanningService(mockProvider, eventBus, config, mockLogger, { fileChecker: mockFileChecker });
+      const { existsSync } = await import("node:fs");
+
+      let tempDirPath: string | null = null;
+
+      mockProvider.call = async (request: ClaudeRequest) => {
+        const match = request.prompt.match(/\n\s+(\/[^\n]*task_plan\.json)/);
+        if (match?.[1]) {
+          tempDirPath = match[1].replace("/task_plan.json", "");
+        }
+        return { result: "error", exitCode: 1, model: "claude-sonnet-4-5" as const, effortLevel: "medium" as const, duration: 1000 };
+      };
+
+      await expect(service.planTasks({
+        runId: createRunId("test-run"),
+        parentBranch: "feature/test-run",
+        requirementsPath: "/test/requirements.md",
+        targetDocsDir: "/test/docs",
+      })).rejects.toThrow();
+
+      expect(tempDirPath).not.toBeNull();
+      expect(existsSync(tempDirPath!)).toBe(false);
+    });
+  });
 });

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

@@ -10,6 +10,9 @@ import { PlanningError } from "../../shared/errors";
 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 { tmpdir } from "node:os";
 
 export interface PlanTasksParams {
   runId: RunId;
@@ -45,25 +48,32 @@ export class PlanningService {
       requirementsPath,
     });
 
+    // Create temp directory for task_plan.json output
+    const tempDir = await mkdtemp(join(tmpdir(), `aad-plan-${runId}-`));
+    const taskPlanFilePath = join(tempDir, "task_plan.json");
+
     try {
       // 1. Project analysis (optional context for splitter)
       const projectAnalysis = await analyzeProject(projectRoot, this.fileChecker);
       this.logger.debug({ projectAnalysis }, "Project analysis completed");
 
-      // 2. Build splitter prompt
+      // 2. Build splitter prompt (file-write based)
       const prompt = this.buildSplitterPrompt({
         runId,
         parentBranch,
         requirementsPath,
         targetDocsDir,
         projectAnalysis,
+        taskPlanFilePath,
       });
 
-      // 3. Call Claude splitter
-      this.logger.info("Calling Claude splitter agent");
+      // 3. Call Claude splitter — output goes to file, not stdout
+      this.logger.info({ taskPlanFilePath }, "Calling Claude splitter agent (file-write mode)");
       const subagents = this.config.teams.splitter ? this.buildSplitterSubagents() : undefined;
+      
       const response = await this.claudeProvider.call({
         prompt,
+        allowedTools: ["Read", "Write", "Edit", "Glob", "Grep", "Bash"],
         ...(subagents ? { subagents } : {}),
       });
 
@@ -75,9 +85,31 @@ export class PlanningService {
         });
       }
 
-      // 4. Parse task plan from Claude output
-      const taskPlanJsonStr = this.extractTaskPlanFromOutput(response.result);
-      const taskPlanJson = JSON.parse(taskPlanJsonStr);
+      // 4. Read task plan from file (not from stdout)
+      let taskPlanJsonStr: string;
+      try {
+        taskPlanJsonStr = await readFile(taskPlanFilePath, "utf-8");
+        this.logger.info({ fileLength: taskPlanJsonStr.length }, "Read task_plan.json from file");
+      } catch (fileError) {
+        // Fallback: try extracting JSON from stdout (backward compatibility)
+        this.logger.warn({ fileError }, "task_plan.json file not found, falling back to stdout extraction");
+        taskPlanJsonStr = this.extractTaskPlanFromOutput(response.result);
+      }
+      
+      this.logger.debug({ jsonLength: taskPlanJsonStr.length, jsonPreview: taskPlanJsonStr.slice(0, 500) }, "Extracted JSON");
+      
+      let taskPlanJson;
+      try {
+        taskPlanJson = JSON.parse(taskPlanJsonStr);
+      } catch (parseError) {
+        const errorMsg = parseError instanceof Error ? parseError.message : String(parseError);
+        this.logger.error({ parseError: errorMsg, jsonLength: taskPlanJsonStr.length, jsonSample: taskPlanJsonStr.slice(0, 1000) }, "JSON parse failed");
+        throw new PlanningError(`Failed to parse task plan JSON: ${errorMsg}`, {
+          runId,
+          rawOutput: taskPlanJsonStr.slice(0, 2000),
+        });
+      }
+      
       const taskPlan = parseTaskPlan(taskPlanJson);
 
       this.logger.debug({ taskCount: taskPlan.tasks.length }, "Task plan parsed");
@@ -118,6 +150,9 @@ export class PlanningService {
         error: errorMessage,
       });
       throw error;
+    } finally {
+      // Cleanup temp directory
+      await rm(tempDir, { recursive: true, force: true }).catch(() => {});
     }
   }
 
@@ -130,8 +165,9 @@ export class PlanningService {
     requirementsPath: string;
     targetDocsDir: string;
     projectAnalysis: unknown;
+    taskPlanFilePath: string;
   }): string {
-    const { runId, parentBranch, requirementsPath } = params;
+    const { runId, parentBranch, requirementsPath, taskPlanFilePath } = params;
 
     const taskPlanFormat = JSON.stringify(
       {
@@ -140,10 +176,10 @@ export class PlanningService {
         tasks: [
           {
             task_id: "task-001",
-            title: "タスクのタイトル",
-            description: "詳細な説明",
+            title: "Task title",
+            description: "Detailed description",
             files_to_modify: ["file1.js", "file2.js"],
-            depends_on: ["task-000"],
+            depends_on: [],
             priority: 1,
           },
         ],
@@ -152,48 +188,33 @@ export class PlanningService {
       2
     );
 
-    if (this.config.teams.splitter) {
-      // Teams mode: subagents handle analysis, main agent integrates
-      return `splitterエージェントとして、サブエージェントの分析結果を統合し、要件をタスクに分割してください。
-
-サブエージェント（codebase-analyzer, requirement-analyzer, dependency-mapper）が自動的に並列分析を行います。
-それぞれの結果を統合して、最終的なタスクプランを作成してください。
+    // File-write based approach: Claude writes task_plan.json to a specific path.
+    // This avoids JSON parsing issues from stdout where conversational text gets mixed in.
+    // Same pattern as the proven shell script version (.aad/scripts/run-parallel.sh).
+    const basePrompt = `You are a task splitter agent. Analyze the requirements and split them into tasks.
 
-要件: ${requirementsPath}
-Run ID: ${runId}
-親ブランチ: ${parentBranch}
-
-以下の手順を実行してください:
-1. サブエージェントの分析結果を統合する
-2. タスクに分割し、以下のJSON形式で標準出力に出力してください（ファイル生成ではなく、コンソールに直接出力）:
-   ${taskPlanFormat}
-3. 各タスクの files_to_modify を明確にする
-4. 依存関係 (depends_on) を設定する
-   ⚠️  重要: 同じファイルを変更する複数のタスクがある場合、必ず後のタスクを前のタスクに依存させてください
-   これにより、ファイル衝突を防ぎます
-5. priority を設定する
-
-⚠️  重要: 最終的な出力は、上記のJSON形式のみを標準出力に出力してください。説明文やコードブロック記法（\`\`\`）は不要です。`;
-    } else {
-      // Solo mode: traditional prompt
-      return `splitterエージェントとして、以下の要件を分割してください:
-
-要件: ${requirementsPath}
+Requirements file: ${requirementsPath}
 Run ID: ${runId}
-親ブランチ: ${parentBranch}
-
-以下の手順を実行してください:
-1. 要件ファイル/ディレクトリを読み込む（ディレクトリの場合は配下のファイルを全て読む）
-2. タスクに分割し、以下のJSON形式で標準出力に出力してください（ファイル生成ではなく、コンソールに直接出力）:
-   ${taskPlanFormat}
-3. 各タスクの files_to_modify を明確にする
-4. 依存関係 (depends_on) を設定する
-   ⚠️  重要: 同じファイルを変更する複数のタスクがある場合、必ず後のタスクを前のタスクに依存させてください
-   これにより、ファイル衝突を防ぎます
-5. priority を設定する
-
-⚠️  重要: 最終的な出力は、上記のJSON形式のみを標準出力に出力してください。説明文やコードブロック記法（\`\`\`）は不要です。`;
-    }
+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)
+4. Set priority (1 = highest)
+5. CRITICAL: Write the result as a JSON file to the following path:
+   ${taskPlanFilePath}
+
+The JSON file MUST follow this exact format:
+${taskPlanFormat}
+
+IMPORTANT:
+- Use the Write tool to write the JSON to ${taskPlanFilePath}
+- The file must contain ONLY valid JSON (no markdown, no explanation)
+- Use "task_id" (not "id") for task identifiers
+- After writing the file, confirm that you have written it`;
+
+    return basePrompt;
   }
 
   /**
@@ -241,7 +262,7 @@ Run ID: ${runId}
       JSON.parse(output);
       return output;
     } catch {
-      // Not valid JSON, try to extract from markdown code block
+      // Not valid JSON, try extraction strategies
     }
 
     // Try to extract from ```json ... ``` block
@@ -256,6 +277,37 @@ Run ID: ${runId}
       return codeBlockMatch[1];
     }
 
+    // Try to find JSON object starting with { and ending with }
+    const jsonObjectMatch = output.match(/\{[\s\S]*"tasks"\s*:\s*\[[\s\S]*\]\s*\}/);
+    if (jsonObjectMatch) {
+      try {
+        JSON.parse(jsonObjectMatch[0]);
+        return jsonObjectMatch[0];
+      } catch {
+        // Not valid JSON, continue
+      }
+    }
+
+    // Try to find the last JSON-like block (Claude often adds explanation before JSON)
+    const lastBraceIndex = output.lastIndexOf("}");
+    if (lastBraceIndex !== -1) {
+      // Find the matching opening brace
+      let depth = 0;
+      for (let i = lastBraceIndex; i >= 0; i--) {
+        if (output[i] === "}") depth++;
+        if (output[i] === "{") depth--;
+        if (depth === 0) {
+          const candidate = output.slice(i, lastBraceIndex + 1);
+          try {
+            JSON.parse(candidate);
+            return candidate;
+          } catch {
+            break;
+          }
+        }
+      }
+    }
+
     // Return as-is and let parseTaskPlan handle validation
     return output;
   }

package/src/shared/__tests__/memory-check.test.ts

@@ -0,0 +1,91 @@
+import { describe, test, expect, mock } from "bun:test";
+import { waitForMemory, type MemoryStatus } from "../memory-check";
+import { MemoryError } from "../errors";
+import { pino } from "pino";
+
+const logger = pino({ level: "silent" });
+
+function mockStatus(freeGB: number): MemoryStatus {
+  return {
+    totalGB: 16,
+    usedGB: 16 - freeGB,
+    freeGB,
+    usedPercent: Math.round(((16 - freeGB) / 16) * 100),
+    isLowMemory: freeGB < 2.0,
+  };
+}
+
+describe("waitForMemory", () => {
+  test("returns immediately when memory is sufficient", async () => {
+    const getStatus = mock(async () => mockStatus(8.0));
+    const sleep = mock(async () => {});
+
+    const result = await waitForMemory(logger, {}, getStatus, sleep);
+
+    expect(result.shouldReduceWorkers).toBe(false);
+    expect(result.freeGB).toBe(8.0);
+    expect(sleep).not.toHaveBeenCalled();
+  });
+
+  test("returns shouldReduceWorkers=true when freeGB < 3.0", async () => {
+    const getStatus = mock(async () => mockStatus(2.5));
+    const sleep = mock(async () => {});
+
+    const result = await waitForMemory(logger, {}, getStatus, sleep);
+
+    expect(result.shouldReduceWorkers).toBe(true);
+    expect(result.freeGB).toBe(2.5);
+  });
+
+  test("waits and retries when freeGB < 1.5", async () => {
+    let callCount = 0;
+    const getStatus = mock(async () => {
+      callCount++;
+      // First 2 calls: low memory, then recover
+      return mockStatus(callCount <= 2 ? 1.0 : 4.0);
+    });
+    const sleep = mock(async () => {});
+
+    const result = await waitForMemory(logger, { retryIntervalMs: 100 }, getStatus, sleep);
+
+    expect(sleep).toHaveBeenCalledTimes(2);
+    expect(result.shouldReduceWorkers).toBe(false);
+    expect(result.freeGB).toBe(4.0);
+  });
+
+  test("throws MemoryError when memory stays below 1.0GB after all retries", async () => {
+    const getStatus = mock(async () => mockStatus(0.5));
+    const sleep = mock(async () => {});
+
+    await expect(
+      waitForMemory(logger, { maxRetries: 3, retryIntervalMs: 10 }, getStatus, sleep),
+    ).rejects.toThrow(MemoryError);
+
+    expect(sleep).toHaveBeenCalledTimes(3);
+  });
+
+  test("does not throw when memory is between 1.0 and 1.5 after retries", async () => {
+    let callCount = 0;
+    const getStatus = mock(async () => {
+      callCount++;
+      return mockStatus(callCount <= 5 ? 1.2 : 1.2); // stays at 1.2 - above 1.0 threshold
+    });
+    const sleep = mock(async () => {});
+
+    const result = await waitForMemory(logger, { maxRetries: 5, retryIntervalMs: 10 }, getStatus, sleep);
+
+    // 1.2 < 3.0 so shouldReduceWorkers
+    expect(result.shouldReduceWorkers).toBe(true);
+    expect(sleep).toHaveBeenCalledTimes(5);
+  });
+
+  test("uses custom minFreeGB option", async () => {
+    const getStatus = mock(async () => mockStatus(2.0));
+    const sleep = mock(async () => {});
+
+    const result = await waitForMemory(logger, { minFreeGB: 1.0 }, getStatus, sleep);
+
+    expect(sleep).not.toHaveBeenCalled();
+    expect(result.shouldReduceWorkers).toBe(true);
+  });
+});