feat: hai board — core, dashboard, cli, engine

packages/dashboard/src/index.ts

@@ -0,0 +1 @@
+export { createServer } from "./server.js";

packages/dashboard/src/routes.ts

@@ -0,0 +1,105 @@
+import { Router } from "express";
+import type { TaskStore, Column } from "@hai/core";
+import { COLUMNS } from "@hai/core";
+
+export function createApiRoutes(store: TaskStore): Router {
+  const router = Router();
+
+  // List all tasks
+  router.get("/tasks", async (_req, res) => {
+    try {
+      const tasks = await store.listTasks();
+      res.json(tasks);
+    } catch (err: any) {
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  // Get single task with prompt content
+  router.get("/tasks/:id", async (req, res) => {
+    try {
+      const task = await store.getTask(req.params.id);
+      res.json(task);
+    } catch (err: any) {
+      res.status(404).json({ error: `Task ${req.params.id} not found` });
+    }
+  });
+
+  // Create task
+  router.post("/tasks", async (req, res) => {
+    try {
+      const { title, description, column, dependencies } = req.body;
+      if (!title || typeof title !== "string") {
+        res.status(400).json({ error: "title is required" });
+        return;
+      }
+      const task = await store.createTask({
+        title,
+        description,
+        column,
+        dependencies,
+      });
+      res.status(201).json(task);
+    } catch (err: any) {
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  // Move task to column
+  router.post("/tasks/:id/move", async (req, res) => {
+    try {
+      const { column } = req.body;
+      if (!column || !COLUMNS.includes(column as Column)) {
+        res.status(400).json({
+          error: `Invalid column. Must be one of: ${COLUMNS.join(", ")}`,
+        });
+        return;
+      }
+      const task = await store.moveTask(req.params.id, column as Column);
+      res.json(task);
+    } catch (err: any) {
+      const status = err.message.includes("Invalid transition") ? 400 : 500;
+      res.status(status).json({ error: err.message });
+    }
+  });
+
+  // Update task
+  router.patch("/tasks/:id", async (req, res) => {
+    try {
+      const { title, description, prompt } = req.body;
+      const task = await store.updateTask(req.params.id, {
+        title,
+        description,
+        prompt,
+      });
+      res.json(task);
+    } catch (err: any) {
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  // Merge task (in-review → done, merges branch + cleans worktree)
+  router.post("/tasks/:id/merge", async (req, res) => {
+    try {
+      const result = await store.mergeTask(req.params.id);
+      res.json(result);
+    } catch (err: any) {
+      const status = err.message.includes("Cannot merge") ? 400
+        : err.message.includes("Merge conflict") ? 409
+        : 500;
+      res.status(status).json({ error: err.message });
+    }
+  });
+
+  // Delete task
+  router.delete("/tasks/:id", async (req, res) => {
+    try {
+      const task = await store.deleteTask(req.params.id);
+      res.json(task);
+    } catch (err: any) {
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  return router;
+}

packages/dashboard/src/server.ts

@@ -0,0 +1,28 @@
+import express from "express";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import type { TaskStore } from "@hai/core";
+import { createApiRoutes } from "./routes.js";
+import { createSSE } from "./sse.js";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+export function createServer(store: TaskStore) {
+  const app = express();
+
+  app.use(express.json());
+  app.use(express.static(join(__dirname, "..", "public")));
+
+  // SSE endpoint
+  app.get("/api/events", createSSE(store));
+
+  // REST API
+  app.use("/api", createApiRoutes(store));
+
+  // SPA fallback
+  app.get("/{*splat}", (_req, res) => {
+    res.sendFile(join(__dirname, "..", "public", "index.html"));
+  });
+
+  return app;
+}

packages/dashboard/src/sse.ts

@@ -0,0 +1,51 @@
+import type { Request, Response } from "express";
+import type { TaskStore } from "@hai/core";
+
+export function createSSE(store: TaskStore) {
+  return (_req: Request, res: Response) => {
+    res.setHeader("Content-Type", "text/event-stream");
+    res.setHeader("Cache-Control", "no-cache");
+    res.setHeader("Connection", "keep-alive");
+    res.setHeader("X-Accel-Buffering", "no");
+    res.flushHeaders();
+
+    // Send initial heartbeat
+    res.write(": connected\n\n");
+
+    const onCreated = (task: any) => {
+      res.write(`event: task:created\ndata: ${JSON.stringify(task)}\n\n`);
+    };
+    const onMoved = (data: any) => {
+      res.write(`event: task:moved\ndata: ${JSON.stringify(data)}\n\n`);
+    };
+    const onUpdated = (task: any) => {
+      res.write(`event: task:updated\ndata: ${JSON.stringify(task)}\n\n`);
+    };
+    const onDeleted = (task: any) => {
+      res.write(`event: task:deleted\ndata: ${JSON.stringify(task)}\n\n`);
+    };
+    const onMerged = (result: any) => {
+      res.write(`event: task:merged\ndata: ${JSON.stringify(result)}\n\n`);
+    };
+
+    store.on("task:created", onCreated);
+    store.on("task:moved", onMoved);
+    store.on("task:updated", onUpdated);
+    store.on("task:deleted", onDeleted);
+    store.on("task:merged", onMerged);
+
+    // Heartbeat every 30s to keep connection alive
+    const heartbeat = setInterval(() => {
+      res.write(": heartbeat\n\n");
+    }, 30_000);
+
+    _req.on("close", () => {
+      clearInterval(heartbeat);
+      store.off("task:created", onCreated);
+      store.off("task:moved", onMoved);
+      store.off("task:updated", onUpdated);
+      store.off("task:deleted", onDeleted);
+      store.off("task:merged", onMerged);
+    });
+  };
+}