create-walle 0.9.3 → 0.9.4

package/template/wall-e/coding-orchestrator.js

@@ -0,0 +1,625 @@
+'use strict';
+const fs = require('node:fs');
+const path = require('node:path');
+const crypto = require('node:crypto');
+const { spawn, execFile } = require('node:child_process');
+const { promisify } = require('node:util');
+
+const execFileAsync = promisify(execFile);
+
+const codingContext = require('./coding-context');
+const codingReview = require('./coding-review');
+
+const MAX_CUMULATIVE_CONTEXT = 4000;
+const MAX_DIFF_SIZE = 50 * 1024; // 50KB
+
+// ─── Pure/unit-testable functions ────────────────────────────────────────────
+
+/**
+ * Returns default config object.
+ */
+function getDefaultConfig() {
+  return {
+    delivery: 'commit',
+    max_retries: 3,
+    max_subtasks: 15,
+    guardrail_threshold: 10,
+    subtask_timeout_ms: 300000,
+    subtask_budget_usd: 0.50,
+    total_budget_usd: 5.00,
+    test_command: 'auto',
+    review: true,
+  };
+}
+
+/**
+ * Builds the prompt sent to Claude for planning.
+ */
+function buildPlanningPrompt(request, context, options = {}) {
+  const maxSubtasks = options.max_subtasks || getDefaultConfig().max_subtasks;
+
+  const sections = [];
+
+  sections.push(`You are a senior software engineer planning a coding task. Break the request into subtasks that can each be executed as an independent Claude Code session.
+
+## Request
+${request}`);
+
+  if (context.claudeMd) {
+    sections.push(`## Project Conventions (CLAUDE.md)
+${context.claudeMd}`);
+  }
+
+  if (context.fileTree) {
+    sections.push(`## File Tree
+${context.fileTree}`);
+  }
+
+  if (context.gitLog) {
+    sections.push(`## Recent Commits
+${context.gitLog}`);
+  }
+
+  if (context.relevantFiles && Object.keys(context.relevantFiles).length > 0) {
+    const fileEntries = Object.entries(context.relevantFiles)
+      .map(([name, content]) => `### ${name}\n\`\`\`\n${content}\n\`\`\``)
+      .join('\n\n');
+    sections.push(`## Relevant Source Files
+${fileEntries}`);
+  }
+
+  if (context.brainMemories && context.brainMemories.length > 0) {
+    const memories = context.brainMemories
+      .map(m => `- ${m.content || JSON.stringify(m)}`)
+      .join('\n');
+    sections.push(`## Past Decisions (from memory)
+${memories}`);
+  }
+
+  if (context.mcpResults && context.mcpResults.length > 0) {
+    const results = context.mcpResults
+      .map(r => `- [${r.tool}]: ${typeof r.result === 'string' ? r.result : JSON.stringify(r.result)}`)
+      .join('\n');
+    sections.push(`## Related Specs (MCP)
+${results}`);
+  }
+
+  if (context.testCommand) {
+    sections.push(`## Test Command
+${context.testCommand}`);
+  }
+
+  sections.push(`## Instructions
+Output JSON with the following structure (no other text outside the JSON):
+{
+  "subtasks": [
+    { "title": "Short title", "prompt": "Detailed prompt for this subtask" }
+  ],
+  "branch_name": "type/short-description",
+  "estimated_scope": "small|medium|large"
+}
+
+Rules:
+- Maximum ${maxSubtasks} subtasks
+- Each subtask should be independently executable
+- Order subtasks so dependencies come first
+- Include test-writing subtasks where appropriate
+- branch_name should follow conventional naming (feat/, fix/, refactor/, etc.)`);
+
+  return sections.join('\n\n');
+}
+
+/**
+ * Extracts plan JSON from Claude's text output.
+ */
+function parsePlan(output) {
+  if (!output) {
+    throw new Error('Failed to parse plan: empty output');
+  }
+
+  // Try to find JSON with subtasks array
+  // First try: look for ```json ... ``` blocks
+  const fencedMatch = output.match(/```(?:json)?\s*\n?([\s\S]*?)\n?```/);
+  if (fencedMatch) {
+    try {
+      const parsed = JSON.parse(fencedMatch[1]);
+      if (Array.isArray(parsed.subtasks) && parsed.subtasks.length > 0) {
+        return parsed;
+      }
+    } catch {
+      // fall through to other methods
+    }
+  }
+
+  // Second try: find JSON by locating the opening brace before "subtasks"
+  // and the matching closing brace (balanced brace counting)
+  const subtasksIdx = output.indexOf('"subtasks"');
+  if (subtasksIdx !== -1) {
+    let start = output.lastIndexOf('{', subtasksIdx);
+    while (start >= 0) {
+      // Find matching closing brace
+      let depth = 0;
+      let end = -1;
+      for (let i = start; i < output.length; i++) {
+        if (output[i] === '{') depth++;
+        else if (output[i] === '}') { depth--; if (depth === 0) { end = i; break; } }
+      }
+      if (end > start) {
+        try {
+          const parsed = JSON.parse(output.slice(start, end + 1));
+          if (Array.isArray(parsed.subtasks) && parsed.subtasks.length > 0) {
+            return parsed;
+          }
+        } catch {
+          // Not valid from here
+        }
+      }
+      start = output.lastIndexOf('{', start - 1);
+    }
+  }
+
+  throw new Error('Failed to parse plan: no valid JSON with non-empty subtasks array found');
+}
+
+/**
+ * Builds prompt for executing a single subtask.
+ */
+function buildSubtaskPrompt(subtask, cumulativeContext, claudeMd) {
+  const sections = [];
+
+  if (claudeMd) {
+    sections.push(`## Project Conventions (CLAUDE.md)
+${claudeMd}`);
+  }
+
+  if (cumulativeContext) {
+    sections.push(`## Context from Previous Steps
+${cumulativeContext}`);
+  }
+
+  sections.push(`## Current Subtask: ${subtask.title}
+${subtask.prompt}`);
+
+  sections.push(`## Instructions
+- Implement the subtask described above
+- Follow project conventions
+- Write clean, well-documented code
+- If tests are relevant, ensure they pass`);
+
+  return sections.join('\n\n');
+}
+
+/**
+ * Writes state object to JSON file.
+ */
+function writeCheckpoint(filePath, state) {
+  fs.writeFileSync(filePath, JSON.stringify(state, null, 2), 'utf8');
+}
+
+/**
+ * Reads and parses JSON state file.
+ */
+function readCheckpoint(filePath) {
+  const raw = fs.readFileSync(filePath, 'utf8');
+  return JSON.parse(raw);
+}
+
+/**
+ * Formats a report object as human-readable string.
+ */
+function formatReport(report) {
+  const lines = [];
+
+  lines.push(`Status: ${report.success ? 'SUCCESS' : 'FAILED'}`);
+
+  if (report.branch) {
+    lines.push(`Branch: ${report.branch}`);
+  }
+
+  if (report.commit) {
+    lines.push(`Commit: ${report.commit}`);
+  }
+
+  if (report.error) {
+    lines.push(`Error: ${report.error}`);
+  }
+
+  if (report.concerns && report.concerns.length > 0) {
+    lines.push('Concerns:');
+    for (const concern of report.concerns) {
+      lines.push(`  - ${concern}`);
+    }
+  }
+
+  if (report.summary) {
+    lines.push(`Summary: ${report.summary}`);
+  }
+
+  return lines.join('\n');
+}
+
+// ─── Integration functions ───────────────────────────────────────────────────
+
+/**
+ * Spawns `claude -p <prompt>` as a headless session.
+ */
+function runHeadless(prompt, { cwd, sessionId, timeoutMs, budgetUsd } = {}) {
+  const sid = sessionId || crypto.randomUUID();
+
+  return new Promise((resolve) => {
+    const args = [
+      '-p', prompt,
+      '--output-format', 'json',
+      '--max-turns', '50',
+      '--session-id', sid,
+    ];
+    if (budgetUsd) {
+      args.push('--max-budget-usd', String(budgetUsd));
+    }
+
+    let proc;
+    try {
+      proc = spawn('claude', args, {
+        cwd: cwd || process.cwd(),
+        stdio: ['ignore', 'pipe', 'pipe'],
+        timeout: timeoutMs || 300000,
+      });
+    } catch (err) {
+      return resolve({
+        success: false,
+        output: '',
+        stderr: err.message,
+        sessionId: sid,
+        exitCode: -1,
+      });
+    }
+
+    const MAX_OUTPUT = 512 * 1024; // 512KB cap
+    let stdout = '';
+    let stderr = '';
+
+    proc.stdout.on('data', (chunk) => {
+      if (stdout.length < MAX_OUTPUT) stdout += chunk;
+    });
+    proc.stderr.on('data', (chunk) => {
+      if (stderr.length < MAX_OUTPUT) stderr += chunk;
+    });
+
+    proc.on('error', (err) => {
+      resolve({
+        success: false,
+        output: stdout,
+        stderr: err.message,
+        sessionId: sid,
+        exitCode: -1,
+      });
+    });
+
+    proc.on('close', (code) => {
+      resolve({
+        success: code === 0,
+        output: stdout,
+        stderr,
+        sessionId: sid,
+        exitCode: code,
+      });
+    });
+  });
+}
+
+/**
+ * Runs test command. Returns { success, output }.
+ */
+async function runTests(cwd, testCommand) {
+  try {
+    const { stdout, stderr } = await execFileAsync(testCommand, [], {
+      cwd,
+      shell: true,
+      timeout: 120000,
+    });
+    return { success: true, output: (stdout || '') + (stderr || '') };
+  } catch (e) {
+    return { success: false, output: ((e.stdout || '') + (e.stderr || '')) };
+  }
+}
+
+/**
+ * Gets diff for review. Checks unstaged, staged, and committed. Cap at 50KB.
+ */
+async function getGitDiff(cwd) {
+  // Try unstaged
+  try {
+    const { stdout } = await execFileAsync('git', ['diff'], { cwd });
+    if (stdout.trim()) return stdout.slice(0, MAX_DIFF_SIZE);
+  } catch { /* ignore */ }
+
+  // Try staged
+  try {
+    const { stdout } = await execFileAsync('git', ['diff', '--cached'], { cwd });
+    if (stdout.trim()) return stdout.slice(0, MAX_DIFF_SIZE);
+  } catch { /* ignore */ }
+
+  // Try committed
+  try {
+    const { stdout } = await execFileAsync('git', ['diff', 'HEAD~1', 'HEAD'], { cwd });
+    if (stdout.trim()) return stdout.slice(0, MAX_DIFF_SIZE);
+  } catch { /* ignore */ }
+
+  return '';
+}
+
+/**
+ * Assembles context, builds planning prompt, runs headless Claude, parses plan.
+ */
+async function plan(request, cwd, options = {}) {
+  const config = { ...getDefaultConfig(), ...options };
+
+  // Assemble context
+  const context = await codingContext.assembleContext(request, cwd, {
+    brain: options.brain,
+    mcpClient: options.mcpClient,
+  });
+
+  // Resolve test command
+  if (config.test_command === 'auto') {
+    config.test_command = context.testCommand || null;
+  }
+
+  // Build planning prompt
+  const prompt = buildPlanningPrompt(request, context, { max_subtasks: config.max_subtasks });
+
+  // Run headless Claude for planning
+  const result = await runHeadless(prompt, {
+    cwd,
+    timeoutMs: config.subtask_timeout_ms,
+    budgetUsd: config.subtask_budget_usd,
+  });
+
+  if (!result.success && !result.output) {
+    throw new Error(`Planning failed: ${result.stderr || 'no output'}`);
+  }
+
+  // Parse plan from output
+  const planObj = parsePlan(result.output);
+
+  // Enforce max_subtasks
+  if (planObj.subtasks.length > config.max_subtasks) {
+    planObj.subtasks = planObj.subtasks.slice(0, config.max_subtasks);
+  }
+
+  return { plan: planObj, context, config };
+}
+
+/**
+ * Main execution loop. For each subtask: build prompt, run headless, verify, checkpoint.
+ */
+async function execute(planData, { cwd, onProgress, startFrom = 0 } = {}) {
+  const { plan: planObj, context, config } = planData;
+  const subtasks = planObj.subtasks;
+  const sessionIds = [];
+  const statePath = path.join(cwd, `.coding-orchestrator-state-${Date.now()}.json`);
+  let budgetUsed = 0;
+  let cumulativeContext = '';
+
+  // Create or switch to branch
+  try {
+    await execFileAsync('git', ['checkout', '-b', planObj.branch_name], { cwd });
+  } catch {
+    try {
+      await execFileAsync('git', ['checkout', planObj.branch_name], { cwd });
+    } catch {
+      // Already on the branch or no git — continue anyway
+    }
+  }
+
+  for (let i = startFrom; i < subtasks.length; i++) {
+    const subtask = subtasks[i];
+
+    if (onProgress) {
+      onProgress({ type: 'subtask_start', index: i, title: subtask.title });
+    }
+
+    // Budget guard
+    if (budgetUsed >= config.total_budget_usd) {
+      return {
+        success: false,
+        completed: i,
+        session_ids: sessionIds,
+        state_path: statePath,
+        error: 'Budget exceeded',
+        failed_subtask: i,
+      };
+    }
+
+    let succeeded = false;
+    let lastError = '';
+
+    for (let retry = 0; retry <= config.max_retries; retry++) {
+      // Build subtask prompt
+      const cappedContext = cumulativeContext.length > MAX_CUMULATIVE_CONTEXT
+        ? cumulativeContext.slice(-MAX_CUMULATIVE_CONTEXT)
+        : cumulativeContext;
+
+      const prompt = buildSubtaskPrompt(subtask, cappedContext, context.claudeMd);
+
+      // Run headless
+      const result = await runHeadless(prompt, {
+        cwd,
+        timeoutMs: config.subtask_timeout_ms,
+        budgetUsd: config.subtask_budget_usd,
+      });
+
+      sessionIds.push(result.sessionId);
+      budgetUsed += config.subtask_budget_usd;
+
+      if (!result.success && !result.output) {
+        lastError = `Headless session failed: ${result.stderr || 'no output'}`;
+        if (onProgress) onProgress({ type: 'retry', index: i, retry, error: lastError });
+        continue;
+      }
+
+      // Run tests if configured
+      let testsOk = true;
+      if (config.test_command) {
+        const testResult = await runTests(cwd, config.test_command);
+        if (!testResult.success) {
+          lastError = `Tests failed: ${testResult.output.slice(0, 500)}`;
+          if (onProgress) onProgress({ type: 'retry', index: i, retry, error: lastError });
+          testsOk = false;
+        }
+      }
+
+      // Review if configured
+      let reviewOk = true;
+      if (config.review && testsOk) {
+        const diff = await getGitDiff(cwd);
+        if (diff) {
+          const verdict = await codingReview.reviewSubtask(subtask, diff, { cwd });
+          if (!verdict.pass && verdict.severity === 'blocker') {
+            lastError = `Review failed: ${verdict.issues.join(', ')}`;
+            if (onProgress) onProgress({ type: 'retry', index: i, retry, error: lastError });
+            reviewOk = false;
+          }
+        }
+      }
+
+      if (testsOk && reviewOk) {
+        succeeded = true;
+        // Update cumulative context
+        cumulativeContext += `\n[Step ${i + 1}: ${subtask.title}] Completed. Output: ${(result.output || '').slice(0, 200)}`;
+        break;
+      }
+    }
+
+    // Checkpoint
+    const state = {
+      plan: planObj,
+      completed: succeeded ? i + 1 : i,
+      session_ids: sessionIds,
+      budget_used: budgetUsed,
+      cumulative_context: cumulativeContext,
+    };
+    writeCheckpoint(statePath, state);
+
+    if (!succeeded) {
+      if (onProgress) onProgress({ type: 'subtask_failed', index: i, error: lastError });
+      return {
+        success: false,
+        completed: i,
+        session_ids: sessionIds,
+        state_path: statePath,
+        error: lastError,
+        failed_subtask: i,
+      };
+    }
+
+    if (onProgress) {
+      onProgress({ type: 'subtask_done', index: i, title: subtask.title });
+    }
+  }
+
+  return {
+    success: true,
+    completed: subtasks.length,
+    session_ids: sessionIds,
+    state_path: statePath,
+  };
+}
+
+/**
+ * Final review, git commit, store memory, cleanup.
+ */
+async function complete(request, planData, executeResult, { cwd, brain, onProgress } = {}) {
+  const { plan: planObj, config } = planData;
+  const report = {
+    success: executeResult.success,
+    branch: planObj.branch_name,
+    commit: null,
+    concerns: [],
+    summary: '',
+  };
+
+  if (!executeResult.success) {
+    report.error = executeResult.error;
+    return report;
+  }
+
+  // Final review
+  if (config.review) {
+    if (onProgress) onProgress({ type: 'final_review' });
+    const diff = await getGitDiff(cwd);
+    if (diff) {
+      const verdict = await codingReview.reviewFinal(request, diff, { cwd });
+      report.concerns = verdict.issues || [];
+      report.summary = verdict.summary || '';
+      if (!verdict.pass && verdict.severity === 'blocker') {
+        report.success = false;
+        report.error = 'Final review found blocker issues';
+        return report;
+      }
+    }
+  }
+
+  // Git commit
+  if (config.delivery === 'commit' || config.delivery === 'push' || config.delivery === 'pr') {
+    try {
+      await execFileAsync('git', ['add', '-A'], { cwd });
+      const sanitizedRequest = request.replace(/[\r\n]+/g, ' ').trim().slice(0, 72);
+      const commitMsg = `feat: ${sanitizedRequest}\n\nOrchestrated by Wall-E coding agent.\nSubtasks: ${planObj.subtasks.length}`;
+      const { stdout } = await execFileAsync('git', ['commit', '-m', commitMsg], { cwd });
+      // Extract commit hash
+      const hashMatch = stdout.match(/\[[\w/.-]+ ([a-f0-9]+)\]/);
+      if (hashMatch) report.commit = hashMatch[1];
+    } catch (e) {
+      report.concerns.push(`Git commit failed: ${(e.stderr || e.message || '').slice(0, 200)}`);
+    }
+  }
+
+  // Store memory in brain
+  if (brain && typeof brain.storeMemory === 'function') {
+    try {
+      await brain.storeMemory({
+        type: 'coding_task',
+        content: `Completed coding task: ${request}. Branch: ${planObj.branch_name}. Subtasks: ${planObj.subtasks.length}.`,
+        metadata: {
+          branch: planObj.branch_name,
+          subtasks: planObj.subtasks.length,
+          success: report.success,
+        },
+      });
+    } catch {
+      // non-critical
+    }
+  }
+
+  // Cleanup state file
+  if (executeResult.state_path) {
+    try {
+      fs.unlinkSync(executeResult.state_path);
+    } catch {
+      // non-critical
+    }
+  }
+
+  if (onProgress) onProgress({ type: 'complete', report });
+
+  return report;
+}
+
+module.exports = {
+  // Pure/unit-testable
+  getDefaultConfig,
+  buildPlanningPrompt,
+  parsePlan,
+  buildSubtaskPrompt,
+  writeCheckpoint,
+  readCheckpoint,
+  formatReport,
+  // Integration
+  runHeadless,
+  runTests,
+  getGitDiff,
+  plan,
+  execute,
+  complete,
+};