claudeboard 2.8.0 → 2.9.0

package/agents/board-client.js

@@ -54,12 +54,20 @@ export async function addLog(taskId, message, type = "progress") {
 }
 
 export async function createEpic(name) {
+  // Check if epic with this name already exists for this project
+  const { data: existing } = await supabase
+    .from("cb_epics")
+    .select("id")
+    .eq("project", PROJECT)
+    .eq("name", name)
+    .single();
+  if (existing) return existing.id;
   const { data } = await supabase.from("cb_epics").insert({ name, project: PROJECT }).select().single();
-  return data;
+  return data?.id;
 }
 
-export async function createTask({ epicId, title, description, priority = "medium", type = "feature" }) {
-  const priorityOrder = { high: 1, medium: 2, low: 3 };
+export async function createTask({ epicId, title, description, priority = "medium", priorityOrder, type = "feature", status = "todo" }) {
+  const defaultOrder = { high: 1, medium: 2, low: 3 };
   const { data } = await supabase
     .from("cb_tasks")
     .insert({
@@ -68,14 +76,16 @@ export async function createTask({ epicId, title, description, priority = "mediu
       title,
       description,
       priority,
-      priority_order: priorityOrder[priority] || 2,
+      priority_order: priorityOrder ?? defaultOrder[priority] ?? 2,
       type,
-      status: "todo",
+      status,
     })
     .select()
     .single();
   return data;
 }
+  return data;
+}
 
 /**
  * Check if this project already has tasks in the board

package/agents/expo-health.js

@@ -1,82 +1,135 @@
-import { callClaude } from "./claude-api.js";
+import { callClaudeJSON } from "./claude-api.js";
 import { runCommand } from "../tools/terminal.js";
-import { startProcess, waitForPort } from "../tools/terminal.js";
+import { createTask, createEpic, addLog } from "./board-client.js";
 import chalk from "chalk";
 import fs from "fs";
 import path from "path";
 import { createRequire } from "module";
+import { createConnection } from "net";
 
 const require = createRequire(import.meta.url);
-
-const MAX_FIX_ATTEMPTS = 3;
+const MAX_FIX_ATTEMPTS = 5;
 
 /**
- * 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 }
+ * Expo Health Check Agent — runs BEFORE the development loop.
+ *
+ * Strategy:
+ * 1. Try npm install (--legacy-peer-deps, then --force if needed)
+ * 2. If install fails with ETARGET/missing version → ask Claude for fix → apply → retry
+ * 3. Start Expo, wait for Metro to be truly ready (not just port open)
+ * 4. If Metro crashes with module/dep errors → ask Claude → apply → retry
+ * 5. If still broken after MAX attempts → inject a BLOCKER task into the board
+ *    so the developer agent fixes it before any other task runs
+ *
+ * Returns { ready: boolean, process: ChildProcess|null }
  */
 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"));
+    console.log(chalk.dim("  No package.json — skipping"));
     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 };
-    }
+  // ── 1. Install ─────────────────────────────────────────────────────────────
+  const installOk = await installDeps(projectPath);
+  if (!installOk) {
+    await injectFixTask(projectPath, "npm install fails — cannot start Expo",
+      "npm install fails with ETARGET or unresolvable version conflicts. " +
+      "Audit package.json, fix all version constraints to be compatible with " +
+      "the installed Expo SDK, then run npm install --legacy-peer-deps."
+    );
+    console.log(chalk.yellow("  ✗ Install failed — injected fix task into board\n"));
+    return { ready: false, process: null };
   }
-  console.log(chalk.dim("  ✓ Dependencies installed"));
 
