claudeboard 1.0.0

package/dashboard/server.js

@@ -0,0 +1,197 @@
+import express from "express";
+import cors from "cors";
+import { createServer } from "http";
+import { WebSocketServer } from "ws";
+import { createClient } from "@supabase/supabase-js";
+import path from "path";
+import { fileURLToPath } from "url";
+import fs from "fs";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+const app = express();
+const server = createServer(app);
+const wss = new WebSocketServer({ server });
+
+app.use(cors());
+app.use(express.json());
+
+const PORT = process.env.PORT || 3131;
+const PROJECT = process.env.PROJECT_NAME || "default";
+
+const supabase = createClient(
+  process.env.SUPABASE_URL,
+  process.env.SUPABASE_KEY
+);
+
+// Broadcast to all WS clients
+function broadcast(event, data) {
+  const msg = JSON.stringify({ event, data, ts: Date.now() });
+  wss.clients.forEach((client) => {
+    if (client.readyState === 1) client.send(msg);
+  });
+}
+
+// Subscribe to Supabase realtime
+supabase
+  .channel("cb_changes")
+  .on("postgres_changes", { event: "*", schema: "public", table: "cb_tasks" }, (payload) => {
+    broadcast("task_update", payload);
+  })
+  .on("postgres_changes", { event: "*", schema: "public", table: "cb_logs" }, (payload) => {
+    broadcast("log", payload.new);
+  })
+  .subscribe();
+
+// ─── API ROUTES ───────────────────────────────────────────────────────────────
+
+// GET all tasks grouped by epic
+app.get("/api/board", async (req, res) => {
+  const { data: epics } = await supabase
+    .from("cb_epics")
+    .select("*, cb_tasks(*)")
+    .eq("project", PROJECT)
+    .order("created_at");
+
+  const { data: logs } = await supabase
+    .from("cb_logs")
+    .select("*")
+    .eq("project", PROJECT)
+    .order("created_at", { ascending: false })
+    .limit(50);
+
+  res.json({ epics: epics || [], logs: logs || [], project: PROJECT });
+});
+
+// GET next pending task
+app.get("/api/tasks/next", async (req, res) => {
+  const { data } = await supabase
+    .from("cb_tasks")
+    .select("*")
+    .eq("project", PROJECT)
+    .eq("status", "todo")
+    .order("priority_order", { ascending: true })
+    .limit(1)
+    .single();
+
+  if (!data) return res.json({ task: null, message: "All tasks complete! 🎉" });
+  res.json({ task: data });
+});
+
+// POST start task
+app.post("/api/tasks/:id/start", async (req, res) => {
+  const { id } = req.params;
+  const { log } = req.body;
+
+  await supabase
+    .from("cb_tasks")
+    .update({ status: "in_progress", started_at: new Date().toISOString() })
+    .eq("id", id);
+
+  if (log) await addLog(id, log, "start");
+  broadcast("task_started", { id });
+  res.json({ ok: true });
+});
+
+// POST log progress
+app.post("/api/tasks/:id/log", async (req, res) => {
+  const { id } = req.params;
+  const { message } = req.body;
+  await addLog(id, message, "progress");
+  res.json({ ok: true });
+});
+
+// POST complete task
+app.post("/api/tasks/:id/complete", async (req, res) => {
+  const { id } = req.params;
+  const { log } = req.body;
+
+  await supabase
+    .from("cb_tasks")
+    .update({ status: "done", completed_at: new Date().toISOString() })
+    .eq("id", id);
+
+  if (log) await addLog(id, log, "complete");
+  broadcast("task_complete", { id });
+  res.json({ ok: true });
+});
+
+// POST fail task
+app.post("/api/tasks/:id/fail", async (req, res) => {
+  const { id } = req.params;
+  const { log } = req.body;
+
+  await supabase
+    .from("cb_tasks")
+    .update({ status: "error" })
+    .eq("id", id);
+
+  if (log) await addLog(id, log, "error");
+  broadcast("task_failed", { id });
+  res.json({ ok: true });
+});
+
+// POST add new task manually (from dashboard or agent)
+app.post("/api/tasks", async (req, res) => {
+  const { title, description, priority, type, epic_id } = req.body;
+
+  const priorityOrder = { high: 1, medium: 2, low: 3 };
+
+  const { data, error } = await supabase
+    .from("cb_tasks")
+    .insert({
+      project: PROJECT,
+      epic_id: epic_id || null,
+      title,
+      description,
+      priority: priority || "medium",
+      priority_order: priorityOrder[priority] || 2,
+      type: type || "feature",
+      status: "todo",
+    })
+    .select()
+    .single();
+
+  if (error) return res.status(400).json({ error: error.message });
+  broadcast("task_added", data);
+  res.json({ task: data });
+});
+
+// PATCH update task status manually
+app.patch("/api/tasks/:id", async (req, res) => {
+  const { id } = req.params;
+  const updates = req.body;
+
+  await supabase.from("cb_tasks").update(updates).eq("id", id);
+  broadcast("task_update", { id, ...updates });
+  res.json({ ok: true });
+});
+
+// GET logs for a specific task
+app.get("/api/tasks/:id/logs", async (req, res) => {
+  const { data } = await supabase
+    .from("cb_logs")
+    .select("*")
+    .eq("task_id", req.params.id)
+    .order("created_at");
+  res.json({ logs: data || [] });
+});
+
+// Serve dashboard HTML
+app.get("*", (req, res) => {
+  res.sendFile(path.join(__dirname, "index.html"));
+});
+
+// ─── HELPERS ─────────────────────────────────────────────────────────────────
+async function addLog(taskId, message, type = "info") {
+  await supabase.from("cb_logs").insert({
+    project: PROJECT,
+    task_id: taskId,
+    message,
+    type,
+  });
+}
+
+server.listen(PORT, () => {
+  console.log(`READY on port ${PORT}`);
+});

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "claudeboard",
+  "version": "1.0.0",
+  "description": "AI engineering team — from PRD to working mobile app, autonomously",
+  "type": "module",
+  "bin": {
+    "claudeboard": "./bin/cli.js"
+  },
+  "files": [
+    "bin/",
+    "dashboard/",
+    "agents/",
+    "tools/",
+    "sql/",
+    "README.md"
+  ],
+  "dependencies": {
+    "@supabase/supabase-js": "^2.43.1",
+    "chalk": "^5.3.0",
+    "commander": "^12.0.0",
+    "cors": "^2.8.5",
+    "dotenv": "^16.4.5",
+    "enquirer": "^2.4.1",
+    "express": "^4.18.3",
+    "open": "^10.1.0",
+    "ora": "^8.0.1",
+    "puppeteer": "^22.8.0",
+    "ws": "^8.17.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/highvaluedigital/claudeboard"
+  },
+  "author": "highvaluedigital",
+  "license": "MIT",
+  "keywords": [
+    "claude",
+    "ai",
+    "agent",
+    "coding",
+    "automation",
+    "dashboard",
+    "mobile",
+    "expo",
+    "react-native",
+    "prd",
+    "engineering"
+  ]
+}

