claudeboard 1.5.0 → 2.1.0

package/agents/developer.js

@@ -1,161 +1,240 @@
-import { callClaudeJSON, callClaude } from "./claude-api.js";
-import { startTask, completeTask, failTask, addLog } from "./board-client.js";
-import { readFile, writeFile, listFiles, projectTree, readFilesAsContext } from "../tools/filesystem.js";
-import { runCommand } from "../tools/terminal.js";
-import path from "path";
+/**
+ * Developer Agent — powered by Claude Agent SDK
+ *
+ * Instead of calling the Claude API and manually writing files,
+ * this agent spawns Claude Code directly in the project directory.
+ * Claude Code can read the full codebase, run commands, install deps,
+ * fix errors, and iterate — all autonomously.
+ *
+ * Requires: npm install -g @anthropic-ai/claude-code
+ */
 
-const SYSTEM = `You are a senior React Native / Expo developer. You write clean, production-ready code.
+import { query } from "@anthropic-ai/claude-agent-sdk";
+import { startTask, completeTask, failTask, addLog } from "./board-client.js";
+import { execSync } from "child_process";
+
+// Resolve the global `claude` binary path at startup
+function resolveClaudePath() {
+  // 1. Explicit override via env var
+  if (process.env.CLAUDE_CODE_PATH) return process.env.CLAUDE_CODE_PATH;
+
+  // 2. Ask the shell where `claude` lives (works after: npm install -g @anthropic-ai/claude-code)
+  try {
+    return execSync("which claude", { stdio: "pipe" }).toString().trim();
+  } catch {}
+
+  // 3. Common Homebrew / nvm / fnm paths
+  const candidates = [
+    "/opt/homebrew/bin/claude",
+    "/usr/local/bin/claude",
+    `${process.env.HOME}/.nvm/versions/node/current/bin/claude`,
+    `${process.env.HOME}/.npm-global/bin/claude`,
+  ];
+  for (const p of candidates) {
+    try { execSync(`test -f "${p}"`, { stdio: "pipe" }); return p; } catch {}
+  }
 
-Rules:
-- Write complete, working code — never use placeholders or TODOs
-- Always use TypeScript when the project uses it
-- Follow the existing code style and patterns in the project
-- Add console.log statements for key operations so QA can verify functionality
-- Add error handling with meaningful error messages
-- When creating screens, make them visually polished — proper spacing, colors, typography
-- Use the existing navigation structure — never change routing patterns mid-project
-- Import only packages that are already installed or that you explicitly install first
+  return null; // will surface as CLINotFoundError
+}
 
-When you need to create or modify files, respond with a JSON array of file operations.`;
+const CLAUDE_PATH = resolveClaudePath();
+
+// Tools Claude Code can use — full developer access
+const DEVELOPER_TOOLS = [
+  "Read",        // Read any file in the project
+  "Write",       // Create new files
+  "Edit",        // Edit existing files (surgical, line-level)
+  "MultiEdit",   // Edit multiple files in one shot
+  "Bash",        // Run npm install, npx expo install, tsc, etc.
+  "Glob",        // Find files by pattern (e.g. "**/*.tsx")
+  "Grep",        // Search file contents
+  "TodoWrite",   // Let Claude track its own subtasks
+  "TodoRead",    // Read its own task list
+];
+
+const DEV_RULES = `
+You are a senior React Native / Expo developer working as part of an autonomous engineering team.
+
+RULES:
+- Write complete, production-ready code — no placeholders, no TODOs
+- Use TypeScript if the project uses it
+- Follow the existing code style and folder structure (read existing files first)
+- Install packages with: npx expo install <package>
+- After writing files, run: npx tsc --noEmit — fix any TypeScript errors
+- If you hit an error, read it and fix it — iterate until it works
+- Do NOT ask questions. Do NOT ask for confirmation. Make your best judgment.
+- When fully done, print EXACTLY this line: TASK_COMPLETE: <one sentence summary>
+`;
 
 export async function runDeveloperAgent(task, projectPath, techStack, retryContext = null) {
-  console.log(`  💻  Developer working on: ${task.title}`);
-  await startTask(task.id, `Starting implementation: ${task.title}`);
-
-  const MAX_RETRIES = 3;
-  let attempt = 0;
-  let lastError = null;
-
-  while (attempt < MAX_RETRIES) {
-    attempt++;
-    if (attempt > 1) {
-      console.log(`  🔄  Retry ${attempt}/${MAX_RETRIES} for: ${task.title}`);
-      await addLog(task.id, `Retry ${attempt}: fixing — ${lastError}`, "progress");
-    }
-
-    try {
-      // Gather context
-      const tree = projectTree(projectPath);
-      const relevantFiles = getRelevantFiles(task, projectPath);
-      const fileContext = readFilesAsContext(relevantFiles, projectPath);
-
-      const retryNote = retryContext
-        ? `\n\nPREVIOUS ATTEMPT FAILED:\n${retryContext}\n\nFix these issues.`
-        : "";
-
-      const lastErrorNote = lastError
-        ? `\n\nLAST ERROR: ${lastError}\nFix this specifically.`
-        : "";
-
-      const prompt = `
-Task: ${task.title}
-Description: ${task.description}
-
-Project structure:
-${tree}
-
-Relevant existing files:
-${fileContext || "No existing files yet — this may be a fresh setup task."}
-
-Tech stack: ${JSON.stringify(techStack || {}, null, 2)}
-${retryNote}${lastErrorNote}
-
-Respond with JSON:
-{
-  "plan": "Brief explanation of your approach",
-  "installPackages": ["pkg1", "pkg2"],
-  "files": [
-    {
-      "path": "relative/path/from/project/root.tsx",
-      "action": "create|modify|delete",
-      "content": "complete file content here"
-    }
-  ],
-  "commands": ["any post-file commands to run, e.g. npx expo install package"],
-  "verificationSteps": "What to check to verify this works"
-}`;
-
-      const result = await callClaudeJSON(SYSTEM, prompt);
-
-      // Install packages first
-      if (result.installPackages?.length > 0) {
-        const pkgs = result.installPackages.join(" ");
-        await addLog(task.id, `Installing: ${pkgs}`, "progress");
-        const install = await runCommand(`npx expo install ${pkgs}`, projectPath, 120000);
-        if (install.exitCode !== 0) {
-          // Try npm install as fallback
-          await runCommand(`npm install ${pkgs}`, projectPath, 120000);
+  console.log(`  🤖  Claude Code working on: ${task.title}`);
+  if (CLAUDE_PATH) {
+    console.log(`     CLI: ${CLAUDE_PATH}`);
+  } else {
+    const hint = "Claude Code CLI not found. Run: npm install -g @anthropic-ai/claude-code";
+    await startTask(task.id, hint);
+    await failTask(task.id, hint);
+    console.error(`\n  ✗ ${hint}\n`);
+    return { success: false, error: hint };
+  }
+  await startTask(task.id, `Claude Code starting: ${task.title}`);
+
+  const retryNote = retryContext
+    ? `\n\n⚠️ RETRY — Previous attempt failed or QA flagged issues:\n${retryContext}\n\nFix these specific issues.`
+    : "";
+
+  const techNote = techStack && Object.keys(techStack).length > 0
+    ? `\nKnown tech stack: ${JSON.stringify(techStack)}`
+    : "";
+
+  const prompt = `## Task to implement
+
+**Title:** ${task.title}
+
+**Description:**
+${task.description || "No additional description provided."}
+${techNote}
+${retryNote}
+
+## Steps
+1. Explore the project structure to understand existing patterns
+2. Implement the task completely
+3. Install any missing dependencies with: npx expo install <pkg>
+4. Run: npx tsc --noEmit and fix any errors
+5. When done, print: TASK_COMPLETE: <summary>`;
+
+  try {
+    let toolCallCount = 0;
+    let completed = false;
+    let summary = "";
+
+    for await (const message of query({
+      prompt,
+      options: {
+        cwd: projectPath,
+        model: "claude-sonnet-4-20250514",
+        permissionMode: "bypassPermissions",
+        allowedTools: DEVELOPER_TOOLS,
+        maxTurns: 80,
+        ...(CLAUDE_PATH ? { pathToClaudeCodeExecutable: CLAUDE_PATH } : {}),
+        systemPrompt: {
+          type: "preset",
+          preset: "claude_code",
+          append: DEV_RULES,
+        },
+        env: {
+          ANTHROPIC_API_KEY: process.env.ANTHROPIC_API_KEY,
+        },
+      },
+    })) {
+
+      // ── Assistant messages ─────────────────────────────────────────────────
+      if (message.type === "assistant") {
+        for (const block of message.message.content) {
+
+          if (block.type === "text" && block.text?.trim()) {
+            const text = block.text.trim();
+
+            // Detect completion signal
+            if (text.includes("TASK_COMPLETE:")) {
+              completed = true;
+              summary = text.split("TASK_COMPLETE:")[1]?.trim().split("\n")[0] || task.title;
+            }
+
+            // Log meaningful progress
+            if (text.length > 20) {
+              const preview = text.split("\n")[0].slice(0, 120);
+              await addLog(task.id, preview, "progress");
+              console.log(`     ${preview}`);
+            }
+          }
+
+          if (block.type === "tool_use") {
+            toolCallCount++;
+            const log = formatToolLog(block);
+            if (log) {
+              await addLog(task.id, log, "progress");
+              console.log(`     🔧 ${log}`);
+            }
+          }
         }
       }
 
-      // Write files
-      for (const file of result.files || []) {
-        const fullPath = path.join(projectPath, file.path);
-        if (file.action === "delete") {
-          try { fs.unlinkSync(fullPath); } catch {}
+      // ── Result ─────────────────────────────────────────────────────────────
+      if (message.type === "result") {
+        if (message.subtype === "success") {
+          if (!completed && message.result?.includes("TASK_COMPLETE:")) {
+            completed = true;
+            summary = message.result.split("TASK_COMPLETE:")[1]?.trim().split("\n")[0] || task.title;
+          }
+
+          const finalSummary = summary || `Implemented: ${task.title}`;
+          await completeTask(task.id, `✓ ${finalSummary} (${toolCallCount} tool calls)`);
+          console.log(`  ✓ Done: ${task.title} — ${toolCallCount} tool calls`);
+          return { success: true, summary: finalSummary };
+
+        } else if (message.subtype === "error_max_turns") {
+          if (completed) {
+            await completeTask(task.id, `✓ ${summary} (hit turn limit)`);
+            return { success: true, summary };
+          }
+          const err = "Reached max turns without completing — increase maxTurns or break task into smaller pieces";
+          await failTask(task.id, err);
+          return { success: false, error: err };
+
         } else {
-          writeFile(fullPath, file.content);
-          await addLog(task.id, `${file.action}: ${file.path}`, "progress");
+          const err = message.result || "Claude Code returned an error";
+          await failTask(task.id, err.slice(0, 500));
+          return { success: false, error: err };
         }
       }
 
-      // Run any additional commands
-      for (const cmd of result.commands || []) {
-        await addLog(task.id, `Running: ${cmd}`, "progress");
-        await runCommand(cmd, projectPath, 60000);
-      }
-
-      // Verify it compiles
-      const typecheck = await runCommand("npx tsc --noEmit 2>&1 | head -20", projectPath, 30000);
-      const hasTSErrors = typecheck.stdout.includes("error TS");
-
-      if (hasTSErrors) {
-        lastError = `TypeScript errors:\n${typecheck.stdout}`;
-        continue; // retry
+      // ── System init ────────────────────────────────────────────────────────
+      if (message.type === "system" && message.subtype === "init") {
+        const sessionShort = message.session_id?.slice(0, 8) || "?";
+        console.log(`     📡 Session ${sessionShort} | ${message.tools?.length || 0} tools | ${message.model}`);
+        await addLog(task.id, `Claude Code session ${sessionShort} in ${projectPath}`, "start");
       }
+    }
 
-      // Check for obvious JS syntax errors
-      const buildCheck = await runCommand(
-        "npx expo export --platform web --output-dir /tmp/cb-check 2>&1 | tail -10",
-        projectPath,
-        90000
-      );
+    // Generator ended without a result message
+    if (completed) {
+      await completeTask(task.id, `✓ ${summary}`);
+      return { success: true, summary };
+    }
 
-      if (buildCheck.stdout.includes("ERROR") || buildCheck.stdout.includes("Cannot find")) {
-        lastError = `Build error:\n${buildCheck.stdout}`;
-        continue; // retry
-      }
+    const err = "Session ended without result";
+    await failTask(task.id, err);
+    return { success: false, error: err };
 
-      await completeTask(task.id, `✓ Implemented: ${result.plan}`);
-      console.log(`  ✓ Done: ${task.title}`);
-      return { success: true, files: result.files, verificationSteps: result.verificationSteps };
+  } catch (err) {
+    const msg = err.message || String(err);
+    console.error(`  ✗ Error:`, msg.slice(0, 200));
 
-    } catch (err) {
-      lastError = err.message;
-      console.error(`  ✗ Error on attempt ${attempt}:`, err.message);
+    // Missing CLI — helpful message
+    if (msg.includes("CLINotFoundError") || msg.includes("ENOENT") || msg.includes("claude-code")) {
+      const hint = "Claude Code CLI not installed. Run: npm install -g @anthropic-ai/claude-code";
+      await failTask(task.id, hint);
+      console.error(`\n  ⚠️  ${hint}\n`);
+      return { success: false, error: hint };
     }
-  }
 
-  await failTask(task.id, `Failed after ${MAX_RETRIES} attempts. Last error: ${lastError}`);
-  return { success: false, error: lastError };
+    await failTask(task.id, msg.slice(0, 500));
+    return { success: false, error: msg };
+  }
 }
 
-/**
- * Get files relevant to this task based on keywords
- */
-function getRelevantFiles(task, projectPath) {
-  const keywords = task.title.toLowerCase().split(" ");
-  const allFiles = listFiles(projectPath, [".ts", ".tsx", ".js", ".jsx", ".json"]);
-
-  // Always include key config files
-  const alwaysInclude = ["package.json", "app.json", "tsconfig.json", "babel.config.js"];
-  const result = allFiles.filter((f) => {
-    const rel = path.relative(projectPath, f);
-    if (alwaysInclude.some((name) => rel.endsWith(name))) return true;
-    if (rel.includes("app/") && rel.endsWith("_layout")) return true;
-    // Include files that match task keywords
-    return keywords.some((kw) => kw.length > 4 && rel.toLowerCase().includes(kw));
-  });
-
-  return result.slice(0, 15); // Max 15 files for context
+function formatToolLog(block) {
+  const { name, input = {} } = block;
+  switch (name) {
+    case "Read":       return `Read: ${input.file_path || input.path || ""}`;
+    case "Write":      return `Write: ${input.file_path || input.path || ""}`;
+    case "Edit":
+    case "MultiEdit":  return `Edit: ${input.file_path || input.path || ""}`;
+    case "Bash":       return `Run: ${(input.command || "").slice(0, 80)}`;
+    case "Glob":       return `Glob: ${input.pattern || ""}`;
+    case "Grep":       return `Grep: "${(input.pattern || "").slice(0, 40)}"`;
+    case "TodoWrite":  return `Planning subtasks...`;
+    default:           return null;
+  }
 }

package/bin/cli.js

@@ -151,6 +151,21 @@ program
     if (opts.restart) console.log(chalk.yellow(`  Mode      → FORCE RESTART\n`));
     else console.log(chalk.dim(`  Mode      → auto-resume if tasks exist\n`));
 
+    // ── Verify Claude Code CLI is installed ───────────────────────────────────
+    const { execSync } = await import("child_process");
+    try {
+      execSync("claude --version", { stdio: "pipe" });
+      const version = execSync("claude --version", { stdio: "pipe" }).toString().trim();
+      console.log(chalk.dim(`  Claude Code → ${version}\n`));
+    } catch {
+      console.log(chalk.red("\n  ✗ Claude Code CLI not found!\n"));
+      console.log(chalk.yellow("  The developer agent requires Claude Code to be installed:"));
+      console.log(chalk.bold("    npm install -g @anthropic-ai/claude-code\n"));
+      console.log(chalk.dim("  Then authenticate:"));
+      console.log(chalk.bold("    claude\n"));
+      process.exit(1);
+    }
+
     const { runOrchestrator } = await import("../agents/orchestrator.js");
 
     await runOrchestrator({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claudeboard",
-  "version": "1.5.0",
+  "version": "2.1.0",
   "description": "AI engineering team — from PRD to working mobile app, autonomously",
   "type": "module",
   "bin": {
@@ -15,6 +15,7 @@
     "README.md"
   ],
   "dependencies": {
+    "@anthropic-ai/claude-agent-sdk": "latest",
     "@supabase/supabase-js": "^2.43.1",
     "chalk": "^5.3.0",
     "commander": "^12.0.0",