-  // ── Step 2: Attempt Expo start with error detection ───────────────────────
+  // ── 2. Start Expo + verify Metro is error-free ─────────────────────────────
   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`));
+      console.log(chalk.green(`  ✓ Expo running cleanly 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)}`));
+    console.log(chalk.yellow(`  ✗ Expo error: ${error?.split("\n")[0]?.slice(0, 120)}`));
 
     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);
+    // Ask Claude for a fix and apply it
+    const fixed = await applyExpoFix(projectPath, error);
+    if (!fixed) break;
+    console.log(chalk.dim("  Fix applied — retrying..."));
+  }
+
+  // All attempts failed — inject task so developer agent fixes it
+  const lastError = await getLastExpoError(projectPath);
+  await injectFixTask(projectPath,
+    "FIX: Expo fails to start — resolve dependency errors",
+    `Expo cannot start due to dependency errors. Fix ALL issues so the app boots without errors.\n\n` +
+    `Last error:\n${lastError}\n\n` +
+    `Steps:\n` +
+    `1. Read package.json and identify incompatible versions\n` +
+    `2. Fix react-native-worklets, react-native-reanimated and any other conflicting packages\n` +
+    `3. Run: npm install --legacy-peer-deps\n` +
+    `4. Verify with: npx expo start --web --port ${port} (should not crash)\n` +
+    `5. If imports fail (Unable to resolve module), remove or replace the problematic import`
+  );
+
+  console.log(chalk.yellow("  ✗ Expo broken — injected fix task (will be worked on first)\n"));
+  return { ready: false, process: null };
+}
 
-    if (!fixed) {
-      console.log(chalk.red("  Could not determine fix — skipping Expo"));
-      break;
+// ── npm install with progressive fallback ─────────────────────────────────
+async function installDeps(projectPath) {
+  const pkg = JSON.parse(fs.readFileSync(path.join(projectPath, "package.json"), "utf8"));
+  const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+
+  // Step 1: legacy-peer-deps
+  console.log(chalk.dim("  npm install --legacy-peer-deps..."));
+  let result = await runCommand("npm install --legacy-peer-deps 2>&1", projectPath, 180000);
+  if (!hasFatalNpmError(result.stdout)) {
+    console.log(chalk.dim("  ✓ Dependencies installed"));
+    return true;
+  }
+
+  const error1 = result.stdout;
+  console.log(chalk.yellow(`  ⚠ Install error: ${getFatalError(error1)}`));
+
+  // Step 2: ask Claude to fix version conflicts
+  console.log(chalk.dim("  Asking Claude to resolve version conflicts..."));
+  const fix = await askClaudeForInstallFix(deps, error1);
+  if (fix?.commands?.length) {
+    console.log(chalk.dim(`  Diagnosis: ${fix.diagnosis}`));
+    for (const cmd of fix.commands) {
+      console.log(chalk.dim(`  → ${cmd}`));
+      await runCommand(cmd + " 2>&1", projectPath, 180000);
+    }
+    // Retry install
+    result = await runCommand("npm install --legacy-peer-deps 2>&1", projectPath, 180000);
+    if (!hasFatalNpmError(result.stdout)) {
+      console.log(chalk.dim("  ✓ Dependencies installed after fix"));
+      return true;
     }
-    console.log(chalk.dim(`  Applied fix — retrying...`));
   }
 
-  console.log(chalk.yellow("  ⚠ Expo not available — continuing without visual QA\n"));
-  return { ready: false, process: null };
+  // Step 3: --force (last resort)
+  console.log(chalk.dim("  Retrying with --force..."));
+  result = await runCommand("npm install --force 2>&1", projectPath, 180000);
+  if (!hasFatalNpmError(result.stdout)) {
+    console.log(chalk.dim("  ✓ Dependencies installed (--force)"));
+    return true;
+  }
+
+  return false;
 }
 
-// ── Try to start Expo and detect if it crashes or succeeds ─────────────────
+// ── Start Expo and wait until Metro is TRULY ready (no errors) ─────────────
+// We wait up to 60s. Success = "Metro waiting on" AND no error lines.
+// Failure = any "Unable to resolve module", "Cannot find module", etc.
 async function tryStartExpo(projectPath, port) {
   return new Promise((resolve) => {
     let output = "";
@@ -86,64 +139,64 @@ async function tryStartExpo(projectPath, port) {
     const done = (ready, error) => {
       if (resolved) return;
       resolved = true;
-      if (!ready && proc) {
-        try { proc.kill(); } catch {}
-        proc = null;
-      }
+      if (!ready && proc) { try { proc.kill(); } catch {} proc = null; }
+      // Save error for later
+      if (!ready && error) saveLastError(projectPath, error);
       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);
+    const timeout = setTimeout(() =>
+      done(false, `Expo did not become ready within 60s.\n${output.slice(-800)}`), 60000);
 
     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",
-        },
+        env: { ...process.env, CI: "1", EXPO_NO_INTERACTIVE: "1", EXPO_NO_DOTENV: "0" },
         stdio: "pipe",
       });
 
+      const checkError = (text) => {
+        if (
+          text.includes("Unable to resolve module") ||
+          text.includes("Cannot find module") ||
+          text.includes("Error: Unable") ||
+          text.includes("Module not found") ||
+          text.includes("SyntaxError") ||
+          text.includes("ENOENT: no such file")
+        ) {
+          clearTimeout(timeout);
+          setTimeout(() => done(false, output.slice(-2000)), 1500); // collect full error
+        }
+      };
+
       proc.stdout.on("data", (d) => {
         const text = d.toString();
         output += text;
-        // Success signals
+        // Metro ready signal — but wait 3s to make sure no errors follow
         if (
           text.includes("Metro waiting on") ||
-          text.includes(`localhost:${port}`) ||
-          text.includes("Web is waiting") ||
-          text.includes("Bundling complete")
+          text.includes(`http://localhost:${port}`) ||
+          text.includes("Bundling complete") ||
+          text.includes("Web is waiting on")
         ) {
-          clearTimeout(timeout);
-          done(true, null);
+          setTimeout(() => {
+            // If we haven't already failed, declare success
+            if (!resolved) { clearTimeout(timeout); done(true, null); }
+          }, 3000);
         }