package/sql/setup.sql

@@ -0,0 +1,57 @@
+-- ClaudeBoard — Supabase Setup
+-- Run this in your Supabase SQL Editor
+
+-- Epics (grouping of tasks)
+create table if not exists cb_epics (
+  id uuid primary key default gen_random_uuid(),
+  project text not null,
+  name text not null,
+  created_at timestamptz default now()
+);
+
+-- Tasks
+create table if not exists cb_tasks (
+  id uuid primary key default gen_random_uuid(),
+  project text not null,
+  epic_id uuid references cb_epics(id) on delete set null,
+  title text not null,
+  description text,
+  status text not null default 'todo', -- todo | in_progress | done | error | blocked
+  priority text default 'medium',      -- high | medium | low
+  priority_order int default 2,
+  type text default 'feature',         -- feature | bug | refactor | test | config
+  started_at timestamptz,
+  completed_at timestamptz,
+  created_at timestamptz default now()
+);
+
+-- Logs (activity feed)
+create table if not exists cb_logs (
+  id uuid primary key default gen_random_uuid(),
+  project text not null,
+  task_id uuid references cb_tasks(id) on delete cascade,
+  message text not null,
+  type text default 'info',  -- start | progress | complete | error | info
+  created_at timestamptz default now()
+);
+
+-- Indexes
+create index if not exists idx_tasks_project on cb_tasks(project);
+create index if not exists idx_tasks_status on cb_tasks(status);
+create index if not exists idx_tasks_priority on cb_tasks(priority_order);
+create index if not exists idx_logs_task on cb_logs(task_id);
+create index if not exists idx_logs_project on cb_logs(project);
+
+-- Enable Realtime
+alter publication supabase_realtime add table cb_tasks;
+alter publication supabase_realtime add table cb_logs;
+alter publication supabase_realtime add table cb_epics;
+
+-- RLS (Row Level Security) — permissive for local dev
+alter table cb_epics enable row level security;
+alter table cb_tasks enable row level security;
+alter table cb_logs enable row level security;
+
+create policy "allow_all_epics" on cb_epics for all using (true) with check (true);
+create policy "allow_all_tasks" on cb_tasks for all using (true) with check (true);
+create policy "allow_all_logs" on cb_logs for all using (true) with check (true);

