agentflow-dashboard 0.1.4 → 0.2.0

package/bin/dashboard.js

@@ -1,12 +1,14 @@
 #!/usr/bin/env node
 
 // Import and start the CLI
-import('../dist/cli.js').then(({ startDashboard }) => {
+import('../dist/cli.js')
+  .then(({ startDashboard }) => {
     startDashboard().catch((error) => {
-        console.error('Failed to start AgentFlow Dashboard:', error);
-        process.exit(1);
+      console.error('Failed to start AgentFlow Dashboard:', error);
+      process.exit(1);
     });
-}).catch((error) => {
+  })
+  .catch((error) => {
     console.error('Failed to load AgentFlow Dashboard:', error);
     process.exit(1);
-});
+  });

package/dist/chunk-L24LYP6L.js

@@ -0,0 +1,515 @@
+// src/stats.ts
+import { getFailures, getHungNodes, getStats } from "agentflow-core";
+var AgentStats = class {
+  agentMetrics = /* @__PURE__ */ new Map();
+  processedTraces = /* @__PURE__ */ new Set();
+  processTrace(trace) {
+    const traceKey = `${trace.filename || trace.agentId}-${trace.startTime}`;
+    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.startTime);
+    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.startTime,
+      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.duration || 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()) : [];
+      const failedNodes = nodes.filter((node) => node.status === "failed").length;
+      return {
+        success: failedNodes === 0,
+        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
+    };
+  }
+  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/watcher.ts
+import { loadGraph } from "agentflow-core";
+import chokidar from "chokidar";
+import { EventEmitter } from "events";
+import * as fs from "fs";
+import * as path from "path";
+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 graph = loadGraph(content);
+      const filename = path.basename(filePath);
+      const stats = fs.statSync(filePath);
+      graph.filename = filename;
+      graph.lastModified = stats.mtime.getTime();
+      this.traces.set(filename, graph);
+      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.startTime) - (a.lastModified || a.startTime);
+    });
+  }
+  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");
+    }
+  }
+  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)
+    };
+  }
+};
+
+// src/server.ts
+import express from "express";
+import * as fs2 from "fs";
+import { createServer } from "http";
+import * as path2 from "path";
+import { fileURLToPath } from "url";
+import { WebSocketServer } from "ws";
+import { discoverProcessConfig, auditProcesses } from "agentflow-core";
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = path2.dirname(__filename);
+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;
+  processHealthCache = { result: null, ts: 0 };
+  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("/api/process-health", (req, res) => {
+      try {
+        const now = Date.now();
+        if (this.processHealthCache.result && now - this.processHealthCache.ts < 1e4) {
+          return res.json(this.processHealthCache.result);
+        }
+        const discoveryDirs = [
+          this.config.tracesDir,
+          path2.dirname(this.config.tracesDir),
+          ...this.config.dataDirs || []
+        ];
+        const processConfig = discoverProcessConfig(discoveryDirs);
+        if (!processConfig) {
+          return res.json(null);
+        }
+        const result = auditProcesses(processConfig);
+        this.processHealthCache = { result, ts: now };
+        res.json(result);
+      } catch (error) {
+        res.status(500).json({ error: "Failed to audit processes" });
+      }
+    });
+    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,
+  TraceWatcher,
+  DashboardServer
+};