+        checkError(text);
       });
 
       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);
-        }
+        checkError(text);
       });
 
       proc.on("close", (code) => {
         clearTimeout(timeout);
-        if (code !== 0) done(false, `Process exited with code ${code}.\n${output.slice(-1000)}`);
+        if (!resolved) done(false, `Expo exited (code ${code})\n${output.slice(-1000)}`);
       });
 
     } catch (e) {
@@ -153,88 +206,106 @@ async function tryStartExpo(projectPath, port) {
   });
 }
 
-// ── 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);
+// ── Ask Claude how to fix a runtime Expo error ────────────────────────────
+async function applyExpoFix(projectPath, errorText) {
+  const pkg = JSON.parse(fs.readFileSync(path.join(projectPath, "package.json"), "utf8"));
   const deps = { ...pkg.dependencies, ...pkg.devDependencies };
 
-  const prompt = `You are a React Native / Expo dependency expert.
-
-The app failed to start with this error:
+  let verdict;
+  try {
+    verdict = await callClaudeJSON(
+      "You are a React Native / Expo dependency expert. Respond only with valid JSON.",
+      `Expo failed to start with this error:
 \`\`\`
 ${errorText}
 \`\`\`
 
-Current package.json dependencies:
-\`\`\`json
+Current dependencies:
 ${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
+Provide the exact commands to fix this. 
+For "Unable to resolve module X from file Y": the fix is usually to install the missing package or fix its version.
+For react-native-worklets version conflict: install react-native-worklets@latest.
 
 Respond with JSON:
 {
-  "diagnosis": "One sentence explanation of the root cause",
+  "diagnosis": "one sentence",
   "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;
-  }
+  } catch { return false; }
 
-  if (!verdict?.commands?.length || verdict.confidence < 40) {
-    console.log(chalk.dim(`  Diagnosis: ${verdict?.diagnosis || "unknown"} (confidence: ${verdict?.confidence}%)`));
-    return false;
-  }
+  if (!verdict?.commands?.length || verdict.confidence < 30) 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}`));
-    }
+    console.log(chalk.dim(`  → ${cmd}`));
+    await runCommand(cmd + " 2>&1", projectPath, 120000);
   }
-
   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;