package/tools/filesystem.js

@@ -0,0 +1,95 @@
+import fs from "fs";
+import path from "path";
+
+/**
+ * Read a file, return content string or null
+ */
+export function readFile(filePath) {
+  try {
+    return fs.readFileSync(filePath, "utf8");
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Write a file (creates dirs if needed)
+ */
+export function writeFile(filePath, content) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, content, "utf8");
+}
+
+/**
+ * List files in a directory recursively (ignores node_modules, .git, etc)
+ */
+export function listFiles(dir, extensions = null, maxDepth = 4) {
+  const results = [];
+  const IGNORE = new Set(["node_modules", ".git", ".expo", "dist", "build", ".next", "coverage"]);
+
+  function walk(current, depth) {
+    if (depth > maxDepth) return;
+    let entries;
+    try { entries = fs.readdirSync(current, { withFileTypes: true }); } catch { return; }
+
+    for (const entry of entries) {
+      if (IGNORE.has(entry.name)) continue;
+      const fullPath = path.join(current, entry.name);
+      if (entry.isDirectory()) {
+        walk(fullPath, depth + 1);
+      } else if (!extensions || extensions.some((ext) => entry.name.endsWith(ext))) {
+        results.push(fullPath);
+      }
+    }
+  }
+
+  walk(dir, 0);
+  return results;
+}
+
+/**
+ * Get a compact project tree string (for LLM context)
+ */
+export function projectTree(dir, maxDepth = 3) {
+  const IGNORE = new Set(["node_modules", ".git", ".expo", "dist", "build", ".next"]);
+  const lines = [];
+
+  function walk(current, depth, prefix) {
+    if (depth > maxDepth) return;
+    let entries;
+    try { entries = fs.readdirSync(current, { withFileTypes: true }); } catch { return; }
+
+    const filtered = entries.filter((e) => !IGNORE.has(e.name));
+    filtered.forEach((entry, i) => {
+      const isLast = i === filtered.length - 1;
+      const connector = isLast ? "└── " : "├── ";
+      lines.push(prefix + connector + entry.name);
+      if (entry.isDirectory()) {
+        walk(
+          path.join(current, entry.name),
+          depth + 1,
+          prefix + (isLast ? "    " : "│   ")
+        );
+      }
+    });
+  }
+
+  lines.push(path.basename(dir) + "/");
+  walk(dir, 0, "");
+  return lines.join("\n");
+}
+
+/**
+ * Read multiple files and return as context string
+ */
+export function readFilesAsContext(filePaths, projectRoot) {
+  return filePaths
+    .map((fp) => {
+      const content = readFile(fp);
+      if (!content) return null;
+      const rel = path.relative(projectRoot, fp);
+      return `### ${rel}\n\`\`\`\n${content.slice(0, 3000)}\n\`\`\``;
+    })
+    .filter(Boolean)
+    .join("\n\n");
+}

package/tools/screenshot.js

@@ -0,0 +1,74 @@
+import { runCommand, waitForPort } from "./terminal.js";
+import fs from "fs";
+import path from "path";
+
+let puppeteer = null;
+
+async function getPuppeteer() {
+  if (!puppeteer) {
+    try {
+      const mod = await import("puppeteer");
+      puppeteer = mod.default;
+    } catch {
+      return null;
+    }
+  }
+  return puppeteer;
+}
+
+/**
+ * Take a screenshot of a running Expo Web app
+ * Returns { success, imagePath, base64, error }
+ */
+export async function screenshotExpoWeb(port = 8081, outputDir, pagePath = "/") {
+  const p = await getPuppeteer();
+  if (!p) {
+    return { success: false, error: "puppeteer not installed — run: npm install puppeteer" };
+  }
+
+  const url = `http://localhost:${port}${pagePath}`;
+  const filename = `screenshot-${Date.now()}.png`;
+  const imagePath = path.join(outputDir, filename);
+
+  fs.mkdirSync(outputDir, { recursive: true });
+
+  let browser;
+  try {
+    browser = await p.launch({
+      headless: "new",
+      args: ["--no-sandbox", "--disable-setuid-sandbox"],
+    });
+
+    const page = await browser.newPage();
+
+    // Mobile viewport — Expo apps are mobile-first
+    await page.setViewport({ width: 390, height: 844, deviceScaleFactor: 2 });
+
+    await page.goto(url, { waitUntil: "networkidle2", timeout: 30000 });
+
+    // Wait a bit for React to render
+    await new Promise((r) => setTimeout(r, 2000));
+
+    await page.screenshot({ path: imagePath, fullPage: false });
+
+    const base64 = fs.readFileSync(imagePath).toString("base64");
+
+    return { success: true, imagePath, base64, url };
+  } catch (err) {
+    return { success: false, error: err.message };
+  } finally {
+    if (browser) await browser.close();
+  }
+}
+
+/**
+ * Take multiple screenshots navigating through routes
+ */
+export async function screenshotRoutes(port = 8081, routes = ["/"], outputDir) {
+  const results = [];
+  for (const route of routes) {
+    const result = await screenshotExpoWeb(port, outputDir, route);
+    results.push({ route, ...result });
+  }
+  return results;
+}

