ralphflow 0.5.0 → 0.5.2

package/dist/{server-DOSLU36L.js → server-EX5MWYW4.js}

@@ -1,5 +1,6 @@
 import {
   BUILT_IN_TEMPLATES,
+  cloneBuiltInTemplate,
   copyTemplate,
   createCustomTemplate,
   deleteCustomTemplate,
@@ -14,14 +15,14 @@ import {
   resolveFlowDir,
   resolveTemplatePathWithCustom,
   validateTemplateName
-} from "./chunk-TCCMQDVT.js";
+} from "./chunk-DOC64TD6.js";
 
 // src/dashboard/server.ts
 import { Hono as Hono2 } from "hono";
 import { cors } from "hono/cors";
 import { serve } from "@hono/node-server";
 import { readFileSync as readFileSync3, existsSync as existsSync3 } from "fs";
-import { join as join4, dirname } from "path";
+import { join as join4, dirname, extname } from "path";
 import { fileURLToPath } from "url";
 import { WebSocketServer as WebSocketServer3 } from "ws";
 import chalk from "chalk";
@@ -34,6 +35,7 @@ import { randomUUID } from "crypto";
 import { WebSocket } from "ws";
 import { parse as parseYaml, stringify as stringifyYaml } from "yaml";
 var notifications = [];
+var decisions = [];
 function broadcastWs(wss, event) {
   if (!wss) return;
   const data = JSON.stringify(event);
@@ -68,7 +70,9 @@ function createApiRoutes(cwd, port = 4242, wss) {
           order: loop.order,
           stages: loop.stages,
           multiAgent: !!(loop.multi_agent && typeof loop.multi_agent === "object" && loop.multi_agent.enabled),
-          model: loop.model || null
+          model: loop.model || null,
+          feeds: loop.feeds || [],
+          fed_by: loop.fed_by || []
         }))
       };
     });
@@ -133,6 +137,11 @@ function createApiRoutes(cwd, port = 4242, wss) {
         notifications.splice(i, 1);
       }
     }
+    for (let i = decisions.length - 1; i >= 0; i--) {
+      if (decisions[i].app === appName) {
+        decisions.splice(i, 1);
+      }
+    }
     return c.json({ ok: true, appName });
   });
   api.post("/api/apps/:app/archive", (c) => {
@@ -209,6 +218,11 @@ function createApiRoutes(cwd, port = 4242, wss) {
           notifications.splice(i, 1);
         }
       }
+      for (let i = decisions.length - 1; i >= 0; i--) {
+        if (decisions[i].app === appName) {
+          decisions.splice(i, 1);
+        }
+      }
       const archivePath = `.ralph-flow/.archives/${appName}/${archiveTimestamp}`;
       return c.json({ ok: true, archivePath, timestamp: archiveTimestamp });
     } catch (err) {
@@ -461,6 +475,138 @@ function createApiRoutes(cwd, port = 4242, wss) {
     }
     return c.json({ ok: true, templateName: name });
   });