+// ── Ask Claude how to fix npm install failures ────────────────────────────
+async function askClaudeForInstallFix(deps, errorText) {
+  try {
+    return await callClaudeJSON(
+      "You are a React Native dependency expert. Respond only with valid JSON.",
+      `npm install failed:
+${errorText}
+
+Dependencies: ${JSON.stringify(deps, null, 2)}
+
+Provide exact commands to resolve the version conflict.
+For ETARGET (version not found): suggest the nearest valid version.
+For peer dep conflicts: suggest compatible versions for all conflicting packages.
+
+JSON: { "diagnosis": "...", "commands": ["..."], "confidence": 0-100 }`
+    );
+  } catch { return null; }
+}
+
+// ── Create a high-priority fix task in the board ──────────────────────────
+async function injectFixTask(projectPath, title, description) {
+  try {
+    // Make sure the epic exists
+    const epicId = await createEpic("⚠ Expo Fix Required", "expo-fix");
+    await createTask({
+      epicId,
+      title,
+      description,
+      priority: "high",
+      priorityOrder: 0, // Run FIRST
+      type: "bug",
+      status: "todo",
+    });
+    console.log(chalk.yellow(`  ➕ Injected task: "${title}"`));
+  } catch (e) {
+    console.log(chalk.dim(`  Could not inject task: ${e.message}`));
   }
-  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;
+// ── Save/read last error to disk for later reference ─────────────────────
+function saveLastError(projectPath, error) {
+  try {
+    fs.writeFileSync(path.join(projectPath, ".claudeboard-expo-error.txt"), error, "utf8");
+  } catch {}
+}
+
+async function getLastExpoError(projectPath) {
+  try {
+    const f = path.join(projectPath, ".claudeboard-expo-error.txt");
+    return fs.existsSync(f) ? fs.readFileSync(f, "utf8").slice(-1500) : "Unknown error";
+  } catch { return "Unknown error"; }
+}
+
+// ── Helpers ───────────────────────────────────────────────────────────────
+function hasFatalNpmError(output) {
+  return output.includes("npm error code ETARGET") ||
+    output.includes("notarget No matching version") ||
+    (output.includes("npm error") && output.includes("ERESOLVE") && output.includes("unable to resolve"));
+}
+
+function getFatalError(output) {
+  return output.split("\n").find(l => l.includes("npm error") && !l.includes("peer")) || output.slice(-200);
 }

package/agents/orchestrator.js

@@ -140,6 +140,15 @@ export async function runOrchestrator(config) {
 
     consecutiveFailures = 0;
 
+    // ── If this was an Expo fix task, clear the error and re-health-check ────
+    if (task.title?.toLowerCase().includes("expo") && task.type === "bug") {
+      try { fs.unlinkSync(path.join(projectPath, ".claudeboard-expo-error.txt")); } catch {}
+      console.log(chalk.dim("  Expo fix completed — re-running health check..."));
+      const recheck = await runExpoHealthCheck(projectPath, expoPort);
+      expoReady = recheck.ready;
+      expoProcess = recheck.process;
+    }
+
     // ── Re-check Expo health if it's supposed to be running but isn't ────────
     if (expoReady) {
       const portOpen = await isPortOpen(expoPort);

package/agents/qa.js

@@ -33,11 +33,22 @@ export async function runQAAgent(task, devResult, projectPath, prdContent, expoP
     };
   }
 
-  // ── 3. Screenshot (only if Expo is running) ────────────────────────────────
+  // ── 3. Screenshot + Metro error check (only if Expo is running) ───────────
   let visualVerdict = null;
   const expoRunning = await isPortOpen(expoPort);
 
   if (expoRunning) {
+    // Verify Metro is actually serving without errors (not just port open)
+    const metroCheck = await checkMetroHealth(expoPort, projectPath);
+    if (!metroCheck.healthy) {
+      await addLog(task.id, `Metro error detected: ${metroCheck.error?.slice(0, 100)}`, "error");
+      return {
+        passed: false,
+        issues: [`Expo/Metro has active errors: ${metroCheck.error?.slice(0, 200)}`],
+        fixInstructions: `Metro is crashing with this error:\n${metroCheck.error}\n\nFix this error so the app loads without crashing on the device.`,
+        screenshotPath: null,
+      };
+    }
     await addLog(task.id, "Taking screenshot...", "progress");
     const screenshotDir = path.join(projectPath, ".claudeboard-screenshots");
     const screenshot = await screenshotExpoWeb(expoPort, screenshotDir);
@@ -227,3 +238,23 @@ async function isPortOpen(port) {
     });
   } catch { return false; }
 }
+
+// Check Metro is serving without errors by fetching the bundle status
+async function checkMetroHealth(port, projectPath) {
+  try {
+    // Read the expo error file if it exists (written by health check)
+    const errorFile = path.join(projectPath, ".claudeboard-expo-error.txt");
+    if (fs.existsSync(errorFile)) {
+      const errorContent = fs.readFileSync(errorFile, "utf8");
+      // Only fail if error is recent (file modified in last 5 min)
+      const stat = fs.statSync(errorFile);
+      const ageMs = Date.now() - stat.mtimeMs;
+      if (ageMs < 5 * 60 * 1000 && errorContent.includes("Unable to resolve")) {
+        return { healthy: false, error: errorContent.slice(-800) };
+      }
+    }
+    return { healthy: true };
+  } catch {
+    return { healthy: true }; // Don't fail if we can't check
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claudeboard",
-  "version": "2.8.0",
+  "version": "2.9.0",
   "description": "AI engineering team — from PRD to working mobile app, autonomously",
   "type": "module",
   "bin": {