openclaw-node-harness 2.0.0

package/mission-control/scripts/import-pipeline.js

@@ -0,0 +1,295 @@
+#!/usr/bin/env node
+/**
+ * import-pipeline.js — Bulk import Arcane Rapture pipeline into Mission Control DB.
+ *
+ * Creates: 1 project + 3 phases + 8 months (pipeline nodes) + 233 tasks + all dependencies.
+ * Safe to re-run: deletes existing ARCANE-* entries first.
+ *
+ * Usage: node scripts/import-pipeline.js [--dry-run]
+ */
+
+const Database = require("better-sqlite3");
+const fs = require("fs");
+const path = require("path");
+
+const DRY_RUN = process.argv.includes("--dry-run");
+const DB_PATH = path.join(__dirname, "..", "data", "mission-control.db");
+const PIPELINE_JSON = path.join(
+  __dirname,
+  "..",
+  "..",
+  "arcane",
+  "pipeline-data.json"
+);
+
+// Department → color mapping
+const DEPT_COLORS = {
+  DEV: "#3B82F6",
+  CHAIN: "#8B5CF6",
+  ART: "#EC4899",
+  DESIGN: "#F59E0B",
+  QA: "#10B981",
+  INFRA: "#6B7280",
+  MKT: "#EF4444",
+  COMM: "#06B6D4",
+  BIZ: "#22C55E",
+  LEGAL: "#F97316",
+  HIRE: "#A855F7",
+};
+
+function main() {
+  if (!fs.existsSync(PIPELINE_JSON)) {
+    console.error(`Pipeline data not found: ${PIPELINE_JSON}`);
+    process.exit(1);
+  }
+
+  const data = JSON.parse(fs.readFileSync(PIPELINE_JSON, "utf-8"));
+  console.log(
+    `Loaded pipeline: ${data.phases.length} phases, ${data.months.length} months, ${data.tasks.length} tasks`
+  );
+
+  if (DRY_RUN) {
+    console.log("[DRY RUN] Would import the following:");
+    console.log(`  1 project: ARCANE-RAPTURE`);
+    console.log(`  ${data.phases.length} phases`);
+    console.log(`  ${data.months.length} month pipelines`);
+    console.log(`  ${data.tasks.length} tasks`);
+
+    const depCount = data.tasks.reduce((n, t) => n + t.deps.length, 0);
+    console.log(`  ${depCount} dependencies`);
+    return;
+  }
+
+  // Ensure data dir exists
+  const dataDir = path.dirname(DB_PATH);
+  if (!fs.existsSync(dataDir)) {
+    fs.mkdirSync(dataDir, { recursive: true });
+  }
+
+  const db = new Database(DB_PATH);
+  db.pragma("journal_mode = WAL");
+  db.pragma("foreign_keys = ON");
+
+  // Guard: verify MC runtime migrations have run
+  const cols = db.prepare("PRAGMA table_info(tasks)").all().map(c => c.name);
+  const required = ["type", "parent_id", "project", "start_date", "end_date", "color", "description", "needs_approval"];
+  const missing = required.filter(c => !cols.includes(c));
+  if (missing.length > 0) {
+    console.error(`DB schema missing columns: ${missing.join(", ")}`);
+    console.error("Start Mission Control first (npm run dev) to run migrations, then re-run this script.");
+    process.exit(1);
+  }
+  const tables = db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='dependencies'").get();
+  if (!tables) {
+    console.error("DB missing 'dependencies' table. Start Mission Control first to run migrations.");
+    process.exit(1);
+  }
+
+  // Wrap everything in a transaction
+  const importAll = db.transaction(() => {
+    // 1. Clean existing ARCANE pipeline entries (safe re-run)
+    // Build the full set of IDs we're about to import
+    const importIds = new Set([
+      "ARCANE-RAPTURE",
+      ...data.phases.map((p) => p.id),
+      ...data.months.map((m) => m.id),
+      ...data.tasks.map((t) => t.id),
+    ]);
+
+    // Delete ALL dependencies that reference any of these IDs
+    const allDepRows = db
+      .prepare(`SELECT id, source_id, target_id FROM dependencies`)
+      .all();
+    const deleteDep = db.prepare(`DELETE FROM dependencies WHERE id = ?`);
+    let depsDeleted = 0;
+    for (const row of allDepRows) {
+      if (importIds.has(row.source_id) || importIds.has(row.target_id)) {
+        deleteDep.run(row.id);
+        depsDeleted++;
+      }
+    }
+
+    // Delete ALL tasks that match our import IDs
+    const deleteTask = db.prepare(`DELETE FROM tasks WHERE id = ?`);
+    let tasksDeleted = 0;
+    for (const id of importIds) {
+      const result = deleteTask.run(id);
+      tasksDeleted += result.changes;
+    }
+
+    if (tasksDeleted > 0 || depsDeleted > 0) {
+      console.log(
+        `Cleaned ${tasksDeleted} existing tasks, ${depsDeleted} dependencies`
+      );
+    }
+
+    const now = new Date().toISOString();
+
+    // 2. Create the project
+    const insertTask = db.prepare(`
+      INSERT INTO tasks (id, title, status, kanban_column, type, parent_id, project,
+        start_date, end_date, color, description, owner, needs_approval,
+        updated_at, created_at, sort_order)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+
+    insertTask.run(
+      "ARCANE-RAPTURE",
+      "Arcane Rapture — Master Pipeline",
+      "queued",
+      "backlog",
+      "project",
+      null,
+      "arcane-rapture",
+      "2026-03-01",
+      "2026-10-31",
+      "#1E40AF",
+      "Full execution pipeline: 11 departments, 8 months, 233 tasks. Extracted from Master Unified Pipeline document.",
+      null,
+      1,
+      now,
+      now,
+      0
+    );
+    console.log("Created project: ARCANE-RAPTURE");
+
+    // 3. Create phases
+    for (let i = 0; i < data.phases.length; i++) {
+      const p = data.phases[i];
+      insertTask.run(
+        p.id,
+        p.title,
+        "queued",
+        "backlog",
+        "phase",
+        "ARCANE-RAPTURE",
+        "arcane-rapture",
+        p.startDate,
+        p.endDate,
+        p.color,
+        `Months ${p.months}`,
+        null,
+        1,
+        now,
+        now,
+        i + 1
+      );
+    }
+    console.log(`Created ${data.phases.length} phases`);
+
+    // 4. Create month pipeline nodes
+    for (let i = 0; i < data.months.length; i++) {
+      const m = data.months[i];
+      insertTask.run(
+        m.id,
+        m.title,
+        "queued",
+        "backlog",
+        "pipeline",
+        m.phase,
+        "arcane-rapture",
+        m.startDate,
+        m.endDate,
+        null,
+        null,
+        null,
+        1,
+        now,
+        now,
+        i + 1
+      );
+    }
+    console.log(`Created ${data.months.length} month pipelines`);
+
+    // 5. Create all tasks
+    // Build a set of valid task IDs for dependency validation
+    const validIds = new Set(data.tasks.map((t) => t.id));
+    let skippedDeps = 0;
+
+    for (let i = 0; i < data.tasks.length; i++) {
+      const t = data.tasks[i];
+      const monthId = `ARCANE-M${String(t.month).padStart(2, "0")}`;
+      const month = data.months.find((m) => m.id === monthId);
+      const deptColor = DEPT_COLORS[t.dept] || "#6B7280";
+
+      insertTask.run(
+        t.id,
+        t.title,
+        "queued",
+        "backlog",
+        "task",
+        monthId,
+        "arcane-rapture",
+        month ? month.startDate : null,
+        month ? month.endDate : null,
+        deptColor,
+        t.critical ? `⚠️ CRITICAL PATH — ${t.dept}` : t.dept,
+        null,
+        1,
+        now,
+        now,
+        i + 1
+      );
+    }
+    console.log(`Created ${data.tasks.length} tasks`);
+
+    // 6. Create dependencies
+    const insertDep = db.prepare(`
+      INSERT INTO dependencies (source_id, target_id, type, created_at)
+      VALUES (?, ?, 'finish_to_start', ?)
+    `);
+
+    let depCount = 0;
+    for (const t of data.tasks) {
+      for (const depId of t.deps) {
+        if (validIds.has(depId)) {
+          insertDep.run(depId, t.id, now);
+          depCount++;
+        } else {
+          skippedDeps++;
+        }
+      }
+    }
+    console.log(`Created ${depCount} dependencies`);
+    if (skippedDeps > 0) {
+      console.log(`Skipped ${skippedDeps} deps (unresolvable task IDs)`);
+    }
+
+    // 7. Summary stats
+    const totalTasks = db
+      .prepare(`SELECT COUNT(*) as c FROM tasks WHERE project = 'arcane-rapture'`)
+      .get();
+    const totalDeps = db.prepare(`SELECT COUNT(*) as c FROM dependencies`).get();
+    const criticals = data.tasks.filter((t) => t.critical);
+
+    console.log("\n=== Import Complete ===");
+    console.log(`Total tasks in DB: ${totalTasks.c}`);
+    console.log(`Total dependencies: ${totalDeps.c}`);
+    console.log(
+      `Critical path items: ${criticals.map((t) => t.id).join(", ")}`
+    );
+    console.log(
+      `\nDepartment breakdown:`
+    );
+    const deptCounts = {};
+    for (const t of data.tasks) {
+      deptCounts[t.dept] = (deptCounts[t.dept] || 0) + 1;
+    }
+    for (const [dept, count] of Object.entries(deptCounts).sort(
+      (a, b) => b[1] - a[1]
+    )) {
+      console.log(`  ${dept}: ${count} tasks`);
+    }
+  });
+
+  try {
+    importAll();
+  } catch (err) {
+    console.error("Import failed:", err.message);
+    process.exit(1);
+  }
+
+  db.close();
+}
+
+main();

package/mission-control/src/app/api/activity/live/route.ts

@@ -0,0 +1,27 @@
+import { NextRequest, NextResponse } from "next/server";
+import { getRecentTranscriptActivity } from "@/lib/parsers/transcript";
+
+/**
+ * GET /api/activity/live
+ * Returns recent activity extracted from the Claude JSONL transcript.
+ * This is a read-only, pull-based endpoint — no database writes.
+ */
+export async function GET(request: NextRequest) {
+  try {
+    const { searchParams } = request.nextUrl;
+    const limit = parseInt(searchParams.get("limit") || "30", 10);
+
+    const events = getRecentTranscriptActivity(Math.min(limit, 100));
+
+    return NextResponse.json({
+      events,
+      count: events.length,
+    });
+  } catch (err) {
+    console.error("GET /api/activity/live error:", err);
+    return NextResponse.json(
+      { error: "Failed to read transcript activity" },
+      { status: 500 }
+    );
+  }
+}

package/mission-control/src/app/api/activity/route.ts

@@ -0,0 +1,47 @@
+import { NextRequest, NextResponse } from "next/server";
+import { logActivity, getRecentActivity } from "@/lib/activity";
+
+/**
+ * GET /api/activity?limit=50
+ * Returns recent activity log entries, newest first.
+ */
+export async function GET(request: NextRequest) {
+  try {
+    const limit = parseInt(
+      request.nextUrl.searchParams.get("limit") || "50",
+      10
+    );
+    const entries = getRecentActivity(Math.min(limit, 200));
+    return NextResponse.json(entries);
+  } catch (err) {
+    console.error("GET /api/activity error:", err);
+    return NextResponse.json(
+      { error: "Failed to fetch activity" },
+      { status: 500 }
+    );
+  }
+}
+
+/**
+ * POST /api/activity
+ * Log a custom activity event. Body: { event_type, description, task_id? }
+ */
+export async function POST(request: NextRequest) {
+  try {
+    const body = await request.json();
+    if (!body.event_type || !body.description) {
+      return NextResponse.json(
+        { error: "event_type and description are required" },
+        { status: 400 }
+      );
+    }
+    logActivity(body.event_type, body.description, body.task_id);
+    return NextResponse.json({ ok: true }, { status: 201 });
+  } catch (err) {
+    console.error("POST /api/activity error:", err);
+    return NextResponse.json(
+      { error: "Failed to log activity" },
+      { status: 500 }
+    );
+  }
+}

package/mission-control/src/app/api/burndown/route.ts

@@ -0,0 +1,112 @@
+import { NextRequest, NextResponse } from "next/server";
+import { getRawDb } from "@/lib/db";
+
+/**
+ * GET /api/burndown?projectId=X
+ * Returns task status counts and a done-over-time timeline for burndown charts.
+ */
+export async function GET(request: NextRequest) {
+  try {
+    const { searchParams } = request.nextUrl;
+    const projectId = searchParams.get("projectId");
+    const raw = getRawDb();
+
+    let statusRows: Array<{ status: string; count: number }>;
+    let startDate: string | null = null;
+    let endDate: string | null = null;
+    let doneTimeline: Array<{ date: string; count: number }>;
+
+    if (projectId) {
+      statusRows = raw
+        .prepare(
+          `WITH RECURSIVE tree AS (
+            SELECT id, type, status FROM tasks WHERE id = ?
+            UNION ALL
+            SELECT t.id, t.type, t.status FROM tasks t JOIN tree ON t.parent_id = tree.id
+          )
+          SELECT status, COUNT(*) as count FROM tree
+          WHERE type = 'task' OR type IS NULL
+          GROUP BY status`
+        )
+        .all(projectId) as Array<{ status: string; count: number }>;
+
+      const dateRange = raw
+        .prepare(
+          `WITH RECURSIVE tree AS (
+            SELECT id, start_date, end_date FROM tasks WHERE id = ?
+            UNION ALL
+            SELECT t.id, t.start_date, t.end_date FROM tasks t JOIN tree ON t.parent_id = tree.id
+          )
+          SELECT MIN(start_date) as min_date, MAX(end_date) as max_date FROM tree`
+        )
+        .get(projectId) as { min_date: string | null; max_date: string | null };
+      startDate = dateRange?.min_date ?? null;
+      endDate = dateRange?.max_date ?? null;
+
+      // Timeline: done tasks grouped by updatedAt date
+      doneTimeline = raw
+        .prepare(
+          `WITH RECURSIVE tree AS (
+            SELECT id FROM tasks WHERE id = ?
+            UNION ALL
+            SELECT t.id FROM tasks t JOIN tree ON t.parent_id = tree.id
+          )
+          SELECT DATE(t.updated_at) as date, COUNT(*) as count
+          FROM tasks t
+          WHERE t.id IN (SELECT id FROM tree)
+            AND t.status IN ('done', 'cancelled')
+            AND (t.type = 'task' OR t.type IS NULL)
+          GROUP BY DATE(t.updated_at)
+          ORDER BY date`
+        )
+        .all(projectId) as Array<{ date: string; count: number }>;
+    } else {
+      statusRows = raw
+        .prepare(
+          `SELECT status, COUNT(*) as count FROM tasks
+          WHERE type = 'task' OR type IS NULL
+          GROUP BY status`
+        )
+        .all() as Array<{ status: string; count: number }>;
+
+      doneTimeline = raw
+        .prepare(
+          `SELECT DATE(updated_at) as date, COUNT(*) as count
+          FROM tasks
+          WHERE status IN ('done', 'cancelled')
+            AND (type = 'task' OR type IS NULL)
+          GROUP BY DATE(updated_at)
+          ORDER BY date`
+        )
+        .all() as Array<{ date: string; count: number }>;
+    }
+
+    const counts: Record<string, number> = {};
+    let total = 0;
+    for (const row of statusRows) {
+      counts[row.status] = row.count;
+      total += row.count;
+    }
+
+    // Build cumulative done series
+    let cumDone = 0;
+    const timeline = doneTimeline.map((d) => {
+      cumDone += d.count;
+      return { date: d.date, done: cumDone, remaining: total - cumDone };
+    });
+
+    return NextResponse.json({
+      total,
+      counts,
+      startDate,
+      endDate,
+      timeline,
+    });
+  } catch (err) {
+    console.error("GET /api/burndown error:", err);
+    return NextResponse.json(
+      { error: "Failed to compute burndown" },
+      { status: 500 }
+    );
+  }
+}

package/mission-control/src/app/api/critical-path/route.ts

@@ -0,0 +1,159 @@
+import { NextRequest, NextResponse } from "next/server";
+import { getRawDb } from "@/lib/db";
+
+interface TaskRow {
+  id: string;
+  start_date: string | null;
+  end_date: string | null;
+  type: string | null;
+}
+
+/**
+ * GET /api/critical-path?projectId=X
+ * Computes the critical path through the dependency DAG using
+ * forward/backward pass (ES/EF/LS/LF). Tasks with zero float are critical.
+ */
+export async function GET(request: NextRequest) {
+  try {
+    const { searchParams } = request.nextUrl;
+    const projectId = searchParams.get("projectId");
+    if (!projectId) {
+      return NextResponse.json(
+        { error: "projectId required" },
+        { status: 400 }
+      );
+    }
+
+    const raw = getRawDb();
+
+    // Get subtree tasks
+    const taskRows = raw
+      .prepare(
+        `WITH RECURSIVE tree AS (
+          SELECT id, start_date, end_date, type FROM tasks WHERE id = ?
+          UNION ALL
+          SELECT t.id, t.start_date, t.end_date, t.type
+          FROM tasks t JOIN tree ON t.parent_id = tree.id
+        )
+        SELECT * FROM tree`
+      )
+      .all(projectId) as TaskRow[];
+
+    const taskIds = new Set(taskRows.map((t) => t.id));
+
+    // Get dependencies within subtree (using the same recursive CTE)
+    const depRows = raw
+      .prepare(
+        `WITH RECURSIVE tree AS (
+          SELECT id FROM tasks WHERE id = ?
+          UNION ALL
+          SELECT t.id FROM tasks t JOIN tree ON t.parent_id = tree.id
+        )
+        SELECT d.source_id, d.target_id FROM dependencies d
+        WHERE d.source_id IN (SELECT id FROM tree)
+          AND d.target_id IN (SELECT id FROM tree)`
+      )
+      .all(projectId) as Array<{ source_id: string; target_id: string }>;
+
+    // No dependencies → no critical path to compute
+    if (depRows.length === 0) {
+      return NextResponse.json({ criticalPath: [], totalDuration: 0 });
+    }
+
+    // Compute task durations (in days)
+    const duration = new Map<string, number>();
+    for (const t of taskRows) {
+      if (t.start_date && t.end_date) {
+        const ms =
+          new Date(t.end_date).getTime() - new Date(t.start_date).getTime();
+        duration.set(t.id, Math.max(1, Math.ceil(ms / 86400000)));
+      } else {
+        duration.set(t.id, 1);
+      }
+    }
+
+    // Build adjacency lists
+    const successors = new Map<string, string[]>();
+    const predecessors = new Map<string, string[]>();
+    const inDegree = new Map<string, number>();
+
+    for (const id of taskIds) {
+      successors.set(id, []);
+      predecessors.set(id, []);
+      inDegree.set(id, 0);
+    }
+
+    for (const dep of depRows) {
+      successors.get(dep.source_id)!.push(dep.target_id);
+      predecessors.get(dep.target_id)!.push(dep.source_id);
+      inDegree.set(
+        dep.target_id,
+        (inDegree.get(dep.target_id) || 0) + 1
+      );
+    }
+
+    // Topological sort (Kahn's algorithm)
+    const queue: string[] = [];
+    for (const [id, deg] of inDegree) {
+      if (deg === 0) queue.push(id);
+    }
+    const topoOrder: string[] = [];
+    const degCopy = new Map(inDegree);
+    const topoQueue = [...queue];
+    while (topoQueue.length > 0) {
+      const node = topoQueue.shift()!;
+      topoOrder.push(node);
+      for (const succ of successors.get(node) || []) {
+        const nd = (degCopy.get(succ) || 1) - 1;
+        degCopy.set(succ, nd);
+        if (nd === 0) topoQueue.push(succ);
+      }
+    }
+
+    // Forward pass: ES[i] = max(EF[predecessors]), EF[i] = ES[i] + duration[i]
+    const ES = new Map<string, number>();
+    const EF = new Map<string, number>();
+    for (const node of topoOrder) {
+      const preds = predecessors.get(node) || [];
+      const es =
+        preds.length > 0
+          ? Math.max(...preds.map((p) => EF.get(p) || 0))
+          : 0;
+      ES.set(node, es);
+      EF.set(node, es + (duration.get(node) || 1));
+    }
+
+    const projectDuration = Math.max(0, ...Array.from(EF.values()));
+
+    // Backward pass: LF[i] = min(LS[successors]), LS[i] = LF[i] - duration[i]
+    const LS = new Map<string, number>();
+    const LF = new Map<string, number>();
+    for (let i = topoOrder.length - 1; i >= 0; i--) {
+      const node = topoOrder[i];
+      const succs = successors.get(node) || [];
+      const lf =
+        succs.length > 0
+          ? Math.min(...succs.map((s) => LS.get(s) || projectDuration))
+          : projectDuration;
+      LF.set(node, lf);
+      LS.set(node, lf - (duration.get(node) || 1));
+    }
+
+    // Critical path: tasks with zero float (LS - ES ≈ 0)
+    const criticalPath: string[] = [];
+    for (const id of topoOrder) {
+      const float = (LS.get(id) || 0) - (ES.get(id) || 0);
+      if (Math.abs(float) < 0.001) {
+        criticalPath.push(id);
+      }
+    }
+
+    return NextResponse.json({ criticalPath, totalDuration: projectDuration });
+  } catch (err) {
+    console.error("GET /api/critical-path error:", err);
+    return NextResponse.json(
+      { error: "Failed to compute critical path" },
+      { status: 500 }
+    );
+  }
+}