+  api.post("/api/templates/:name/clone", async (c) => {
+    const sourceName = c.req.param("name");
+    if (sourceName.includes("..") || sourceName.includes("/") || sourceName.includes("\\")) {
+      return c.json({ error: 'Invalid name: must not contain "..", "/", or "\\"' }, 400);
+    }
+    if (!BUILT_IN_TEMPLATES.includes(sourceName)) {
+      return c.json({ error: `"${sourceName}" is not a built-in template. Only built-in templates can be cloned.` }, 400);
+    }
+    let body;
+    try {
+      body = await c.req.json();
+    } catch {
+      return c.json({ error: "Invalid JSON body" }, 400);
+    }
+    const { newName } = body;
+    if (!newName || newName.trim().length === 0) {
+      return c.json({ error: "newName is required" }, 400);
+    }
+    const validation = validateTemplateName(newName.trim());
+    if (!validation.valid) {
+      return c.json({ error: validation.error }, 400);
+    }
+    const customDir = join(cwd, ".ralph-flow", ".templates", newName.trim());
+    if (existsSync(customDir)) {
+      return c.json({ error: `Template "${newName.trim()}" already exists` }, 409);
+    }
+    try {
+      cloneBuiltInTemplate(cwd, sourceName, newName.trim());
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      if (msg.includes("already exists")) {
+        return c.json({ error: msg }, 409);
+      }
+      return c.json({ error: `Clone failed: ${msg}` }, 500);
+    }
+    return c.json({
+      ok: true,
+      source: sourceName,
+      templateName: newName.trim(),
+      message: `Template "${sourceName}" cloned as "${newName.trim()}"`
+    }, 201);
+  });
+  api.get("/api/templates/:name/config", (c) => {
+    const name = c.req.param("name");
+    if (name.includes("..") || name.includes("/") || name.includes("\\")) {
+      return c.json({ error: "Invalid name" }, 400);
+    }
+    let templateDir;
+    try {
+      templateDir = resolveTemplatePathWithCustom(name, cwd);
+    } catch {
+      return c.json({ error: `Template "${name}" not found` }, 404);
+    }
+    try {
+      const config = loadConfig(templateDir);
+      return c.json(config);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      return c.json({ error: msg }, 500);
+    }
+  });
+  api.get("/api/templates/:name/loops/:loopKey/prompt", (c) => {
+    const name = c.req.param("name");
+    const loopKey = c.req.param("loopKey");
+    if (name.includes("..") || name.includes("/") || name.includes("\\")) {
+      return c.json({ error: "Invalid name" }, 400);
+    }
+    if (loopKey.includes("..") || loopKey.includes("/") || loopKey.includes("\\")) {
+      return c.json({ error: "Invalid loop key" }, 400);
+    }
+    let templateDir;
+    try {
+      templateDir = resolveTemplatePathWithCustom(name, cwd);
+    } catch {
+      return c.json({ error: `Template "${name}" not found` }, 404);
+    }
+    let config;
+    try {
+      config = loadConfig(templateDir);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      return c.json({ error: msg }, 500);
+    }
+    const loopConfig = config.loops[loopKey];
+    if (!loopConfig) {
+      return c.json({ error: `Loop "${loopKey}" not found in template` }, 404);
+    }
+    const promptPath = resolve(templateDir, "loops", loopConfig.prompt);
+    if (!promptPath.startsWith(resolve(templateDir))) {
+      return c.json({ error: "Invalid path" }, 403);
+    }
+    if (!existsSync(promptPath)) {
+      return c.json({ error: "prompt.md not found", content: "" }, 404);
+    }
+    const content = readFileSync(promptPath, "utf-8");
+    return c.json({ path: loopConfig.prompt, content });
+  });
+  api.put("/api/templates/:name/loops/:loopKey/prompt", async (c) => {
+    const name = c.req.param("name");
+    const loopKey = c.req.param("loopKey");
+    if (name.includes("..") || name.includes("/") || name.includes("\\")) {
+      return c.json({ error: "Invalid name" }, 400);
+    }
+    if (loopKey.includes("..") || loopKey.includes("/") || loopKey.includes("\\")) {
+      return c.json({ error: "Invalid loop key" }, 400);
+    }
+    if (BUILT_IN_TEMPLATES.includes(name)) {
+      return c.json({ error: "Cannot modify built-in template prompts" }, 403);
+    }
+    const customDir = join(cwd, ".ralph-flow", ".templates", name);
+    if (!existsSync(customDir) || !existsSync(join(customDir, "ralphflow.yaml"))) {
+      return c.json({ error: `Custom template "${name}" not found` }, 404);
+    }
+    let config;
+    try {
+      config = loadConfig(customDir);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      return c.json({ error: msg }, 500);
+    }
+    const loopConfig = config.loops[loopKey];
+    if (!loopConfig) {
+      return c.json({ error: `Loop "${loopKey}" not found in template` }, 404);
+    }
+    const promptPath = resolve(customDir, "loops", loopConfig.prompt);
+    if (!promptPath.startsWith(resolve(customDir))) {
+      return c.json({ error: "Invalid path" }, 403);
+    }
+    const body = await c.req.json();
+    writeFileSync(promptPath, body.content, "utf-8");
+    return c.json({ ok: true });
+  });
   api.post("/api/notification", async (c) => {
     const app = c.req.query("app") || "unknown";
     const loop = c.req.query("loop") || "unknown";
@@ -493,6 +639,45 @@ function createApiRoutes(cwd, port = 4242, wss) {
     broadcastWs(wss, { type: "notification:dismissed", id });
     return c.json({ ok: true });
   });
+  api.post("/api/decision", async (c) => {
+    const app = c.req.query("app") || "unknown";
+    const loop = c.req.query("loop") || "unknown";
+    let body;
+    try {
+      body = await c.req.json();
+    } catch {
+      return c.json({ error: "Invalid JSON body" }, 400);
+    }
+    if (!body.item || !body.decision) {
+      return c.json({ error: "item and decision are required" }, 400);
+    }
+    const decision = {
+      id: randomUUID(),
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      app,
+      loop,
+      item: body.item,
+      agent: body.agent || "unknown",
+      decision: body.decision,
+      reasoning: body.reasoning || ""
+    };
+    decisions.push(decision);
+    broadcastWs(wss, { type: "decision:reported", decision });
+    return c.json(decision, 200);
+  });
+  api.get("/api/decisions", (c) => {
+    return c.json(decisions);
+  });
+  api.delete("/api/decision/:id", (c) => {
+    const id = c.req.param("id");
+    const idx = decisions.findIndex((d) => d.id === id);
+    if (idx === -1) {
+      return c.json({ error: "Decision not found" }, 404);
+    }
+    decisions.splice(idx, 1);
+    broadcastWs(wss, { type: "decision:dismissed", id });
+    return c.json({ ok: true });
+  });
   return api;
 }
 function validatePath(resolvedPath, cwd) {
@@ -728,19 +913,24 @@ function removeNotificationHook(cwd) {
 
 // src/dashboard/server.ts
 var __dirname = dirname(fileURLToPath(import.meta.url));
-function resolveUiPath() {
+var CONTENT_TYPES = {
+  ".css": "text/css",
+  ".js": "text/javascript",
+  ".html": "text/html"
+};
+function resolveUiDir() {
   const candidates = [
-    join4(__dirname, "..", "dashboard", "ui", "index.html"),
+    join4(__dirname, "..", "dashboard", "ui"),
     // dev: src/dashboard/ -> src/dashboard/ui/
-    join4(__dirname, "..", "src", "dashboard", "ui", "index.html")
+    join4(__dirname, "..", "src", "dashboard", "ui")
     // bundled: dist/ -> src/dashboard/ui/
   ];
   for (const candidate of candidates) {
-    if (existsSync3(candidate)) return candidate;
+    if (existsSync3(join4(candidate, "index.html"))) return candidate;
   }
   throw new Error(
     `Dashboard UI not found. Searched:
-${candidates.join("\n")}`
+${candidates.map((c) => join4(c, "index.html")).join("\n")}`
   );
 }
 async function startDashboard(options) {
@@ -753,11 +943,21 @@ async function startDashboard(options) {
   }));
   const apiRoutes = createApiRoutes(cwd, port, wss);
   app.route("/", apiRoutes);
+  const uiDir = resolveUiDir();
   app.get("/", (c) => {
-    const htmlPath = resolveUiPath();
-    const html = readFileSync3(htmlPath, "utf-8");
+    const html = readFileSync3(join4(uiDir, "index.html"), "utf-8");
     return c.html(html);
   });
+  app.get("/:file{.+\\.(css|js)$}", (c) => {
+    const file = c.req.param("file");
+    const filePath = join4(uiDir, file);
+    if (!filePath.startsWith(uiDir) || !existsSync3(filePath)) {
+      return c.notFound();
+    }
+    const content = readFileSync3(filePath, "utf-8");
+    const contentType = CONTENT_TYPES[extname(filePath)] || "text/plain";
+    return c.text(content, 200, { "Content-Type": contentType });
+  });
   const server = serve({
     fetch: app.fetch,
     port,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ralphflow",
-  "version": "0.5.0",
+  "version": "0.5.2",
   "description": "Multi-agent AI workflow orchestration framework for Claude Code. Define pipelines as loops, coordinate parallel agents, and ship structured work.",
   "type": "module",
   "bin": {
@@ -22,6 +22,9 @@
     "dev": "tsup --watch",
     "typecheck": "tsc --noEmit",
     "lint": "eslint src/",
+    "docs:dev": "vitepress dev docs",
+    "docs:build": "vitepress build docs",
+    "docs:preview": "vitepress preview docs",
     "prepublishOnly": "npm run build"
   },
   "keywords": [
@@ -67,6 +70,7 @@
     "@types/node": "^22.0.0",
     "@types/ws": "^8.5.0",
     "tsup": "^8.3.0",
-    "typescript": "^5.6.0"
+    "typescript": "^5.6.0",
+    "vitepress": "^1.6.4"
   }
 }

package/src/dashboard/ui/app.js

@@ -0,0 +1,203 @@
+// Application entry point — WebSocket, data fetching, init, action wiring.
+
+import { state, dom, actions } from './state.js';
+import { fetchJson } from './utils.js';
+import { renderSidebar, selectApp, selectLoop } from './sidebar.js';
+import { renderContent, loadTracker, openDeleteAppModal, openArchiveAppModal, openCreateAppModal } from './loop-detail.js';
+import {
+  fetchNotifications,
+  dismissNotification,
+  fetchDecisions,
+  dismissDecision,
+  maybeRequestNotifPermission,
+  showBrowserNotification,
+  showBrowserDecisionNotification,
+  playNotificationChime,
+  onFirstInteraction,
+} from './notifications.js';
+import { switchAppTab, loadArchives } from './archives.js';
+import {
+  renderTemplatesPage,
+  renderTemplateBuilder,
+  captureBuilderInputs,
+  updateYamlPreview,
+  updateMinimapIO,
+  fetchTemplates,
+} from './templates.js';
+
+// -----------------------------------------------------------------------
+// Wire cross-module actions registry
+// -----------------------------------------------------------------------
+actions.renderSidebar = renderSidebar;
+actions.renderContent = renderContent;
+actions.selectLoop = selectLoop;
+actions.fetchApps = fetchApps;
+actions.fetchAppStatus = fetchAppStatus;
+actions.openCreateAppModal = openCreateAppModal;
+actions.openDeleteAppModal = openDeleteAppModal;
+actions.openArchiveAppModal = openArchiveAppModal;
+actions.renderTemplatesPage = renderTemplatesPage;
+actions.renderTemplateBuilder = renderTemplateBuilder;
+actions.captureBuilderInputs = captureBuilderInputs;
+actions.updateYamlPreview = updateYamlPreview;
+actions.updateMinimapIO = updateMinimapIO;
+actions.fetchTemplates = fetchTemplates;
+actions.switchAppTab = switchAppTab;
+actions.loadArchives = loadArchives;
+actions.dismissNotification = dismissNotification;
+actions.dismissDecision = dismissDecision;
+
+// -----------------------------------------------------------------------
+// Host display
+// -----------------------------------------------------------------------
+dom.hostDisplay.textContent = location.host;
+
+fetch('/api/context')
+  .then(r => r.json())
+  .then(ctx => {
+    dom.hostDisplay.textContent = ctx.projectName + ' :' + ctx.port;
+  })
+  .catch(() => { /* keep location.host as fallback */ });
+
+// -----------------------------------------------------------------------
+// WebSocket
+// -----------------------------------------------------------------------
+function connectWs() {
+  const proto = location.protocol === 'https:' ? 'wss:' : 'ws:';
+  state.ws = new WebSocket(`${proto}//${location.host}/ws`);
+
+  state.ws.onopen = () => {
+    dom.statusDot.className = 'status-dot connected';
+    dom.statusText.textContent = 'Connected';
+    state.reconnectDelay = 1000;
+  };
+
+  state.ws.onclose = () => {
+    dom.statusDot.className = 'status-dot disconnected';
+    dom.statusText.textContent = 'Disconnected';
+    setTimeout(connectWs, state.reconnectDelay);
+    state.reconnectDelay = Math.min(state.reconnectDelay * 2, 30000);
+  };
+
+  state.ws.onerror = () => {
+    state.ws.close();
+  };
+
+  state.ws.onmessage = (e) => {
+    const event = JSON.parse(e.data);
+    state.eventCounter++;
+    dom.eventCountEl.textContent = state.eventCounter;
+    dom.lastUpdate.textContent = new Date().toLocaleTimeString();
+    handleWsEvent(event);
+  };
+}
+
+function handleWsEvent(event) {
+  if (event.type === 'status:full') {
+    state.apps = event.apps;
+    renderSidebar();
+    if (state.selectedApp) {
+      const updated = state.apps.find(a => a.appName === state.selectedApp.appName);
+      if (updated) {
+        state.selectedApp = updated;
+        renderContent();
+      }
+    }
+  } else if (event.type === 'tracker:updated') {
+    if (state.selectedApp && state.selectedApp.appName === event.app) {
+      const loopEntry = state.selectedApp.loops.find(l => l.key === event.loop);
+      if (loopEntry) {
+        loopEntry.status = event.status;
+      }
+      renderContent();
+      if (state.selectedLoop === event.loop) {
+        loadTracker(event.app, event.loop);
+      }
+    }
+  } else if (event.type === 'file:changed') {
+    if (state.selectedApp && state.selectedApp.appName === event.app) {
+      fetchAppStatus(event.app);
+    }
+  } else if (event.type === 'notification:attention') {
+    const n = event.notification;
+    state.notificationsList.unshift(n);
+    renderSidebar();
+    renderContent();
+    maybeRequestNotifPermission();
+    showBrowserNotification(n);
+    playNotificationChime();
+  } else if (event.type === 'notification:dismissed') {
+    state.notificationsList = state.notificationsList.filter(n => n.id !== event.id);
+    renderSidebar();
+    renderContent();
+  } else if (event.type === 'decision:reported') {
+    const d = event.decision;
+    state.decisionsList.unshift(d);
+    renderSidebar();
+    renderContent();
+    maybeRequestNotifPermission();
+    showBrowserDecisionNotification(d);
+    playNotificationChime();
+  } else if (event.type === 'decision:dismissed') {
+    state.decisionsList = state.decisionsList.filter(d => d.id !== event.id);
+    renderSidebar();
+    renderContent();
+  }
+}
+
+// -----------------------------------------------------------------------
+// API
+// -----------------------------------------------------------------------
+async function fetchApps() {
+  state.apps = await fetchJson('/api/apps');
+  renderSidebar();
+  if (state.apps.length > 0 && !state.selectedApp) {
+    selectApp(state.apps[0]);
+  }
+}
+
+async function fetchAppStatus(appName) {
+  const statuses = await fetchJson(`/api/apps/${encodeURIComponent(appName)}/status`);
+  if (state.selectedApp && state.selectedApp.appName === appName) {
+    statuses.forEach(s => {
+      const loop = state.selectedApp.loops.find(l => l.key === s.key);
+      if (loop) loop.status = s;
+    });
+    renderContent();
+  }
+}
+
+// -----------------------------------------------------------------------
+// Templates nav click handler
+// -----------------------------------------------------------------------
+document.getElementById('templatesNav').addEventListener('click', () => {
+  state.currentPage = 'templates';
+  state.selectedApp = null;
+  state.selectedLoop = null;
+  state.showTemplateBuilder = false;
+  state.templateBuilderState = null;
+  state.editingTemplateName = null;
+  state.viewingTemplateName = null;
+  state.viewingTemplateConfig = null;
+  state.viewingTemplatePrompts = {};
+  state.showTemplateWizard = false;
+  state.wizardStep = 0;
+  state.wizardData = null;
+  document.title = 'Templates - RalphFlow Dashboard';
+  renderSidebar();
+  renderContent();
+});
+
+// -----------------------------------------------------------------------
+// Audio context init on first interaction
+// -----------------------------------------------------------------------
+document.addEventListener('click', onFirstInteraction);
+document.addEventListener('keydown', onFirstInteraction);
+
+// -----------------------------------------------------------------------
+// Boot
+// -----------------------------------------------------------------------
+fetchApps();
+fetchNotifications();
+fetchDecisions();
+connectWs();