claudeboard 2.3.0 → 2.8.0

package/agents/claude-api.js

@@ -4,7 +4,7 @@
  */
 
 const MODEL = "claude-sonnet-4-20250514";
-const MAX_TOKENS = 16000; // Increased — large codegen responses need more tokens
+const MAX_TOKENS = 8096; // Max output tokens — input context window is 200k, no limits there
 
 function getHeaders() {
   const key = process.env.ANTHROPIC_API_KEY;

package/agents/expo-health.js

@@ -0,0 +1,240 @@
+import { callClaude } from "./claude-api.js";
+import { runCommand } from "../tools/terminal.js";
+import { startProcess, waitForPort } from "../tools/terminal.js";
+import chalk from "chalk";
+import fs from "fs";
+import path from "path";
+import { createRequire } from "module";
+
+const require = createRequire(import.meta.url);
+
+const MAX_FIX_ATTEMPTS = 3;
+
+/**
+ * Expo Health Check Agent
+ * Runs before development loop starts.
+ * 1. Install deps
+ * 2. Try to start Expo
+ * 3. If it crashes, read the error and fix it (up to 3 attempts)
+ * 4. Return { ready: true/false, process, port }
+ */
+export async function runExpoHealthCheck(projectPath, port = 8081) {
+  console.log(chalk.bold.cyan("\n[ EXPO HEALTH CHECK ]\n"));
+
+  if (!fs.existsSync(path.join(projectPath, "package.json"))) {
+    console.log(chalk.dim("  No package.json found — skipping Expo health check"));
+    return { ready: false, process: null };
+  }
+
+  // ── Step 1: Install dependencies ──────────────────────────────────────────
+  console.log(chalk.dim("  Installing dependencies (--legacy-peer-deps)..."));
+  const installResult = await runCommand(
+    "npm install --legacy-peer-deps 2>&1",
+    projectPath,
+    120000
+  );
+  const installErrors = extractNpmErrors(installResult.stdout);
+  if (installErrors) {
+    console.log(chalk.yellow(`  ⚠ npm install issues detected:\n${installErrors}`));
+    // Try to fix install errors before continuing
+    const fixed = await fixInstallErrors(projectPath, installErrors);
+    if (!fixed) {
+      console.log(chalk.red("  ✗ Could not fix install errors — continuing without Expo"));
+      return { ready: false, process: null };
+    }
+  }
+  console.log(chalk.dim("  ✓ Dependencies installed"));
+
+  // ── Step 2: Attempt Expo start with error detection ───────────────────────
+  for (let attempt = 1; attempt <= MAX_FIX_ATTEMPTS; attempt++) {
+    console.log(chalk.dim(`  Starting Expo (attempt ${attempt}/${MAX_FIX_ATTEMPTS})...`));
+
+    const result = await tryStartExpo(projectPath, port);
+
+    if (result.ready) {
+      console.log(chalk.green(`  ✓ Expo running on port ${port}\n`));
+      return { ready: true, process: result.process };
+    }
+
+    const error = result.error;
+    console.log(chalk.yellow(`  ✗ Expo failed to start:\n    ${error?.slice(0, 200)}`));
+
+    if (attempt === MAX_FIX_ATTEMPTS) break;
+
+    // ── Step 3: Ask Claude to fix the error ─────────────────────────────────
+    console.log(chalk.dim(`  Asking Claude to fix the error...`));
+    const fixed = await fixExpoError(projectPath, error);
+
+    if (!fixed) {
+      console.log(chalk.red("  Could not determine fix — skipping Expo"));
+      break;
+    }
+    console.log(chalk.dim(`  Applied fix — retrying...`));
+  }
+
+  console.log(chalk.yellow("  ⚠ Expo not available — continuing without visual QA\n"));
+  return { ready: false, process: null };
+}
+
+// ── Try to start Expo and detect if it crashes or succeeds ─────────────────
+async function tryStartExpo(projectPath, port) {
+  return new Promise((resolve) => {
+    let output = "";
+    let resolved = false;
+    let proc = null;
+
+    const done = (ready, error) => {
+      if (resolved) return;
+      resolved = true;
+      if (!ready && proc) {
+        try { proc.kill(); } catch {}
+        proc = null;
+      }
+      resolve({ ready, process: proc, error });
+    };
+
+    // Collect logs for 20 seconds, then give up if no success
+    const timeout = setTimeout(() => done(false, `Expo did not start within 20s. Last output:\n${output.slice(-500)}`), 20000);
+
+    try {
+      const { spawn } = require("child_process");
+      proc = spawn("npx", ["expo", "start", "--web", "--port", String(port)], {
+        cwd: projectPath,
+        env: {
+          ...process.env,
+          CI: "1",
+          EXPO_NO_INTERACTIVE: "1",
+          EXPO_NO_DOTENV: "0",
+        },
+        stdio: "pipe",
+      });
+
+      proc.stdout.on("data", (d) => {
+        const text = d.toString();
+        output += text;
+        // Success signals
+        if (
+          text.includes("Metro waiting on") ||
+          text.includes(`localhost:${port}`) ||
+          text.includes("Web is waiting") ||
+          text.includes("Bundling complete")
+        ) {
+          clearTimeout(timeout);
+          done(true, null);
+        }
+      });
+
+      proc.stderr.on("data", (d) => {
+        const text = d.toString();
+        output += text;
+        // Fatal crash signals
+        if (
+          text.includes("Unable to resolve module") ||
+          text.includes("Cannot find module") ||
+          text.includes("Error: Cannot") ||
+          text.includes("ENOENT") ||
+          text.includes("SyntaxError")
+        ) {
+          clearTimeout(timeout);
+          // Small delay to collect full error
+          setTimeout(() => done(false, output.slice(-1500)), 1000);
+        }
+      });
+
+      proc.on("close", (code) => {
+        clearTimeout(timeout);
+        if (code !== 0) done(false, `Process exited with code ${code}.\n${output.slice(-1000)}`);
+      });
+
+    } catch (e) {
+      clearTimeout(timeout);
+      done(false, e.message);
+    }
+  });
+}
+
+// ── Ask Claude to diagnose and apply the fix ──────────────────────────────
+async function fixExpoError(projectPath, errorText) {
+  const pkgRaw = fs.readFileSync(path.join(projectPath, "package.json"), "utf8");
+  const pkg = JSON.parse(pkgRaw);
+  const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+
+  const prompt = `You are a React Native / Expo dependency expert.
+
+The app failed to start with this error:
+\`\`\`
+${errorText}
+\`\`\`
+
+Current package.json dependencies:
+\`\`\`json
+${JSON.stringify(deps, null, 2)}
+\`\`\`
+
+Project path: ${projectPath}
+
+Diagnose the root cause and provide the EXACT shell commands to fix it.
+Common fixes:
+- Version conflicts: upgrade/downgrade specific packages
+- Missing modules: npm install <package>
+- Peer dep issues: npm install <pkg>@<compatible-version> --legacy-peer-deps
+- Wrong import paths: patch the source file
+
+Respond with JSON:
+{
+  "diagnosis": "One sentence explanation of the root cause",
+  "commands": ["npm install ...", "..."],
+  "confidence": 0-100
+}`;
+
+  let verdict;
+  try {
+    const { callClaudeJSON } = await import("./claude-api.js");
+    verdict = await callClaudeJSON(
+      "You are a React Native dependency expert. Respond only with valid JSON.",
+      prompt
+    );
+  } catch {
+    return false;
+  }
+
+  if (!verdict?.commands?.length || verdict.confidence < 40) {
+    console.log(chalk.dim(`  Diagnosis: ${verdict?.diagnosis || "unknown"} (confidence: ${verdict?.confidence}%)`));
+    return false;
+  }
+
+  console.log(chalk.dim(`  Diagnosis: ${verdict.diagnosis}`));
+  console.log(chalk.dim(`  Applying ${verdict.commands.length} fix command(s)...`));
+
+  for (const cmd of verdict.commands) {
+    console.log(chalk.dim(`    → ${cmd}`));
+    const result = await runCommand(cmd + " 2>&1", projectPath, 120000);
+    if (result.returncode !== 0) {
+      const errLine = result.stdout.split("\n").find(l => l.includes("error")) || result.stdout.slice(-200);
+      console.log(chalk.yellow(`    ⚠ Command failed: ${errLine}`));
+    }
+  }
+
+  return true;
+}
+
+// ── Fix npm install errors ──────────────────────────────────────────────────
+async function fixInstallErrors(projectPath, errorText) {
+  // Try --force as a last resort for install errors
+  if (errorText.includes("ERESOLVE") || errorText.includes("peer")) {
+    console.log(chalk.dim("  Retrying with --force..."));
+    const result = await runCommand("npm install --force 2>&1", projectPath, 120000);
+    const stillBroken = extractNpmErrors(result.stdout);
+    return !stillBroken;
+  }
+  return false;
+}
+
+// ── Extract real npm errors (ignore peer dep warnings) ─────────────────────
+function extractNpmErrors(output) {
+  const lines = output.split("\n");
+  const errors = lines.filter(l =>
+    l.includes("npm error") && !l.includes("ERESOLVE") && !l.includes("peer")
+  );
+  return errors.length ? errors.join("\n") : null;
+}

package/agents/orchestrator.js

@@ -5,6 +5,18 @@ import path from "path";
 import { runArchitectAgent } from "./architect.js";
 import { runDeveloperAgent } from "./developer.js";
 import { runQAAgent, runFullAppQA } from "./qa.js";
+import { runExpoHealthCheck } from "./expo-health.js";
+import { createConnection } from "net";
+
+function isPortOpen(port) {
+  return new Promise(resolve => {
+    const sock = createConnection({ port, host: "127.0.0.1" });
+    sock.setTimeout(600);
+    sock.once("connect", () => { sock.destroy(); resolve(true); });
+    sock.once("error", () => resolve(false));
+    sock.once("timeout", () => resolve(false));
+  });
+}
 import {
   initBoard,
   getNextTask,
@@ -84,28 +96,11 @@ export async function runOrchestrator(config) {
   const logFile = path.join(projectPath, ".claudeboard-logs.txt");
   const logStream = fs.createWriteStream(logFile, { flags: "a" });
 
-  // Check if expo project exists
-  const hasPackageJson = fs.existsSync(path.join(projectPath, "package.json"));
-
-  if (hasPackageJson) {
-    console.log(chalk.dim("  Starting Expo Web for QA screenshots...\n"));
-    expoProcess = startProcess(
-      "npx",
-      ["expo", "start", "--web", "--port", String(expoPort)],
-      projectPath,
-      (log) => {
-        logStream.write(log);
-        if (log.includes("Metro waiting") || log.includes("localhost:" + expoPort)) {
-          expoReady = true;
-        }
-      }
-    );
-
-    // Wait up to 30s for expo to start
-    await waitForPort(expoPort, 30000);
-    expoReady = true;
-    console.log(chalk.dim(`  Expo Web running at http://localhost:${expoPort}\n`));
-  }
+  // ── EXPO HEALTH CHECK: install deps + start + auto-fix errors ─────────────
+  // Runs before development loop so the app is visible from task #1
+  const expoHealth = await runExpoHealthCheck(projectPath, expoPort);
+  expoReady = expoHealth.ready;
+  expoProcess = expoHealth.process;
 
   // ── PHASE 2: DEVELOPMENT LOOP ─────────────────────────────────────────────
   console.log(chalk.bold.cyan("[ PHASE 2: DEVELOPMENT ]\n"));
@@ -145,6 +140,17 @@ export async function runOrchestrator(config) {
 
     consecutiveFailures = 0;
 
+    // ── Re-check Expo health if it's supposed to be running but isn't ────────
+    if (expoReady) {
+      const portOpen = await isPortOpen(expoPort);
+      if (!portOpen) {
+        console.log(chalk.yellow("  ⚠ Expo seems to have crashed — running health check..."));
+        const recheck = await runExpoHealthCheck(projectPath, expoPort);
+        expoReady = recheck.ready;
+        expoProcess = recheck.process;
+      }
+    }
+
     // Run QA agent (only if expo is running and this is a UI/feature task)
     const shouldRunQA = expoReady && ["feature", "bug"].includes(task.type);