agentflow-core 0.1.4 → 0.2.1

package/dist/index.js

@@ -1,212 +1,24 @@
 import {
   createGraphBuilder,
+  findWaitingOn,
+  getChildren,
+  getCriticalPath,
+  getDepth,
+  getDuration,
+  getFailures,
+  getHungNodes,
+  getNode,
+  getParent,
+  getStats,
+  getSubtree,
+  getTraceTree,
   graphToJson,
+  groupByTraceId,
   loadGraph,
-  runTraced
-} from "./chunk-TT5DLU73.js";
-
-// src/graph-stitch.ts
-function groupByTraceId(graphs) {
-  const groups = /* @__PURE__ */ new Map();
-  for (const g of graphs) {
-    if (!g.traceId) continue;
-    const arr = groups.get(g.traceId) ?? [];
-    arr.push(g);
-    groups.set(g.traceId, arr);
-  }
-  return groups;
-}
-function stitchTrace(graphs) {
-  if (graphs.length === 0) throw new Error("No graphs to stitch");
-  const traceId = graphs[0].traceId ?? "";
-  const graphsBySpan = /* @__PURE__ */ new Map();
-  const childMap = /* @__PURE__ */ new Map();
-  let rootGraph = null;
-  for (const g of graphs) {
-    if (g.spanId) graphsBySpan.set(g.spanId, g);
-    if (!g.parentSpanId) {
-      if (!rootGraph || g.startTime < rootGraph.startTime) rootGraph = g;
-    }
-    if (g.parentSpanId) {
-      const siblings = childMap.get(g.parentSpanId) ?? [];
-      if (g.spanId) siblings.push(g.spanId);
-      childMap.set(g.parentSpanId, siblings);
-    }
-  }
-  if (!rootGraph) rootGraph = graphs[0];
-  let status = "completed";
-  let endTime = 0;
-  let startTime = Infinity;
-  for (const g of graphs) {
-    startTime = Math.min(startTime, g.startTime);
-    if (g.status === "failed") status = "failed";
-    else if (g.status === "running" && status !== "failed") status = "running";
-    if (g.endTime === null) endTime = null;
-    else if (endTime !== null) endTime = Math.max(endTime, g.endTime);
-  }
-  const frozenChildMap = /* @__PURE__ */ new Map();
-  for (const [k, v] of childMap) frozenChildMap.set(k, Object.freeze([...v]));
-  return Object.freeze({
-    traceId,
-    graphs: graphsBySpan,
-    rootGraph,
-    childMap: frozenChildMap,
-    startTime,
-    endTime,
-    status
-  });
-}
-function getTraceTree(trace) {
-  const result = [];
-  function walk(spanId) {
-    const graph = trace.graphs.get(spanId);
-    if (graph) result.push(graph);
-    const children = trace.childMap.get(spanId) ?? [];
-    for (const childSpan of children) walk(childSpan);
-  }
-  if (trace.rootGraph.spanId) walk(trace.rootGraph.spanId);
-  else result.push(trace.rootGraph);
-  return result;
-}
-
-// src/graph-query.ts
-function getNode(graph, nodeId) {
-  return graph.nodes.get(nodeId);
-}
-function getChildren(graph, nodeId) {
-  const node = graph.nodes.get(nodeId);
-  if (!node) return [];
-  const result = [];
-  for (const childId of node.children) {
-    const child = graph.nodes.get(childId);
-    if (child) result.push(child);
-  }
-  return result;
-}
-function getParent(graph, nodeId) {
-  const node = graph.nodes.get(nodeId);
-  if (!node || node.parentId === null) return void 0;
-  return graph.nodes.get(node.parentId);
-}
-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 getCriticalPath(graph) {
-  const root = graph.nodes.get(graph.rootNodeId);
-  if (!root) return [];
-  function nodeDuration(node) {
-    const end = node.endTime ?? Date.now();
-    return end - node.startTime;
-  }
-  function dfs(node) {
-    if (node.children.length === 0) {
-      return { duration: nodeDuration(node), path: [node] };
-    }
-    let bestChild = { duration: -1, path: [] };
-    for (const childId of node.children) {
-      const child = graph.nodes.get(childId);
-      if (!child) continue;
-      const result = dfs(child);
-      if (result.duration > bestChild.duration) {
-        bestChild = result;
-      }
-    }
-    return {
-      duration: nodeDuration(node) + bestChild.duration,
-      path: [node, ...bestChild.path]
-    };
-  }
-  return dfs(root).path;
-}
-function findWaitingOn(graph, nodeId) {
-  const results = [];
-  for (const edge of graph.edges) {
-    if (edge.from === nodeId && edge.type === "waited_on") {
-      const node = graph.nodes.get(edge.to);
-      if (node) results.push(node);
-    }
-  }
-  return results;
-}
-function getSubtree(graph, nodeId) {
-  const startNode = graph.nodes.get(nodeId);
-  if (!startNode) return [];
-  const result = [];
-  const queue = [...startNode.children];
-  while (queue.length > 0) {
-    const currentId = queue.shift();
-    if (currentId === void 0) break;
-    const current = graph.nodes.get(currentId);
-    if (!current) continue;
-    result.push(current);
-    queue.push(...current.children);
-  }
-  return result;
-}
-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
-  };
-}
+  runTraced,
+  startLive,
+  stitchTrace
+} from "./chunk-FJVQYJFB.js";
 export {
   createGraphBuilder,
   findWaitingOn,
@@ -225,5 +37,6 @@ export {
   groupByTraceId,
   loadGraph,
   runTraced,
+  startLive,
   stitchTrace
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentflow-core",
-  "version": "0.1.4",
+  "version": "0.2.1",
   "description": "Universal execution tracing for AI agent systems",
   "type": "module",
   "main": "./dist/index.cjs",

package/dist/chunk-TT5DLU73.js

@@ -1,435 +0,0 @@
-// src/graph-builder.ts
-import { randomUUID } from "crypto";
-function deepFreeze(obj) {
-  if (obj === null || typeof obj !== "object") return obj;
-  if (obj instanceof Map) {
-    Object.freeze(obj);
-    for (const value of obj.values()) {
-      deepFreeze(value);
-    }
-    return obj;
-  }
-  Object.freeze(obj);
-  const record = obj;
-  for (const key of Object.keys(record)) {
-    const value = record[key];
-    if (value !== null && typeof value === "object" && !Object.isFrozen(value)) {
-      deepFreeze(value);
-    }
-  }
-  return obj;
-}
-function createCounterIdGenerator() {
-  let counter = 0;
-  return () => {
-    counter++;
-    return `node_${String(counter).padStart(3, "0")}`;
-  };
-}
-function createGraphBuilder(config) {
-  const generateId = config?.idGenerator ?? createCounterIdGenerator();
-  const agentId = config?.agentId ?? "unknown";
-  const trigger = config?.trigger ?? "manual";
-  const spanId = randomUUID();
-  const traceId = config?.traceId ?? (typeof process !== "undefined" ? process.env?.AGENTFLOW_TRACE_ID : void 0) ?? randomUUID();
-  const parentSpanId = config?.parentSpanId ?? (typeof process !== "undefined" ? process.env?.AGENTFLOW_PARENT_SPAN_ID : void 0) ?? null;
-  const graphId = generateId();
-  const startTime = Date.now();
-  const nodes = /* @__PURE__ */ new Map();
-  const edges = [];
-  const events = [];
-  const parentStack = [];
-  let rootNodeId = null;
-  let built = false;
-  function assertNotBuilt() {
-    if (built) {
-      throw new Error("GraphBuilder: cannot mutate after build() has been called");
-    }
-  }
-  function getNode(nodeId) {
-    const node = nodes.get(nodeId);
-    if (!node) {
-      throw new Error(`GraphBuilder: node "${nodeId}" does not exist`);
-    }
-    return node;
-  }
-  function recordEvent(nodeId, eventType, data = {}) {
-    events.push({
-      timestamp: Date.now(),
-      eventType,
-      nodeId,
-      data
-    });
-  }
-  function buildGraph() {
-    if (rootNodeId === null) {
-      throw new Error("GraphBuilder: cannot build a graph with no nodes");
-    }
-    let graphStatus = "completed";
-    for (const node of nodes.values()) {
-      if (node.status === "failed" || node.status === "timeout" || node.status === "hung") {
-        graphStatus = "failed";
-        break;
-      }
-      if (node.status === "running") {
-        graphStatus = "running";
-      }
-    }
-    const endTime = graphStatus === "running" ? null : Date.now();
-    const frozenNodes = new Map(
-      [...nodes.entries()].map(([id, mNode]) => [
-        id,
-        {
-          id: mNode.id,
-          type: mNode.type,
-          name: mNode.name,
-          startTime: mNode.startTime,
-          endTime: mNode.endTime,
-          status: mNode.status,
-          parentId: mNode.parentId,
-          children: [...mNode.children],
-          metadata: { ...mNode.metadata },
-          state: { ...mNode.state }
-        }
-      ])
-    );
-    const graph = {
-      id: graphId,
-      rootNodeId,
-      nodes: frozenNodes,
-      edges: [...edges],
-      startTime,
-      endTime,
-      status: graphStatus,
-      trigger,
-      agentId,
-      events: [...events],
-      traceId,
-      spanId,
-      parentSpanId
-    };
-    return deepFreeze(graph);
-  }
-  const builder = {
-    get graphId() {
-      return graphId;
-    },
-    get traceContext() {
-      return { traceId, spanId };
-    },
-    startNode(opts) {
-      assertNotBuilt();
-      const id = generateId();
-      const parentId = opts.parentId ?? parentStack[parentStack.length - 1] ?? null;
-      if (parentId !== null && !nodes.has(parentId)) {
-        throw new Error(`GraphBuilder: parent node "${parentId}" does not exist`);
-      }
-      const node = {
-        id,
-        type: opts.type,
-        name: opts.name,
-        startTime: Date.now(),
-        endTime: null,
-        status: "running",
-        parentId,
-        children: [],
-        metadata: opts.metadata ? { ...opts.metadata } : {},
-        state: {}
-      };
-      nodes.set(id, node);
-      if (parentId !== null) {
-        const parent = nodes.get(parentId);
-        if (parent) {
-          parent.children.push(id);
-        }
-        edges.push({ from: parentId, to: id, type: "spawned" });
-      }
-      if (rootNodeId === null) {
-        rootNodeId = id;
-      }
-      recordEvent(id, "agent_start", { type: opts.type, name: opts.name });
-      return id;
-    },
-    endNode(nodeId, status = "completed") {
-      assertNotBuilt();
-      const node = getNode(nodeId);
-      if (node.endTime !== null) {
-        throw new Error(
-          `GraphBuilder: node "${nodeId}" has already ended (status: ${node.status})`
-        );
-      }
-      node.endTime = Date.now();
-      node.status = status;
-      recordEvent(nodeId, "agent_end", { status });
-    },
-    failNode(nodeId, error) {
-      assertNotBuilt();
-      const node = getNode(nodeId);
-      if (node.endTime !== null) {
-        throw new Error(
-          `GraphBuilder: node "${nodeId}" has already ended (status: ${node.status})`
-        );
-      }
-      const errorMessage = error instanceof Error ? error.message : error;
-      const errorStack = error instanceof Error ? error.stack : void 0;
-      node.endTime = Date.now();
-      node.status = "failed";
-      node.metadata.error = errorMessage;
-      if (errorStack) {
-        node.metadata.errorStack = errorStack;
-      }
-      recordEvent(nodeId, "tool_error", { error: errorMessage });
-    },
-    addEdge(from, to, type) {
-      assertNotBuilt();
-      getNode(from);
-      getNode(to);
-      edges.push({ from, to, type });
-      recordEvent(from, "custom", { to, type, action: "edge_add" });
-    },
-    pushEvent(event) {
-      assertNotBuilt();
-      getNode(event.nodeId);
-      events.push({
-        ...event,
-        timestamp: Date.now()
-      });
-    },
-    updateState(nodeId, state) {
-      assertNotBuilt();
-      const node = getNode(nodeId);
-      Object.assign(node.state, state);
-      recordEvent(nodeId, "custom", { action: "state_update", ...state });
-    },
-    withParent(parentId, fn) {
-      assertNotBuilt();
-      getNode(parentId);
-      parentStack.push(parentId);
-      try {
-        return fn();
-      } finally {
-        parentStack.pop();
-      }
-    },
-    getSnapshot() {
-      return buildGraph();
-    },
-    build() {
-      assertNotBuilt();
-      const graph = buildGraph();
-      built = true;
-      return graph;
-    }
-  };
-  return builder;
-}
-
-// src/loader.ts
-function toNodesMap(raw) {
-  if (raw instanceof Map) return raw;
-  if (Array.isArray(raw)) {
-    return new Map(raw);
-  }
-  if (raw !== null && typeof raw === "object") {
-    return new Map(Object.entries(raw));
-  }
-  return /* @__PURE__ */ new Map();
-}
-function loadGraph(input) {
-  const raw = typeof input === "string" ? JSON.parse(input) : input;
-  const nodes = toNodesMap(raw.nodes);
-  return {
-    id: raw.id ?? "",
-    rootNodeId: raw.rootNodeId ?? raw.rootId ?? "",
-    nodes,
-    edges: raw.edges ?? [],
-    startTime: raw.startTime ?? 0,
-    endTime: raw.endTime ?? null,
-    status: raw.status ?? "completed",
-    trigger: raw.trigger ?? "unknown",
-    agentId: raw.agentId ?? "unknown",
-    events: raw.events ?? [],
-    traceId: raw.traceId,
-    spanId: raw.spanId,
-    parentSpanId: raw.parentSpanId
-  };
-}
-function graphToJson(graph) {
-  const nodesObj = {};
-  for (const [id, node] of graph.nodes) {
-    nodesObj[id] = node;
-  }
-  return {
-    id: graph.id,
-    rootNodeId: graph.rootNodeId,
-    nodes: nodesObj,
-    edges: graph.edges,
-    startTime: graph.startTime,
-    endTime: graph.endTime,
-    status: graph.status,
-    trigger: graph.trigger,
-    agentId: graph.agentId,
-    events: graph.events,
-    traceId: graph.traceId,
-    spanId: graph.spanId,
-    parentSpanId: graph.parentSpanId
-  };
-}
-
-// src/runner.ts
-import { spawnSync } from "child_process";
-import { existsSync, mkdirSync, readdirSync, statSync, writeFileSync } from "fs";
-import { basename, join, resolve } from "path";
-function globToRegex(pattern) {
-  const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*").replace(/\?/g, ".");
-  return new RegExp(`^${escaped}$`);
-}
-function snapshotDir(dir, patterns) {
-  const result = /* @__PURE__ */ new Map();
-  if (!existsSync(dir)) return result;
-  for (const entry of readdirSync(dir)) {
-    if (!patterns.some((re) => re.test(entry))) continue;
-    const full = join(dir, entry);
-    try {
-      const stat = statSync(full);
-      if (stat.isFile()) {
-        result.set(full, stat.mtimeMs);
-      }
-    } catch {
-    }
-  }
-  return result;
-}
-function agentIdFromFilename(filePath) {
-  const base = basename(filePath, ".json");
-  const cleaned = base.replace(/-state$/, "");
-  return `alfred-${cleaned}`;
-}
-function deriveAgentId(command) {
-  return "orchestrator";
-}
-function fileTimestamp() {
-  return (/* @__PURE__ */ new Date()).toISOString().replace(/:/g, "-").replace(/\.\d+Z$/, "");
-}
-async function runTraced(config) {
-  const {
-    command,
-    agentId = deriveAgentId(command),
-    trigger = "cli",
-    tracesDir = "./traces",
-    watchDirs = [],
-    watchPatterns = ["*.json"]
-  } = config;
-  if (command.length === 0) {
-    throw new Error("runTraced: command must not be empty");
-  }
-  const resolvedTracesDir = resolve(tracesDir);
-  const patterns = watchPatterns.map(globToRegex);
-  const orchestrator = createGraphBuilder({ agentId, trigger });
-  const { traceId, spanId } = orchestrator.traceContext;
-  const beforeSnapshots = /* @__PURE__ */ new Map();
-  for (const dir of watchDirs) {
-    beforeSnapshots.set(dir, snapshotDir(dir, patterns));
-  }
-  const rootId = orchestrator.startNode({ type: "agent", name: agentId });
-  const dispatchId = orchestrator.startNode({
-    type: "tool",
-    name: "dispatch-command",
-    parentId: rootId
-  });
-  orchestrator.updateState(dispatchId, { command: command.join(" ") });
-  const monitorId = orchestrator.startNode({
-    type: "tool",
-    name: "state-monitor",
-    parentId: rootId
-  });
-  orchestrator.updateState(monitorId, {
-    watchDirs,
-    watchPatterns
-  });
-  const startMs = Date.now();
-  const execCmd = command[0] ?? "";
-  const execArgs = command.slice(1);
-  process.env.AGENTFLOW_TRACE_ID = traceId;
-  process.env.AGENTFLOW_PARENT_SPAN_ID = spanId;
-  const result = spawnSync(execCmd, execArgs, { stdio: "inherit" });
-  delete process.env.AGENTFLOW_TRACE_ID;
-  delete process.env.AGENTFLOW_PARENT_SPAN_ID;
-  const exitCode = result.status ?? 1;
-  const duration = (Date.now() - startMs) / 1e3;
-  const stateChanges = [];
-  for (const dir of watchDirs) {
-    const before = beforeSnapshots.get(dir) ?? /* @__PURE__ */ new Map();
-    const after = snapshotDir(dir, patterns);
-    for (const [filePath, mtime] of after) {
-      const prevMtime = before.get(filePath);
-      if (prevMtime === void 0 || mtime > prevMtime) {
-        stateChanges.push(filePath);
-      }
-    }
-  }
-  orchestrator.updateState(monitorId, { stateChanges });
-  orchestrator.endNode(monitorId);
-  if (exitCode === 0) {
-    orchestrator.endNode(dispatchId);
-  } else {
-    orchestrator.failNode(dispatchId, `Command exited with code ${exitCode}`);
-  }
-  orchestrator.updateState(rootId, {
-    exitCode,
-    duration,
-    stateChanges
-  });
-  if (exitCode === 0) {
-    orchestrator.endNode(rootId);
-  } else {
-    orchestrator.failNode(rootId, `Command exited with code ${exitCode}`);
-  }
-  const orchestratorGraph = orchestrator.build();
-  const allGraphs = [orchestratorGraph];
-  for (const filePath of stateChanges) {
-    const childAgentId = agentIdFromFilename(filePath);
-    const childBuilder = createGraphBuilder({
-      agentId: childAgentId,
-      trigger: "state-change",
-      traceId,
-      parentSpanId: spanId
-    });
-    const childRootId = childBuilder.startNode({
-      type: "agent",
-      name: childAgentId
-    });
-    childBuilder.updateState(childRootId, {
-      stateFile: filePath,
-      detectedBy: "runner-state-monitor"
-    });
-    childBuilder.endNode(childRootId);
-    allGraphs.push(childBuilder.build());
-  }
-  if (!existsSync(resolvedTracesDir)) {
-    mkdirSync(resolvedTracesDir, { recursive: true });
-  }
-  const ts = fileTimestamp();
-  const tracePaths = [];
-  for (const graph of allGraphs) {
-    const filename = `${graph.agentId}-${ts}.json`;
-    const outPath = join(resolvedTracesDir, filename);
-    writeFileSync(outPath, JSON.stringify(graphToJson(graph), null, 2), "utf-8");
-    tracePaths.push(outPath);
-  }
-  return {
-    exitCode,
-    traceId,
-    spanId,
-    tracePaths,
-    stateChanges,
-    duration
-  };
-}
-
-export {
-  createGraphBuilder,
-  loadGraph,
-  graphToJson,
-  runTraced
-};