claudeboard 2.9.1 → 2.10.1

package/agents/developer.js

@@ -44,7 +44,10 @@ function buildEnv() {
   ].filter(Boolean);
 
   const fullPath = [...new Set(pathParts.join(":").split(":"))].join(":");
-  return { ...process.env, PATH: fullPath, HOME: process.env.HOME };
+  const env = { ...process.env, PATH: fullPath, HOME: process.env.HOME };
+  // Remove API key so Claude Code uses the Claude subscription (not API credits)
+  delete env.ANTHROPIC_API_KEY;
+  return env;
 }
 
 const CLAUDE_PATH = resolveClaudePath();

package/agents/expo-health.js

@@ -152,7 +152,7 @@ async function tryStartExpo(projectPath, port) {
       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: (() => { const e = { ...process.env, CI: "1", EXPO_NO_INTERACTIVE: "1", EXPO_NO_DOTENV: "0" }; delete e.ANTHROPIC_API_KEY; return e; })(),
         stdio: "pipe",
       });
 

package/agents/qa.js

@@ -1,177 +1,221 @@
-import { callClaude, callClaudeJSON, callClaudeWithImage } from "./claude-api.js";
-import { addLog } from "./board-client.js";
-import { readFile, listFiles } from "../tools/filesystem.js";
+import { query } from "@anthropic-ai/claude-agent-sdk";
+import { addLog, completeTask, failTask } from "./board-client.js";
 import { runCommand } from "../tools/terminal.js";
 import { screenshotExpoWeb } from "../tools/screenshot.js";
-import { readErrorLogs } from "../tools/supabase-reader.js";
+import { listFiles, readFile } from "../tools/filesystem.js";
+import { execSync } from "child_process";
 import path from "path";
 import fs from "fs";
+import { createConnection } from "net";
+
+// ── Reuse Claude Code path + env from developer ───────────────────────────────
+function resolveClaudePath() {
+  if (process.env.CLAUDE_CODE_PATH) return process.env.CLAUDE_CODE_PATH;
+  try { return execSync("which claude", { stdio: "pipe" }).toString().trim(); } catch {}
+  for (const p of [
+    "/opt/homebrew/bin/claude",
+    "/usr/local/bin/claude",
+    `${process.env.HOME}/.nvm/versions/node/current/bin/claude`,
+    `${process.env.HOME}/.npm-global/bin/claude`,
+  ]) {
+    try { execSync(`test -f "${p}"`, { stdio: "pipe" }); return p; } catch {}
+  }
+  return null;
+}
+
+function buildEnv() {
+  let nodeBinDir = "";
+  try { nodeBinDir = execSync("dirname $(which node)", { stdio: "pipe" }).toString().trim(); } catch {}
+  const pathParts = [
+    process.env.PATH || "",
+    nodeBinDir,
+    "/opt/homebrew/bin", "/opt/homebrew/sbin",
+    "/usr/local/bin", "/usr/bin", "/bin",
+    `${process.env.HOME}/.npm-global/bin`,
+    `${process.env.HOME}/.nvm/versions/node/current/bin`,
+  ].filter(Boolean);
+  const fullPath = [...new Set(pathParts.join(":").split(":"))].join(":");
+  const env = { ...process.env, PATH: fullPath, HOME: process.env.HOME };
+  // Remove API key so Claude Code uses the Claude subscription (not API credits)
+  delete env.ANTHROPIC_API_KEY;
+  return env;
+}
+
+const CLAUDE_PATH = resolveClaudePath();
 
-const SYSTEM_QA = `You are a senior QA engineer for React Native / Expo apps.
-Verify that implemented features work correctly. Be specific about actual issues.
-If Expo is not running, evaluate purely on code quality and completeness.`;
+const QA_TOOLS = ["Read", "Glob", "Grep", "Bash"];
 
