agentflow-dashboard 0.1.0

package/dist/index.js

@@ -0,0 +1,560 @@
+#!/usr/bin/env node
+
+// src/server.ts
+import express from "express";
+import { WebSocketServer } from "ws";
+import { createServer } from "http";
+import * as path2 from "path";
+import * as fs2 from "fs";
+
+// src/watcher.ts
+import chokidar from "chokidar";
+import * as fs from "fs";
+import * as path from "path";
+import { EventEmitter } from "events";
+var TraceWatcher = class extends EventEmitter {
+  watcher;
+  traces = /* @__PURE__ */ new Map();
+  tracesDir;
+  constructor(tracesDir) {
+    super();
+    this.tracesDir = path.resolve(tracesDir);
+    this.ensureTracesDir();
+    this.loadExistingTraces();
+    this.startWatching();
+  }
+  ensureTracesDir() {
+    if (!fs.existsSync(this.tracesDir)) {
+      fs.mkdirSync(this.tracesDir, { recursive: true });
+      console.log(`Created traces directory: ${this.tracesDir}`);
+    }
+  }
+  loadExistingTraces() {
+    try {
+      const files = fs.readdirSync(this.tracesDir).filter((file) => file.endsWith(".json"));
+      console.log(`Loading ${files.length} existing trace files...`);
+      for (const file of files) {
+        this.loadTraceFile(path.join(this.tracesDir, file));
+      }
+      console.log(`Loaded ${this.traces.size} traces`);
+    } catch (error) {
+      console.error("Error loading existing traces:", error);
+    }
+  }
+  loadTraceFile(filePath) {
+    try {
+      const content = fs.readFileSync(filePath, "utf8");
+      const trace = JSON.parse(content);
+      const filename = path.basename(filePath);
+      const stats = fs.statSync(filePath);
+      trace.filename = filename;
+      trace.lastModified = stats.mtime.getTime();
+      if (Array.isArray(trace.nodes)) {
+        const nodesMap = new Map(trace.nodes);
+        trace.nodes = nodesMap;
+      }
+      this.traces.set(filename, trace);
+      return true;
+    } catch (error) {
+      console.error(`Error loading trace file ${filePath}:`, error);
+      return false;
+    }
+  }
+  startWatching() {
+    this.watcher = chokidar.watch(this.tracesDir, {
+      ignored: /^\\./,
+      persistent: true,
+      ignoreInitial: true
+    });
+    this.watcher.on("add", (filePath) => {
+      if (filePath.endsWith(".json")) {
+        console.log(`New trace file: ${path.basename(filePath)}`);
+        if (this.loadTraceFile(filePath)) {
+          const filename = path.basename(filePath);
+          const trace = this.traces.get(filename);
+          if (trace) {
+            this.emit("trace-added", trace);
+          }
+        }
+      }
+    });
+    this.watcher.on("change", (filePath) => {
+      if (filePath.endsWith(".json")) {
+        console.log(`Trace file updated: ${path.basename(filePath)}`);
+        if (this.loadTraceFile(filePath)) {
+          const filename = path.basename(filePath);
+          const trace = this.traces.get(filename);
+          if (trace) {
+            this.emit("trace-updated", trace);
+          }
+        }
+      }
+    });
+    this.watcher.on("unlink", (filePath) => {
+      if (filePath.endsWith(".json")) {
+        const filename = path.basename(filePath);
+        console.log(`Trace file removed: ${filename}`);
+        this.traces.delete(filename);
+        this.emit("trace-removed", filename);
+      }
+    });
+    this.watcher.on("error", (error) => {
+      console.error("Trace watcher error:", error);
+    });
+    console.log(`Started watching traces directory: ${this.tracesDir}`);
+  }
+  getAllTraces() {
+    return Array.from(this.traces.values()).sort((a, b) => {
+      return (b.lastModified || b.timestamp) - (a.lastModified || a.timestamp);
+    });
+  }
+  getTrace(filename) {
+    return this.traces.get(filename);
+  }
+  getTracesByAgent(agentId) {
+    return this.getAllTraces().filter((trace) => trace.agentId === agentId);
+  }
+  getRecentTraces(limit = 50) {
+    return this.getAllTraces().slice(0, limit);
+  }
+  getTraceCount() {
+    return this.traces.size;
+  }
+  getAgentIds() {
+    const agentIds = /* @__PURE__ */ new Set();
+    for (const trace of this.traces.values()) {
+      agentIds.add(trace.agentId);
+    }
+    return Array.from(agentIds).sort();
+  }
+  stop() {
+    if (this.watcher) {
+      this.watcher.close();
+      this.watcher = void 0;
+      console.log("Stopped watching traces directory");
+    }
+  }
+  // Utility method to get trace statistics
+  getTraceStats() {
+    const total = this.traces.size;
+    const agentCount = this.getAgentIds().length;
+    const recentCount = this.getRecentTraces(24).length;
+    const triggers = /* @__PURE__ */ new Map();
+    for (const trace of this.traces.values()) {
+      const trigger = trace.trigger || "unknown";
+      triggers.set(trigger, (triggers.get(trigger) || 0) + 1);
+    }
+    return {
+      total,
+      agentCount,
+      recentCount,
+      triggers: Object.fromEntries(triggers)
+    };
+  }
+};
+
+// ../core/dist/index.js
+function getFailures(graph) {
+  const failureStatuses = /* @__PURE__ */ new Set(["failed", "hung", "timeout"]);
+  return [...graph.nodes.values()].filter((node) => failureStatuses.has(node.status));
+}
+function getHungNodes(graph) {
+  return [...graph.nodes.values()].filter(
+    (node) => node.status === "running" && node.endTime === null
+  );
+}
+function getDuration(graph) {
+  const end = graph.endTime ?? Date.now();
+  return end - graph.startTime;
+}
+function getDepth(graph) {
+  const root = graph.nodes.get(graph.rootNodeId);
+  if (!root) return -1;
+  function dfs(node, depth) {
+    if (node.children.length === 0) return depth;
+    let maxDepth = depth;
+    for (const childId of node.children) {
+      const child = graph.nodes.get(childId);
+      if (!child) continue;
+      const childDepth = dfs(child, depth + 1);
+      if (childDepth > maxDepth) maxDepth = childDepth;
+    }
+    return maxDepth;
+  }
+  return dfs(root, 0);
+}
+function getStats(graph) {
+  const byStatus = {
+    running: 0,
+    completed: 0,
+    failed: 0,
+    hung: 0,
+    timeout: 0
+  };
+  const byType = {
+    agent: 0,
+    tool: 0,
+    subagent: 0,
+    wait: 0,
+    decision: 0,
+    custom: 0
+  };
+  let failureCount = 0;
+  let hungCount = 0;
+  for (const node of graph.nodes.values()) {
+    byStatus[node.status]++;
+    byType[node.type]++;
+    if (node.status === "failed" || node.status === "timeout" || node.status === "hung") {
+      failureCount++;
+    }
+    if (node.status === "running" && node.endTime === null) {
+      hungCount++;
+    }
+  }
+  return {
+    totalNodes: graph.nodes.size,
+    byStatus,
+    byType,
+    depth: getDepth(graph),
+    duration: getDuration(graph),
+    failureCount,
+    hungCount
+  };
+}
+
+// src/stats.ts
+var AgentStats = class {
+  agentMetrics = /* @__PURE__ */ new Map();
+  processedTraces = /* @__PURE__ */ new Set();
+  processTrace(trace) {
+    const traceKey = `${trace.filename || trace.agentId}-${trace.timestamp}`;
+    if (this.processedTraces.has(traceKey)) {
+      return;
+    }
+    this.processedTraces.add(traceKey);
+    const agentId = trace.agentId;
+    let metrics = this.agentMetrics.get(agentId);
+    if (!metrics) {
+      metrics = {
+        agentId,
+        totalExecutions: 0,
+        successfulExecutions: 0,
+        failedExecutions: 0,
+        successRate: 0,
+        avgExecutionTime: 0,
+        lastExecution: 0,
+        triggers: {},
+        recentActivity: []
+      };
+      this.agentMetrics.set(agentId, metrics);
+    }
+    const analysis = this.analyzeExecution(trace);
+    metrics.totalExecutions++;
+    metrics.lastExecution = Math.max(metrics.lastExecution, trace.timestamp);
+    const trigger = trace.trigger || "unknown";
+    metrics.triggers[trigger] = (metrics.triggers[trigger] || 0) + 1;
+    if (analysis.success) {
+      metrics.successfulExecutions++;
+    } else {
+      metrics.failedExecutions++;
+    }
+    metrics.successRate = metrics.successfulExecutions / metrics.totalExecutions * 100;
+    if (analysis.executionTime > 0) {
+      const currentAvg = metrics.avgExecutionTime;
+      const count = metrics.totalExecutions;
+      metrics.avgExecutionTime = (currentAvg * (count - 1) + analysis.executionTime) / count;
+    }
+    metrics.recentActivity.push({
+      timestamp: trace.timestamp,
+      success: analysis.success,
+      executionTime: analysis.executionTime,
+      trigger
+    });
+    if (metrics.recentActivity.length > 100) {
+      metrics.recentActivity = metrics.recentActivity.slice(-100);
+    }
+    metrics.recentActivity.sort((a, b) => b.timestamp - a.timestamp);
+  }
+  analyzeExecution(trace) {
+    try {
+      const stats = getStats(trace);
+      const failures = getFailures(trace);
+      const hungNodes = getHungNodes(trace);
+      return {
+        success: failures.length === 0 && hungNodes.length === 0,
+        executionTime: stats.totalTime || 0,
+        nodeCount: stats.totalNodes || 0,
+        failureCount: failures.length,
+        hungCount: hungNodes.length
+      };
+    } catch (error) {
+      console.warn("Error analyzing trace with AgentFlow:", error);
+      const nodes = trace.nodes instanceof Map ? Array.from(trace.nodes.values()) : Array.isArray(trace.nodes) ? trace.nodes.map(([, node]) => node) : [];
+      const failedNodes = nodes.filter((node) => node.status === "failed").length;
+      const success = failedNodes === 0;
+      return {
+        success,
+        executionTime: 0,
+        nodeCount: nodes.length,
+        failureCount: failedNodes,
+        hungCount: 0
+      };
+    }
+  }
+  getAgentStats(agentId) {
+    return this.agentMetrics.get(agentId);
+  }
+  getAgentsList() {
+    return Array.from(this.agentMetrics.values()).sort((a, b) => b.lastExecution - a.lastExecution);
+  }
+  getGlobalStats() {
+    const agents = Array.from(this.agentMetrics.values());
+    const now = Date.now();
+    const oneHourAgo = now - 60 * 60 * 1e3;
+    const totalExecutions = agents.reduce((sum, agent) => sum + agent.totalExecutions, 0);
+    const totalSuccessful = agents.reduce((sum, agent) => sum + agent.successfulExecutions, 0);
+    const globalSuccessRate = totalExecutions > 0 ? totalSuccessful / totalExecutions * 100 : 0;
+    const activeAgents = agents.filter((agent) => agent.lastExecution > oneHourAgo).length;
+    const topAgents = agents.slice().sort((a, b) => b.totalExecutions - a.totalExecutions).slice(0, 10).map((agent) => ({
+      agentId: agent.agentId,
+      executionCount: agent.totalExecutions,
+      successRate: agent.successRate
+    }));
+    const recentActivity = [];
+    for (const agent of agents) {
+      for (const activity of agent.recentActivity.slice(0, 20)) {
+        recentActivity.push({
+          timestamp: activity.timestamp,
+          agentId: agent.agentId,
+          success: activity.success,
+          trigger: activity.trigger
+        });
+      }
+    }
+    recentActivity.sort((a, b) => b.timestamp - a.timestamp);
+    recentActivity.splice(200);
+    return {
+      totalAgents: agents.length,
+      totalExecutions,
+      globalSuccessRate,
+      activeAgents,
+      topAgents,
+      recentActivity
+    };
+  }
+  getPerformanceSummary() {
+    const global = this.getGlobalStats();
+    const agents = this.getAgentsList();
+    return {
+      overview: {
+        totalAgents: global.totalAgents,
+        totalExecutions: global.totalExecutions,
+        successRate: Math.round(global.globalSuccessRate * 100) / 100,
+        activeAgents: global.activeAgents
+      },
+      topPerformers: agents.slice(0, 5).map((agent) => ({
+        agentId: agent.agentId,
+        executions: agent.totalExecutions,
+        successRate: Math.round(agent.successRate * 100) / 100,
+        avgTime: Math.round(agent.avgExecutionTime * 100) / 100
+      })),
+      recentTrends: this.analyzeRecentTrends()
+    };
+  }
+  analyzeRecentTrends() {
+    const agents = Array.from(this.agentMetrics.values());
+    const now = Date.now();
+    const oneHourAgo = now - 60 * 60 * 1e3;
+    let recentExecutions = 0;
+    let recentFailures = 0;
+    for (const agent of agents) {
+      for (const activity of agent.recentActivity) {
+        if (activity.timestamp > oneHourAgo) {
+          recentExecutions++;
+          if (!activity.success) {
+            recentFailures++;
+          }
+        }
+      }
+    }
+    return {
+      hourlyExecutions: recentExecutions,
+      hourlyFailures: recentFailures,
+      hourlySuccessRate: recentExecutions > 0 ? Math.round((recentExecutions - recentFailures) / recentExecutions * 1e4) / 100 : 0
+    };
+  }
+  // Clear old data (useful for long-running dashboard instances)
+  cleanup() {
+    const cutoff = Date.now() - 7 * 24 * 60 * 60 * 1e3;
+    for (const [agentId, metrics] of this.agentMetrics.entries()) {
+      metrics.recentActivity = metrics.recentActivity.filter(
+        (activity) => activity.timestamp > cutoff
+      );
+      if (metrics.lastExecution < cutoff) {
+        this.agentMetrics.delete(agentId);
+      }
+    }
+    console.log(`Cleaned up old metrics, ${this.agentMetrics.size} agents remaining`);
+  }
+};
+
+// src/server.ts
+var DashboardServer = class {
+  constructor(config) {
+    this.config = config;
+    this.watcher = new TraceWatcher(config.tracesDir);
+    this.stats = new AgentStats();
+    this.setupExpress();
+    this.setupWebSocket();
+    this.setupTraceWatcher();
+  }
+  app = express();
+  server = createServer(this.app);
+  wss = new WebSocketServer({ server: this.server });
+  watcher;
+  stats;
+  setupExpress() {
+    if (this.config.enableCors) {
+      this.app.use((req, res, next) => {
+        res.header("Access-Control-Allow-Origin", "*");
+        res.header("Access-Control-Allow-Headers", "Origin, X-Requested-With, Content-Type, Accept");
+        next();
+      });
+    }
+    const publicDir = path2.join(__dirname, "../public");
+    if (fs2.existsSync(publicDir)) {
+      this.app.use(express.static(publicDir));
+    }
+    this.app.get("/api/traces", (req, res) => {
+      try {
+        const traces = this.watcher.getAllTraces();
+        res.json(traces);
+      } catch (error) {
+        res.status(500).json({ error: "Failed to load traces" });
+      }
+    });
+    this.app.get("/api/traces/:filename", (req, res) => {
+      try {
+        const trace = this.watcher.getTrace(req.params.filename);
+        if (!trace) {
+          return res.status(404).json({ error: "Trace not found" });
+        }
+        res.json(trace);
+      } catch (error) {
+        res.status(500).json({ error: "Failed to load trace" });
+      }
+    });
+    this.app.get("/api/agents", (req, res) => {
+      try {
+        const agents = this.stats.getAgentsList();
+        res.json(agents);
+      } catch (error) {
+        res.status(500).json({ error: "Failed to load agents" });
+      }
+    });
+    this.app.get("/api/stats", (req, res) => {
+      try {
+        const globalStats = this.stats.getGlobalStats();
+        res.json(globalStats);
+      } catch (error) {
+        res.status(500).json({ error: "Failed to load statistics" });
+      }
+    });
+    this.app.get("/api/stats/:agentId", (req, res) => {
+      try {
+        const agentStats = this.stats.getAgentStats(req.params.agentId);
+        if (!agentStats) {
+          return res.status(404).json({ error: "Agent not found" });
+        }
+        res.json(agentStats);
+      } catch (error) {
+        res.status(500).json({ error: "Failed to load agent statistics" });
+      }
+    });
+    this.app.get("*", (req, res) => {
+      const indexPath = path2.join(__dirname, "../public/index.html");
+      if (fs2.existsSync(indexPath)) {
+        res.sendFile(indexPath);
+      } else {
+        res.status(404).send("Dashboard not found - public files may not be built");
+      }
+    });
+  }
+  setupWebSocket() {
+    this.wss.on("connection", (ws) => {
+      console.log("Dashboard client connected");
+      ws.send(JSON.stringify({
+        type: "init",
+        data: {
+          traces: this.watcher.getAllTraces(),
+          stats: this.stats.getGlobalStats()
+        }
+      }));
+      ws.on("close", () => {
+        console.log("Dashboard client disconnected");
+      });
+      ws.on("error", (error) => {
+        console.error("WebSocket error:", error);
+      });
+    });
+  }
+  setupTraceWatcher() {
+    this.watcher.on("trace-added", (trace) => {
+      this.stats.processTrace(trace);
+      this.broadcast({
+        type: "trace-added",
+        data: trace
+      });
+    });
+    this.watcher.on("trace-updated", (trace) => {
+      this.stats.processTrace(trace);
+      this.broadcast({
+        type: "trace-updated",
+        data: trace
+      });
+    });
+    this.watcher.on("stats-updated", () => {
+      this.broadcast({
+        type: "stats-updated",
+        data: this.stats.getGlobalStats()
+      });
+    });
+  }
+  broadcast(message) {
+    this.wss.clients.forEach((client) => {
+      if (client.readyState === 1) {
+        client.send(JSON.stringify(message));
+      }
+    });
+  }
+  async start() {
+    return new Promise((resolve2) => {
+      const host = this.config.host || "localhost";
+      this.server.listen(this.config.port, host, () => {
+        console.log(`AgentFlow Dashboard running at http://${host}:${this.config.port}`);
+        console.log(`Watching traces in: ${this.config.tracesDir}`);
+        resolve2();
+      });
+    });
+  }
+  async stop() {
+    return new Promise((resolve2) => {
+      this.watcher.stop();
+      this.server.close(() => {
+        console.log("Dashboard server stopped");
+        resolve2();
+      });
+    });
+  }
+  getStats() {
+    return this.stats.getGlobalStats();
+  }
+  getTraces() {
+    return this.watcher.getAllTraces();
+  }
+};
+export {
+  AgentStats,
+  DashboardServer,
+  TraceWatcher
+};