package/tools/supabase-reader.js

@@ -0,0 +1,74 @@
+import { createClient } from "@supabase/supabase-js";
+
+let client = null;
+
+export function initSupabaseReader(url, key) {
+  client = createClient(url, key);
+}
+
+/**
+ * Read recent logs from a logs table
+ * Returns array of log entries
+ */
+export async function readRecentLogs(table = "logs", limit = 50) {
+  if (!client) return [];
+  try {
+    const { data, error } = await client
+      .from(table)
+      .select("*")
+      .order("created_at", { ascending: false })
+      .limit(limit);
+    if (error) return [{ error: error.message }];
+    return data || [];
+  } catch (err) {
+    return [{ error: err.message }];
+  }
+}
+
+/**
+ * Read error logs specifically
+ */
+export async function readErrorLogs(table = "logs", limit = 20) {
+  if (!client) return [];
+  try {
+    const { data } = await client
+      .from(table)
+      .select("*")
+      .or("level.eq.error,level.eq.Error,type.eq.error")
+      .order("created_at", { ascending: false })
+      .limit(limit);
+    return data || [];
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * List all tables in the project's Supabase
+ */
+export async function listTables() {
+  if (!client) return [];
+  try {
+    const { data } = await client
+      .from("information_schema.tables")
+      .select("table_name")
+      .eq("table_schema", "public");
+    return data?.map((r) => r.table_name) || [];
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Sample data from a table (for QA context)
+ */
+export async function sampleTable(tableName, limit = 5) {
+  if (!client) return [];
+  try {
+    const { data, error } = await client.from(tableName).select("*").limit(limit);
+    if (error) return [{ error: error.message }];
+    return data || [];
+  } catch (err) {
+    return [{ error: err.message }];
+  }
+}

package/tools/terminal.js

@@ -0,0 +1,58 @@
+import { exec, spawn } from "child_process";
+import { promisify } from "util";
+
+const execAsync = promisify(exec);
+
+/**
+ * Run a shell command in a given directory, return { stdout, stderr, exitCode }
+ */
+export async function runCommand(cmd, cwd, timeoutMs = 60000) {
+  try {
+    const { stdout, stderr } = await execAsync(cmd, {
+      cwd,
+      timeout: timeoutMs,
+      env: { ...process.env, CI: "true", FORCE_COLOR: "0" },
+    });
+    return { stdout: stdout.trim(), stderr: stderr.trim(), exitCode: 0 };
+  } catch (err) {
+    return {
+      stdout: err.stdout?.trim() || "",
+      stderr: err.stderr?.trim() || err.message,
+      exitCode: err.code || 1,
+    };
+  }
+}
+
+/**
+ * Start a long-running process (e.g. expo start) and return kill function + log stream
+ */
+export function startProcess(cmd, args, cwd, onLog) {
+  const proc = spawn(cmd, args, {
+    cwd,
+    env: { ...process.env, FORCE_COLOR: "0" },
+    stdio: ["ignore", "pipe", "pipe"],
+  });
+
+  proc.stdout.on("data", (d) => onLog(d.toString()));
+  proc.stderr.on("data", (d) => onLog(d.toString()));
+
+  return {
+    kill: () => proc.kill("SIGTERM"),
+    pid: proc.pid,
+  };
+}
+
+/**
+ * Check if a port is in use
+ */
+export async function waitForPort(port, timeoutMs = 30000) {
+  const start = Date.now();
+  while (Date.now() - start < timeoutMs) {
+    try {
+      const result = await execAsync(`curl -s -o /dev/null -w "%{http_code}" http://localhost:${port}`);
+      if (result.stdout !== "000") return true;
+    } catch {}
+    await new Promise((r) => setTimeout(r, 1000));
+  }
+  return false;
+}