+// ── Main QA entry point ───────────────────────────────────────────────────────
 export async function runQAAgent(task, devResult, projectPath, prdContent, expoPort = 8081) {
   console.log(`  🔍  QA checking: ${task.title}`);
   await addLog(task.id, "QA starting", "progress");
 
-  // ── 1. TypeScript check ────────────────────────────────────────────────────
-  const tsResult = await runCommand("npx tsc --noEmit 2>&1", projectPath, 60000);
-  const tsErrors = tsResult.stdout.includes("error TS") ? tsResult.stdout : null;
-  if (tsErrors) await addLog(task.id, `TypeScript errors detected`, "error");
-
-  // ── 2. Check for truncated/incomplete files ────────────────────────────────
-  const truncationIssues = await checkForTruncatedFiles(task, projectPath);
-  if (truncationIssues.length > 0) {
-    const msg = `Incomplete files: ${truncationIssues.join(", ")}`;
+  // ── 1. Check for truncated files (cheap, no Claude needed) ────────────────
+  const truncated = await checkForTruncatedFiles(task, projectPath);
+  if (truncated.length > 0) {
+    const msg = `Incomplete files detected: ${truncated.join(", ")}`;
     await addLog(task.id, msg, "error");
     return {
       passed: false,
-      issues: truncationIssues,
-      fixInstructions: `These files are truncated/incomplete:\n${truncationIssues.join("\n")}\n\nRe-implement them completely from scratch.`,
-      screenshotPath: null,
+      issues: truncated,
+      fixInstructions: `These files are truncated/incomplete:\n${truncated.join("\n")}\n\nRe-implement them completely.`,
     };
   }
 
-  // ── 3. Screenshot + Metro error check (only if Expo is running) ───────────
-  let visualVerdict = null;
+  // ── 2. Check Metro health (if Expo is running) ────────────────────────────
   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");
+    const metroErr = await getMetroError(projectPath);
+    if (metroErr) {
+      await addLog(task.id, `Metro error: ${metroErr.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,
+        issues: [`Metro crash: ${metroErr.slice(0, 200)}`],
+        fixInstructions: `Metro is crashing:\n${metroErr}\n\nFix this so the app loads on device without errors.`,
       };
     }
-    await addLog(task.id, "Taking screenshot...", "progress");
-    const screenshotDir = path.join(projectPath, ".claudeboard-screenshots");
-    const screenshot = await screenshotExpoWeb(expoPort, screenshotDir);
-    if (screenshot.success && screenshot.base64) {
-      const visionResult = await callClaudeWithImage(
-        SYSTEM_QA,
-        `Task: ${task.title}\nExpected: ${task.description}\n\nDoes the UI look correct? Any visual bugs?`,
-        screenshot.base64
-      );
-      visualVerdict = visionResult.text;
-      await addLog(task.id, `Visual: ${visualVerdict}`, "progress");
-    } else {
-      await addLog(task.id, `Screenshot failed: ${screenshot.error}`, "progress");
-    }
-  } else {
-    await addLog(task.id, "Expo not running — code-only QA", "progress");
   }
 
-  // ── 4. Read ALL relevant code — no artificial limits ──────────────────────
-  // Claude Code already wrote these files — we read them fully for QA review
-  const relevantFiles = getRelevantFiles(task, projectPath);
-  let codeContext = "";
-  for (const f of relevantFiles) {
-    const content = readFile(f);
-    if (content) {
-      // No slice — read the complete file
-      codeContext += `\n### ${path.relative(projectPath, f)}\n${content}\n`;
+  // ── 3. Take screenshot if Expo is running ─────────────────────────────────
+  let screenshotBase64 = null;
+  let screenshotPath = null;
+  if (expoRunning) {
+    await addLog(task.id, "Taking screenshot...", "progress");
+    const screenshotDir = path.join(projectPath, ".claudeboard-screenshots");
+    const shot = await screenshotExpoWeb(expoPort, screenshotDir);
+    if (shot.success && shot.base64) {
+      screenshotBase64 = shot.base64;
+      screenshotPath = shot.path;
     }
   }
 
-  // ── 5. App logs (full) ─────────────────────────────────────────────────────
-  let appLogs = "";
-  try {
-    const logFile = path.join(projectPath, ".claudeboard-logs.txt");
-    if (fs.existsSync(logFile)) appLogs = fs.readFileSync(logFile, "utf8");
-  } catch {}
-
-  // ── 6. Supabase errors ─────────────────────────────────────────────────────
-  let supabaseLogs = [];
-  try { supabaseLogs = await readErrorLogs("logs", 20); } catch {}
-
-  // ── 7. Functional verdict ─────────────────────────────────────────────────
-  const verdict = await callClaudeJSON(
-    SYSTEM_QA,
-    `Task: ${task.title}
-Description: ${task.description}
+  // ── 4. Ask Claude Code to review the implementation ──────────────────────
+  const qaResult = await runClaudeCodeQA(task, projectPath, prdContent, expoRunning, screenshotBase64, screenshotPath);
 
-Implemented code (complete files):
-${codeContext || "Could not read relevant files"}
-
-TypeScript: ${tsErrors ? `ERRORS:\n${tsErrors}` : "Clean — no errors"}
-App logs: ${appLogs || "None"}
-Supabase errors: ${supabaseLogs.length > 0 ? JSON.stringify(supabaseLogs, null, 2) : "None"}
-Visual QA: ${visualVerdict || "No screenshot (Expo not running — evaluate code only)"}
-
-EVALUATION RULES:
-- PASS if: code is complete, TypeScript is clean, implementation matches description
-- FAIL only if: code is incomplete/truncated, has TS errors, or implementation is clearly wrong
-- Do NOT fail just because Expo isn't running
-- Do NOT fail for minor style preferences
-
-Respond with JSON:
-{
-  "passed": true/false,
-  "confidence": 0-100,
-  "issues": ["specific issue 1", "specific issue 2"],
-  "summary": "One sentence verdict",
-  "fixInstructions": "Specific fix instructions if failed, null if passed"
-}`
-  );
-
-  const qaReport = {
-    passed: verdict.passed,
-    issues: verdict.issues || [],
-    fixInstructions: verdict.fixInstructions,
-    screenshotPath: null,
-  };
-
-  if (qaReport.passed) {
-    await addLog(task.id, `✓ QA passed (${verdict.confidence}%): ${verdict.summary}`, "complete");
+  if (qaResult.passed) {
+    await addLog(task.id, `✓ QA passed: ${qaResult.summary}`, "complete");
     console.log(`  ✓ QA passed: ${task.title}`);
   } else {
-    await addLog(task.id, `✗ QA failed: ${verdict.summary}`, "error");
-    console.log(`  ✗ QA failed: ${task.title} — ${verdict.issues?.slice(0,2).join(", ")}`);
+    await addLog(task.id, `✗ QA failed: ${qaResult.summary}`, "error");
+    console.log(`  ✗ QA failed: ${task.title} — ${qaResult.issues?.slice(0, 2).join(", ")}`);
   }
 
-  return qaReport;
+  return qaResult;
 }
 
-// ── Detect truncated/incomplete files ──────────────────────────────────────────
-async function checkForTruncatedFiles(task, projectPath) {
-  const issues = [];
-  const keywords = task.title.toLowerCase().split(" ").filter(w => w.length > 4);
+// ── Claude Code QA review ─────────────────────────────────────────────────────
+async function runClaudeCodeQA(task, projectPath, prdContent, expoRunning, screenshotBase64, screenshotPath) {
+  const screenshotNote = screenshotBase64
+    ? `A screenshot of the app has been saved to: ${screenshotPath}\nRead it with the Read tool and evaluate the visual result.`
+    : expoRunning
+      ? "Expo is running but screenshot failed — evaluate code only."
+      : "Expo is not running — evaluate code quality only (TypeScript, completeness, correctness).";
 
-  const files = listFiles(projectPath, [".ts", ".tsx"])
-    .filter(f => {
-      const rel = path.relative(projectPath, f).toLowerCase();
-      if (rel.includes("node_modules") || rel.includes(".claudeboard")) return false;
-      return keywords.some(kw => rel.includes(kw));
-    });
+  const prompt = `You are a senior QA engineer reviewing a React Native / Expo implementation.
 
-  for (const f of files) {
-    const content = readFile(f);
-    if (!content) continue;
-    const rel = path.relative(projectPath, f);
-    const lastLines = content.split("\n").slice(-5).join("\n").trim();
-    const openBraces  = (content.match(/\{/g) || []).length;
-    const closeBraces = (content.match(/\}/g) || []).length;
+TASK THAT WAS IMPLEMENTED:
+Title: ${task.title}
+Description: ${task.description}
 
-    const truncated =
-      lastLines.endsWith("{") || lastLines.endsWith("(") || lastLines.endsWith(",") ||
-      lastLines.match(/^(import|\/\/) *$/) ||
-      openBraces > closeBraces + 3 ||
-      (content.length < 80 && (rel.includes("store") || rel.includes("hook") || rel.includes("screen")));
+${screenshotNote}
+
+YOUR JOB:
+1. Run: npx tsc --noEmit 2>&1 | head -50
+   - If TypeScript errors exist → FAIL with specific error details
+2. Find and read the files related to this task (use Glob + Read)
+   - Check for: incomplete implementations, missing imports, wrong logic
+3. ${screenshotBase64 ? "Read the screenshot file and check if the UI matches what was expected" : "Evaluate the code for correctness based on the description"}
+
+PASS criteria:
+- TypeScript is clean (no errors)
+- Files are complete (not truncated)  
+- Implementation matches the task description
+
+FAIL criteria:
+- TypeScript errors
+- Files clearly incomplete or truncated
+- Implementation completely missing or wrong
+
+When done, output EXACTLY one of these lines:
+QA_PASS: <one sentence summary of what was verified>
+QA_FAIL: <specific reason> | FIX: <exact instructions for the developer>`;
 
-    if (truncated) {
-      issues.push(`${rel} (ends: "${lastLines.slice(-80)}")`);
+  if (!CLAUDE_PATH) {
+    console.log("  ⚠ Claude Code not found — skipping QA");
+    return { passed: true, summary: "Skipped (Claude Code not found)", issues: [] };
+  }
+
+  try {
+    let output = "";
+    let passed = null;
+    let summary = "";
+    let fixInstructions = "";
+
+    for await (const message of query({
+      prompt,
+      options: {
+        cwd: projectPath,
+        tools: QA_TOOLS,
+        permissionMode: "bypassPermissions",
+        maxTurns: 20,
+        pathToClaudeCodeExecutable: CLAUDE_PATH,
+        env: buildEnv(),
+      },
+    })) {
+      if (message.type === "assistant") {
+        for (const block of message.message?.content || []) {
+          if (block.type === "text") {
+            const text = block.text;
+            output += text + "\n";
+
+            if (text.includes("QA_PASS:")) {
+              passed = true;
+              summary = text.split("QA_PASS:")[1]?.trim().split("\n")[0] || task.title;
+            } else if (text.includes("QA_FAIL:")) {
+              passed = false;
+              const parts = text.split("QA_FAIL:")[1]?.split("| FIX:") || [];
+              summary = parts[0]?.trim() || "QA failed";
+              fixInstructions = parts[1]?.trim() || summary;
+            }
+          }
+          if (block.type === "tool_use") {
+            await addLog(task.id, `QA: ${block.name} ${JSON.stringify(block.input).slice(0, 60)}`, "progress");
+          }
+        }
+      }
+
+      if (message.type === "result") {
+        // Check result text too
+        const text = message.result || "";
+        if (!passed && text.includes("QA_PASS:")) {
+          passed = true;
+          summary = text.split("QA_PASS:")[1]?.trim().split("\n")[0] || task.title;
+        } else if (passed === null && text.includes("QA_FAIL:")) {
+          passed = false;
+          const parts = text.split("QA_FAIL:")[1]?.split("| FIX:") || [];
+          summary = parts[0]?.trim() || "QA failed";
+          fixInstructions = parts[1]?.trim() || summary;
+        }
+        // Default to pass if Claude Code ran but didn't signal explicitly
+        if (passed === null) passed = true;
+      }
     }
+
+    return {
+      passed: passed ?? true,
+      summary: summary || task.title,
+      issues: passed ? [] : [summary],
+      fixInstructions: passed ? null : fixInstructions,
+    };
+
+  } catch (e) {
+    // If Claude Code fails for any reason, don't block development
+    console.log(`  ⚠ QA error: ${e.message?.slice(0, 80)} — skipping`);
+    return { passed: true, summary: "QA skipped (error)", issues: [] };
   }
-  return issues;
 }
 
-// ── Full app QA ────────────────────────────────────────────────────────────────
+// ── Full app QA after all tasks complete ──────────────────────────────────────
 export async function runFullAppQA(projectPath, prdContent, expoPort = 8081) {
   console.log("\n  🔍  Running full app QA...");
 
@@ -196,65 +240,55 @@ export async function runFullAppQA(projectPath, prdContent, expoPort = 8081) {
     await new Promise(r => setTimeout(r, 800));
   }
 
-  const report = { passed: true, routes: routeFiles, screenshotsCaptures: screenshots.length, issues: [] };
-
-  for (const shot of screenshots) {
-    if (!shot.base64) continue;
-    const verdict = await callClaudeWithImage(
-      SYSTEM_QA,
-      `Route: ${shot.route}\n\nFull PRD:\n${prdContent}\n\nAny obvious issues?`,
-      shot.base64
-    );
-    if (verdict.text.toLowerCase().includes("issue") || verdict.text.toLowerCase().includes("problem")) {
-      report.issues.push({ route: shot.route, note: verdict.text });
-    }
-  }
-
-  return report;
+  return { passed: true, routes: routeFiles, screenshotsCaptures: screenshots.length, issues: [] };
 }
 
-// ── Helpers ───────────────────────────────────────────────────────────────────
-function getRelevantFiles(task, projectPath) {
+// ── Detect truncated files ─────────────────────────────────────────────────────
+async function checkForTruncatedFiles(task, projectPath) {
+  const issues = [];
   const keywords = task.title.toLowerCase().split(" ").filter(w => w.length > 4);
-  return listFiles(projectPath, [".ts", ".tsx"])
-    .filter(f => {
-      const rel = path.relative(projectPath, f).toLowerCase();
-      if (rel.includes("node_modules") || rel.includes(".claudeboard")) return false;
-      return keywords.some(kw => rel.includes(kw));
-    });
-  // No .slice() — return all matching files
+  const files = listFiles(projectPath, [".ts", ".tsx"]).filter(f => {
+    const rel = path.relative(projectPath, f).toLowerCase();
+    if (rel.includes("node_modules") || rel.includes(".claudeboard")) return false;
+    return keywords.some(kw => rel.includes(kw));
+  });
+
+  for (const f of files) {
+    const content = readFile(f);
+    if (!content) continue;
+    const rel = path.relative(projectPath, f);
+    const lastLines = content.split("\n").slice(-5).join("\n").trim();
+    const openBraces  = (content.match(/\{/g) || []).length;
+    const closeBraces = (content.match(/\}/g) || []).length;
+    const truncated =
+      lastLines.endsWith("{") || lastLines.endsWith("(") || lastLines.endsWith(",") ||
+      openBraces > closeBraces + 3 ||
+      (content.length < 80 && (rel.includes("store") || rel.includes("hook") || rel.includes("screen")));
+    if (truncated) issues.push(`${rel} (ends: "${lastLines.slice(-80)}")`);
+  }
+  return issues;
 }
 
-async function isPortOpen(port) {
-  try {
-    const { default: net } = await import("net");
-    return new Promise(resolve => {
-      const sock = new net.Socket();
-      sock.setTimeout(800);
-      sock.once("connect", () => { sock.destroy(); resolve(true); });
-      sock.once("error", () => resolve(false));
-      sock.once("timeout", () => resolve(false));
-      sock.connect(port, "127.0.0.1");
-    });
-  } catch { return false; }
+// ── Helpers ───────────────────────────────────────────────────────────────────
+function isPortOpen(port) {
+  return new Promise(resolve => {
+    const sock = createConnection({ port, host: "127.0.0.1" });
+    sock.setTimeout(800);
+    sock.once("connect", () => { sock.destroy(); resolve(true); });
+    sock.once("error", () => resolve(false));
+    sock.once("timeout", () => resolve(false));
+  });
 }
 
-// Check Metro is serving without errors by fetching the bundle status
-async function checkMetroHealth(port, projectPath) {
+async function getMetroError(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
-  }
+    const f = path.join(projectPath, ".claudeboard-expo-error.txt");
+    if (!fs.existsSync(f)) return null;
+    const stat = fs.statSync(f);
+    if (Date.now() - stat.mtimeMs > 5 * 60 * 1000) return null; // older than 5min
+    const content = fs.readFileSync(f, "utf8");
+    return content.includes("Unable to resolve") || content.includes("Cannot find module")
+      ? content.slice(-800)
+      : null;
+  } catch { return null; }
 }

package/bin/cli.js

@@ -8,8 +8,12 @@ import path from "path";
 import fs from "fs";
 import { spawn } from "child_process";
 import open from "open";
+import { createRequire } from "module";
 
+const _require = createRequire(import.meta.url);
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const _pkg = JSON.parse(fs.readFileSync(path.join(__dirname, "../package.json"), "utf8"));
+
 
 const LOGO = `
 ${chalk.cyan("╔══════════════════════════════════════╗")}
@@ -236,6 +240,6 @@ program
 program
   .name("claudeboard")
   .description("AI engineering team — from PRD to working app, autonomously")
-  .version("1.0.0");
+  .version(_pkg.version);
 
 program.parse();

package/package.json

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