agentflow-core 0.1.0

package/dist/index.js

@@ -0,0 +1,368 @@
+// src/graph-builder.ts
+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 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 getNode2(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]
+    };
+    return deepFreeze(graph);
+  }
+  const builder = {
+    get graphId() {
+      return graphId;
+    },
+    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 = getNode2(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 = getNode2(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();
+      getNode2(from);
+      getNode2(to);
+      edges.push({ from, to, type });
+      recordEvent(from, "custom", { to, type, action: "edge_add" });
+    },
+    pushEvent(event) {
+      assertNotBuilt();
+      getNode2(event.nodeId);
+      events.push({
+        ...event,
+        timestamp: Date.now()
+      });
+    },
+    updateState(nodeId, state) {
+      assertNotBuilt();
+      const node = getNode2(nodeId);
+      Object.assign(node.state, state);
+      recordEvent(nodeId, "custom", { action: "state_update", ...state });
+    },
+    withParent(parentId, fn) {
+      assertNotBuilt();
+      getNode2(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/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
+  };
+}
+export {
+  createGraphBuilder,
+  findWaitingOn,
+  getChildren,
+  getCriticalPath,
+  getDepth,
+  getDuration,
+  getFailures,
+  getHungNodes,
+  getNode,
+  getParent,
+  getStats,
+  getSubtree
+};

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "agentflow-core",
+  "version": "0.1.0",
+  "description": "Universal execution tracing for AI agent systems",
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup src/index.ts --format esm,cjs --dts --clean --tsconfig tsconfig.build.json"
+  },
+  "dependencies": {},
+  "keywords": [
+    "ai",
+    "agent",
+    "tracing",
+    "execution-graph",
+    "observability"
+  ],
+  "license": "MIT"
+}