agentflow-dashboard 0.4.0 → 0.5.0

package/dist/{chunk-25MUPUYY.js → chunk-RWNVLZU7.js}

@@ -1667,6 +1667,167 @@ var DashboardServer = class {
         res.status(500).json({ error: "Failed to load statistics" });
       }
     });
+    this.app.get("/api/agents/:agentId/timeline", (req, res) => {
+      try {
+        const agentId = req.params.agentId;
+        const limit = Math.min(parseInt(req.query.limit) || 50, 200);
+        const rawTraces = this.watcher.getTracesByAgent(agentId);
+        if (rawTraces.length === 0) {
+          return res.status(404).json({ error: "No traces for agent" });
+        }
+        const traces = rawTraces.sort((a, b) => (b.startTime || 0) - (a.startTime || 0)).slice(0, limit).reverse();
+        const executions = traces.map((t) => {
+          const serialized = serializeTrace(t);
+          const nodes = serialized.nodes || {};
+          const events = serialized.sessionEvents || [];
+          const activities = [];
+          if (events.length > 0) {
+            for (let i = 0; i < events.length; i++) {
+              const evt = events[i];
+              if (evt.type === "system" || evt.type === "model_change") continue;
+              const dur = evt.duration || 0;
+              const startTs = dur > 0 ? evt.timestamp - dur : evt.timestamp;
+              const nextTs = i + 1 < events.length ? events[i + 1].timestamp : evt.timestamp;
+              const endTs = dur > 0 ? evt.timestamp : Math.max(nextTs, startTs + 500);
+              activities.push({
+                id: evt.id || `evt-${i}`,
+                name: evt.toolName || evt.name || evt.type,
+                type: evt.type,
+                status: evt.toolError ? "failed" : "completed",
+                startTime: startTs,
+                endTime: endTs,
+                parentId: evt.parentId
+              });
+            }
+          } else {
+            const sorted = Object.values(nodes).sort((a, b) => (a.startTime || 0) - (b.startTime || 0));
+            for (const node of sorted) {
+              activities.push({
+                id: node.id,
+                name: node.name || node.type || node.id,
+                type: node.type || "unknown",
+                status: node.status || "completed",
+                startTime: node.startTime || t.startTime,
+                endTime: node.endTime || node.startTime || t.startTime,
+                parentId: node.parentId
+              });
+            }
+          }
+          return {
+            id: serialized.id || serialized.filename,
+            filename: serialized.filename,
+            name: serialized.name || serialized.filename,
+            agentId: serialized.agentId,
+            trigger: serialized.trigger,
+            status: serialized.status || "completed",
+            sourceType: serialized.sourceType,
+            startTime: serialized.startTime,
+            endTime: serialized.endTime || serialized.startTime,
+            tokenUsage: serialized.tokenUsage,
+            activities
+          };
+        });
+        const allTimes = executions.flatMap((e) => [e.startTime, e.endTime]);
+        const minTime = Math.min(...allTimes);
+        const maxTime = Math.max(...allTimes);
+        res.json({ agentId, totalExecutions: rawTraces.length, executions, minTime, maxTime });
+      } catch (error) {
+        console.error("Agent timeline error:", error);
+        res.status(500).json({ error: "Failed to build agent timeline" });
+      }
+    });
+    this.app.get("/api/agents/:agentId/process-graph", (req, res) => {
+      try {
+        const agentId = req.params.agentId;
+        const traces = this.watcher.getTracesByAgent(agentId).map(serializeTrace);
+        if (traces.length === 0) {
+          return res.status(404).json({ error: "No traces for agent" });
+        }
+        const activityCounts = /* @__PURE__ */ new Map();
+        const transitionCounts = /* @__PURE__ */ new Map();
+        const activityDurations = /* @__PURE__ */ new Map();
+        const activityStatuses = /* @__PURE__ */ new Map();
+        let totalTraces = 0;
+        for (const trace of traces) {
+          totalTraces++;
+          const activities = [];
+          if (trace.sessionEvents && trace.sessionEvents.length > 0) {
+            for (const evt of trace.sessionEvents) {
+              const name = evt.toolName || evt.name || evt.type;
+              if (!name) continue;
+              activities.push({
+                name,
+                type: evt.type,
+                status: evt.toolError ? "failed" : "completed",
+                duration: evt.duration || 0
+              });
+            }
+          } else {
+            const nodes2 = trace.nodes || {};
+            const sorted = Object.values(nodes2).sort((a, b) => (a.startTime || 0) - (b.startTime || 0));
+            for (const node of sorted) {
+              activities.push({
+                name: node.name || node.type || node.id,
+                type: node.type || "unknown",
+                status: node.status || "completed",
+                duration: (node.endTime || node.startTime || 0) - (node.startTime || 0)
+              });
+            }
+          }
+          const seq = ["[START]", ...activities.map((a) => a.name), "[END]"];
+          for (let i = 0; i < seq.length; i++) {
+            const act = seq[i];
+            activityCounts.set(act, (activityCounts.get(act) || 0) + 1);
+            if (i < seq.length - 1) {
+              const key = act + " \u2192 " + seq[i + 1];
+              transitionCounts.set(key, (transitionCounts.get(key) || 0) + 1);
+            }
+          }
+          for (const act of activities) {
+            if (act.duration > 0) {
+              const durs = activityDurations.get(act.name) || [];
+              durs.push(act.duration);
+              activityDurations.set(act.name, durs);
+            }
+            const st = activityStatuses.get(act.name) || { ok: 0, fail: 0 };
+            if (act.status === "failed") st.fail++;
+            else st.ok++;
+            activityStatuses.set(act.name, st);
+          }
+        }
+        const nodes = Array.from(activityCounts.entries()).map(([name, count]) => {
+          const durs = activityDurations.get(name) || [];
+          const st = activityStatuses.get(name) || { ok: 0, fail: 0 };
+          const avgDuration = durs.length > 0 ? durs.reduce((a, b) => a + b, 0) / durs.length : 0;
+          return {
+            id: name,
+            label: name,
+            count,
+            frequency: count / totalTraces,
+            avgDuration,
+            failRate: st.ok + st.fail > 0 ? st.fail / (st.ok + st.fail) : 0,
+            isVirtual: name === "[START]" || name === "[END]"
+          };
+        });
+        const edges = Array.from(transitionCounts.entries()).map(([key, count]) => {
+          const [source, target] = key.split(" \u2192 ");
+          return { source, target, count, frequency: count / totalTraces };
+        });
+        const maxEdgeCount = Math.max(...edges.map((e) => e.count), 1);
+        const maxNodeCount = Math.max(...nodes.filter((n) => !n.isVirtual).map((n) => n.count), 1);
+        res.json({
+          agentId,
+          totalTraces,
+          nodes,
+          edges,
+          maxEdgeCount,
+          maxNodeCount
+        });
+      } catch (error) {
+        console.error("Process graph error:", error);
+        res.status(500).json({ error: "Failed to build process graph" });
+      }
+    });
     this.app.get("/api/stats/:agentId", (req, res) => {
       try {
         const agentStats = this.stats.getAgentStats(req.params.agentId);

package/dist/cli.cjs

@@ -1561,6 +1561,167 @@ var DashboardServer = class {
         res.status(500).json({ error: "Failed to load statistics" });
       }
     });
+    this.app.get("/api/agents/:agentId/timeline", (req, res) => {
+      try {
+        const agentId = req.params.agentId;
+        const limit = Math.min(parseInt(req.query.limit) || 50, 200);
+        const rawTraces = this.watcher.getTracesByAgent(agentId);
+        if (rawTraces.length === 0) {
+          return res.status(404).json({ error: "No traces for agent" });
+        }
+        const traces = rawTraces.sort((a, b) => (b.startTime || 0) - (a.startTime || 0)).slice(0, limit).reverse();
+        const executions = traces.map((t) => {
+          const serialized = serializeTrace(t);
+          const nodes = serialized.nodes || {};
+          const events = serialized.sessionEvents || [];
+          const activities = [];
+          if (events.length > 0) {
+            for (let i = 0; i < events.length; i++) {
+              const evt = events[i];
+              if (evt.type === "system" || evt.type === "model_change") continue;
+              const dur = evt.duration || 0;
+              const startTs = dur > 0 ? evt.timestamp - dur : evt.timestamp;
+              const nextTs = i + 1 < events.length ? events[i + 1].timestamp : evt.timestamp;
+              const endTs = dur > 0 ? evt.timestamp : Math.max(nextTs, startTs + 500);
+              activities.push({
+                id: evt.id || `evt-${i}`,
+                name: evt.toolName || evt.name || evt.type,
+                type: evt.type,
+                status: evt.toolError ? "failed" : "completed",
+                startTime: startTs,
+                endTime: endTs,
+                parentId: evt.parentId
+              });
+            }
+          } else {
+            const sorted = Object.values(nodes).sort((a, b) => (a.startTime || 0) - (b.startTime || 0));
+            for (const node of sorted) {
+              activities.push({
+                id: node.id,
+                name: node.name || node.type || node.id,
+                type: node.type || "unknown",
+                status: node.status || "completed",
+                startTime: node.startTime || t.startTime,
+                endTime: node.endTime || node.startTime || t.startTime,
+                parentId: node.parentId
+              });
+            }
+          }
+          return {
+            id: serialized.id || serialized.filename,
+            filename: serialized.filename,
+            name: serialized.name || serialized.filename,
+            agentId: serialized.agentId,
+            trigger: serialized.trigger,
+            status: serialized.status || "completed",
+            sourceType: serialized.sourceType,
+            startTime: serialized.startTime,
+            endTime: serialized.endTime || serialized.startTime,
+            tokenUsage: serialized.tokenUsage,
+            activities
+          };
+        });
+        const allTimes = executions.flatMap((e) => [e.startTime, e.endTime]);
+        const minTime = Math.min(...allTimes);
+        const maxTime = Math.max(...allTimes);
+        res.json({ agentId, totalExecutions: rawTraces.length, executions, minTime, maxTime });
+      } catch (error) {
+        console.error("Agent timeline error:", error);
+        res.status(500).json({ error: "Failed to build agent timeline" });
+      }
+    });
+    this.app.get("/api/agents/:agentId/process-graph", (req, res) => {
+      try {
+        const agentId = req.params.agentId;
+        const traces = this.watcher.getTracesByAgent(agentId).map(serializeTrace);
+        if (traces.length === 0) {
+          return res.status(404).json({ error: "No traces for agent" });
+        }
+        const activityCounts = /* @__PURE__ */ new Map();
+        const transitionCounts = /* @__PURE__ */ new Map();
+        const activityDurations = /* @__PURE__ */ new Map();
+        const activityStatuses = /* @__PURE__ */ new Map();
+        let totalTraces = 0;
+        for (const trace of traces) {
+          totalTraces++;
+          const activities = [];
+          if (trace.sessionEvents && trace.sessionEvents.length > 0) {
+            for (const evt of trace.sessionEvents) {
+              const name = evt.toolName || evt.name || evt.type;
+              if (!name) continue;
+              activities.push({
+                name,
+                type: evt.type,
+                status: evt.toolError ? "failed" : "completed",
+                duration: evt.duration || 0
+              });
+            }
+          } else {
+            const nodes2 = trace.nodes || {};
+            const sorted = Object.values(nodes2).sort((a, b) => (a.startTime || 0) - (b.startTime || 0));
+            for (const node of sorted) {
+              activities.push({
+                name: node.name || node.type || node.id,
+                type: node.type || "unknown",
+                status: node.status || "completed",
+                duration: (node.endTime || node.startTime || 0) - (node.startTime || 0)
+              });
+            }
+          }
+          const seq = ["[START]", ...activities.map((a) => a.name), "[END]"];
+          for (let i = 0; i < seq.length; i++) {
+            const act = seq[i];
+            activityCounts.set(act, (activityCounts.get(act) || 0) + 1);
+            if (i < seq.length - 1) {
+              const key = act + " \u2192 " + seq[i + 1];
+              transitionCounts.set(key, (transitionCounts.get(key) || 0) + 1);
+            }
+          }
+          for (const act of activities) {
+            if (act.duration > 0) {
+              const durs = activityDurations.get(act.name) || [];
+              durs.push(act.duration);
+              activityDurations.set(act.name, durs);
+            }
+            const st = activityStatuses.get(act.name) || { ok: 0, fail: 0 };
+            if (act.status === "failed") st.fail++;
+            else st.ok++;
+            activityStatuses.set(act.name, st);
+          }
+        }
+        const nodes = Array.from(activityCounts.entries()).map(([name, count]) => {
+          const durs = activityDurations.get(name) || [];
+          const st = activityStatuses.get(name) || { ok: 0, fail: 0 };
+          const avgDuration = durs.length > 0 ? durs.reduce((a, b) => a + b, 0) / durs.length : 0;
+          return {
+            id: name,
+            label: name,
+            count,
+            frequency: count / totalTraces,
+            avgDuration,
+            failRate: st.ok + st.fail > 0 ? st.fail / (st.ok + st.fail) : 0,
+            isVirtual: name === "[START]" || name === "[END]"
+          };
+        });
+        const edges = Array.from(transitionCounts.entries()).map(([key, count]) => {
+          const [source, target] = key.split(" \u2192 ");
+          return { source, target, count, frequency: count / totalTraces };
+        });
+        const maxEdgeCount = Math.max(...edges.map((e) => e.count), 1);
+        const maxNodeCount = Math.max(...nodes.filter((n) => !n.isVirtual).map((n) => n.count), 1);
+        res.json({
+          agentId,
+          totalTraces,
+          nodes,
+          edges,
+          maxEdgeCount,
+          maxNodeCount
+        });
+      } catch (error) {
+        console.error("Process graph error:", error);
+        res.status(500).json({ error: "Failed to build process graph" });
+      }
+    });
     this.app.get("/api/stats/:agentId", (req, res) => {
       try {
         const agentStats = this.stats.getAgentStats(req.params.agentId);

package/dist/cli.js

@@ -1,6 +1,6 @@
 import {
   startDashboard
-} from "./chunk-25MUPUYY.js";
+} from "./chunk-RWNVLZU7.js";
 export {
   startDashboard
 };

package/dist/index.cjs

@@ -1706,6 +1706,167 @@ var DashboardServer = class {
         res.status(500).json({ error: "Failed to load statistics" });
       }
     });
+    this.app.get("/api/agents/:agentId/timeline", (req, res) => {
+      try {
+        const agentId = req.params.agentId;
+        const limit = Math.min(parseInt(req.query.limit) || 50, 200);
+        const rawTraces = this.watcher.getTracesByAgent(agentId);
+        if (rawTraces.length === 0) {
+          return res.status(404).json({ error: "No traces for agent" });
+        }
+        const traces = rawTraces.sort((a, b) => (b.startTime || 0) - (a.startTime || 0)).slice(0, limit).reverse();
+        const executions = traces.map((t) => {
+          const serialized = serializeTrace(t);
+          const nodes = serialized.nodes || {};
+          const events = serialized.sessionEvents || [];
+          const activities = [];
+          if (events.length > 0) {
+            for (let i = 0; i < events.length; i++) {
+              const evt = events[i];
+              if (evt.type === "system" || evt.type === "model_change") continue;
+              const dur = evt.duration || 0;
+              const startTs = dur > 0 ? evt.timestamp - dur : evt.timestamp;
+              const nextTs = i + 1 < events.length ? events[i + 1].timestamp : evt.timestamp;
+              const endTs = dur > 0 ? evt.timestamp : Math.max(nextTs, startTs + 500);
+              activities.push({
+                id: evt.id || `evt-${i}`,
+                name: evt.toolName || evt.name || evt.type,
+                type: evt.type,
+                status: evt.toolError ? "failed" : "completed",
+                startTime: startTs,
+                endTime: endTs,
+                parentId: evt.parentId
+              });
+            }
+          } else {
+            const sorted = Object.values(nodes).sort((a, b) => (a.startTime || 0) - (b.startTime || 0));
+            for (const node of sorted) {
+              activities.push({
+                id: node.id,
+                name: node.name || node.type || node.id,
+                type: node.type || "unknown",
+                status: node.status || "completed",
+                startTime: node.startTime || t.startTime,
+                endTime: node.endTime || node.startTime || t.startTime,
+                parentId: node.parentId
+              });
+            }
+          }
+          return {
+            id: serialized.id || serialized.filename,
+            filename: serialized.filename,
+            name: serialized.name || serialized.filename,
+            agentId: serialized.agentId,
+            trigger: serialized.trigger,
+            status: serialized.status || "completed",
+            sourceType: serialized.sourceType,
+            startTime: serialized.startTime,
+            endTime: serialized.endTime || serialized.startTime,
+            tokenUsage: serialized.tokenUsage,
+            activities
+          };
+        });
+        const allTimes = executions.flatMap((e) => [e.startTime, e.endTime]);
+        const minTime = Math.min(...allTimes);
+        const maxTime = Math.max(...allTimes);
+        res.json({ agentId, totalExecutions: rawTraces.length, executions, minTime, maxTime });
+      } catch (error) {
+        console.error("Agent timeline error:", error);
+        res.status(500).json({ error: "Failed to build agent timeline" });
+      }
+    });
+    this.app.get("/api/agents/:agentId/process-graph", (req, res) => {
+      try {
+        const agentId = req.params.agentId;
+        const traces = this.watcher.getTracesByAgent(agentId).map(serializeTrace);
+        if (traces.length === 0) {
+          return res.status(404).json({ error: "No traces for agent" });
+        }
+        const activityCounts = /* @__PURE__ */ new Map();
+        const transitionCounts = /* @__PURE__ */ new Map();
+        const activityDurations = /* @__PURE__ */ new Map();
+        const activityStatuses = /* @__PURE__ */ new Map();
+        let totalTraces = 0;
+        for (const trace of traces) {
+          totalTraces++;
+          const activities = [];
+          if (trace.sessionEvents && trace.sessionEvents.length > 0) {
+            for (const evt of trace.sessionEvents) {
+              const name = evt.toolName || evt.name || evt.type;
+              if (!name) continue;
+              activities.push({
+                name,
+                type: evt.type,
+                status: evt.toolError ? "failed" : "completed",
+                duration: evt.duration || 0
+              });
+            }
+          } else {
+            const nodes2 = trace.nodes || {};
+            const sorted = Object.values(nodes2).sort((a, b) => (a.startTime || 0) - (b.startTime || 0));
+            for (const node of sorted) {
+              activities.push({
+                name: node.name || node.type || node.id,
+                type: node.type || "unknown",
+                status: node.status || "completed",
+                duration: (node.endTime || node.startTime || 0) - (node.startTime || 0)
+              });
+            }
+          }
+          const seq = ["[START]", ...activities.map((a) => a.name), "[END]"];
+          for (let i = 0; i < seq.length; i++) {
+            const act = seq[i];
+            activityCounts.set(act, (activityCounts.get(act) || 0) + 1);
+            if (i < seq.length - 1) {
+              const key = act + " \u2192 " + seq[i + 1];
+              transitionCounts.set(key, (transitionCounts.get(key) || 0) + 1);
+            }
+          }
+          for (const act of activities) {
+            if (act.duration > 0) {
+              const durs = activityDurations.get(act.name) || [];
+              durs.push(act.duration);
+              activityDurations.set(act.name, durs);
+            }
+            const st = activityStatuses.get(act.name) || { ok: 0, fail: 0 };
+            if (act.status === "failed") st.fail++;
+            else st.ok++;
+            activityStatuses.set(act.name, st);
+          }
+        }
+        const nodes = Array.from(activityCounts.entries()).map(([name, count]) => {
+          const durs = activityDurations.get(name) || [];
+          const st = activityStatuses.get(name) || { ok: 0, fail: 0 };
+          const avgDuration = durs.length > 0 ? durs.reduce((a, b) => a + b, 0) / durs.length : 0;
+          return {
+            id: name,
+            label: name,
+            count,
+            frequency: count / totalTraces,
+            avgDuration,
+            failRate: st.ok + st.fail > 0 ? st.fail / (st.ok + st.fail) : 0,
+            isVirtual: name === "[START]" || name === "[END]"
+          };
+        });
+        const edges = Array.from(transitionCounts.entries()).map(([key, count]) => {
+          const [source, target] = key.split(" \u2192 ");
+          return { source, target, count, frequency: count / totalTraces };
+        });
+        const maxEdgeCount = Math.max(...edges.map((e) => e.count), 1);
+        const maxNodeCount = Math.max(...nodes.filter((n) => !n.isVirtual).map((n) => n.count), 1);
+        res.json({
+          agentId,
+          totalTraces,
+          nodes,
+          edges,
+          maxEdgeCount,
+          maxNodeCount
+        });
+      } catch (error) {
+        console.error("Process graph error:", error);
+        res.status(500).json({ error: "Failed to build process graph" });
+      }
+    });
     this.app.get("/api/stats/:agentId", (req, res) => {
       try {
         const agentStats = this.stats.getAgentStats(req.params.agentId);

package/dist/index.js

@@ -3,7 +3,7 @@ import {
   AgentStats,
   DashboardServer,
   TraceWatcher
-} from "./chunk-25MUPUYY.js";
+} from "./chunk-RWNVLZU7.js";
 export {
   AgentStats,
   DashboardServer,