groundswell 0.0.2 → 1.0.0

package/dist/debugger/event-replayer.js

@@ -0,0 +1,639 @@
+/**
+ * WorkflowEventReplayer - Reconstruct workflow tree from event history
+ *
+ * **Purpose**: Enables time-travel debugging by replaying workflow events
+ * to reconstruct workflow tree state at any point in execution history.
+ *
+ * **Phase 1 Scope**: Interface definition only. Implementation will be added
+ * in future PRPs (P2.M1.T1.S2 for structural events, P2.M1.T1.S3 for state events).
+ *
+ * **Architecture**:
+ * - Uses Map-based node tracking for O(1) lookups (pattern from WorkflowTreeDebugger)
+ * - Processes events sequentially using discriminated union pattern
+ * - Maintains tree invariants: single-parent rule, bidirectional references, no cycles
+ *
+ * **Event Categorization**:
+ * - **Structural Events** (modify tree structure): childAttached, childDetached, treeUpdated
+ * - **State Events** (update node properties): stateSnapshot, error
+ * - **Metadata Events** (logged but don't modify tree): agentPrompt*, toolInvocation, mcpEvent, reflection*, cache*, task*, step*
+ *
+ * @example
+ * ```typescript
+ * const replayer = new WorkflowEventReplayer();
+ * const tree = replayer.replay(eventStream);
+ * console.log(`Tree has ${tree.children.length} root children`);
+ * ```
+ */
+export class WorkflowEventReplayer {
+    /** Node lookup map for O(1) access */
+    nodeMap = new Map();
+    /** Root node of reconstructed tree */
+    root = null;
+    /**
+     * Replay a sequence of workflow events to reconstruct the workflow tree.
+     *
+     * **Event Processing Strategy:**
+     * - Processes events sequentially in order
+     * - Uses try-catch per event to isolate errors
+     * - Logs errors and continues processing on failure
+     * - Throws only if root cannot be established
+     *
+     * **Phase 1 - Structural Events** (implemented in P2.M1.T1.S2):
+     * - `childAttached`: Add new child node to parent's children array
+     * - `childDetached`: Remove child and all descendants from tree
+     * - `treeUpdated`: Update root reference to new tree
+     *
+     * **Phase 2 - State Events** (implemented in P2.M1.T1.S3):
+     * - `stateSnapshot`: Update node's stateSnapshot field
+     * - `error`: Record error information on node
+     * - `stepStart`: Track step execution start
+     * - `stepEnd`: Track step execution completion with duration
+     * - `taskStart`: Track task execution start
+     * - `taskEnd`: Track task execution completion
+     *
+     * **Phase 3 - Metadata Events** (logged but don't modify tree):
+     * - `agentPromptStart/End`, `toolInvocation`, `mcpEvent`, etc.
+     *
+     * **Tree Invariants Maintained:**
+     * - Single-parent rule: Each node has at most one parent
+     * - Bidirectional references: parent.children and child.parent are consistent
+     * - No circular references: Tree is a Directed Acyclic Graph (DAG)
+     *
+     * @param events - Array of workflow events in chronological order
+     * @returns Root node of the reconstructed workflow tree
+     * @throws {Error} If events array is empty
+     * @throws {Error} If root cannot be established from events
+     *
+     * @example
+     * ```typescript
+     * const replayer = new WorkflowEventReplayer();
+     * const tree = replayer.replay(eventStream);
+     * console.log(`Tree has ${tree.children.length} root children`);
+     * ```
+     */
+    replay(events) {
+        // Validate input
+        if (!events || events.length === 0) {
+            throw new Error('Events array is empty or null');
+        }
+        // Initialize state
+        this.nodeMap.clear();
+        this.root = null;
+        // Process events sequentially
+        for (const event of events) {
+            try {
+                switch (event.type) {
+                    // Structural events (P2.M1.T1.S2)
+                    case 'childAttached':
+                        this.handleChildAttached(event);
+                        break;
+                    case 'childDetached':
+                        this.handleChildDetached(event);
+                        break;
+                    case 'treeUpdated':
+                        this.handleTreeUpdated(event);
+                        break;
+                    // State events (P2.M1.T1.S3)
+                    case 'stateSnapshot':
+                        this.handleStateSnapshot(event);
+                        break;
+                    case 'error':
+                        this.handleErrorEvent(event);
+                        break;
+                    case 'stepStart':
+                        this.handleStepStart(event);
+                        break;
+                    case 'stepEnd':
+                        this.handleStepEnd(event);
+                        break;
+                    case 'taskStart':
+                        this.handleTaskStart(event);
+                        break;
+                    case 'taskEnd':
+                        this.handleTaskEnd(event);
+                        break;
+                    default:
+                        // Other metadata events - skip for now
+                        break;
+                }
+            }
+            catch (error) {
+                // Log error but continue processing subsequent events
+                console.error(`Error processing event type '${event.type}':`, error);
+            }
+        }
+        // Verify root was established
+        if (!this.root) {
+            throw new Error('No root node established from event stream');
+        }
+        return this.root;
+    }
+    /**
+     * Handle childAttached event - add subtree to tree.
+     *
+     * **Strategy:**
+     * 1. Deep clone event.child to avoid mutating original
+     * 2. Find parent node via nodeMap.get(event.parentId)
+     * 3. Validate: parent exists, single-parent rule, no circular references
+     * 4. Set child.parent = parent
+     * 5. Add child to parent.children array
+     * 6. Add child and all descendants to nodeMap via buildNodeMap()
+     * 7. Establish root if this is the first attachment
+     *
+     * **Invariants:**
+     * - Parent must exist in nodeMap (throw if not)
+     * - Child must not already have a different parent (single-parent rule)
+     * - No circular references (child must not be ancestor of parent)
+     * - Bidirectional links: child.parent = parent AND parent.children includes child
+     *
+     * **Deep Cloning:** Uses structuredClone() for safe deep copy
+     *
+     * @param event - ChildAttachedEvent with parentId and child node
+     * @throws {Error} If parent node not found
+     * @throws {Error} If child already has a parent
+     * @throws {Error} If attaching would create circular reference
+     *
+     * @example
+     * ```typescript
+     * // Event structure
+     * { type: 'childAttached', parentId: 'workflow-123', child: { id: 'workflow-456', ... } }
+     * // Result: workflow-456 is added as child of workflow-123
+     * ```
+     */
+    handleChildAttached(event) {
+        // Deep clone child to prevent mutation of event data
+        const child = structuredClone(event.child);
+        // Find parent
+        const parent = this.nodeMap.get(event.parentId);
+        if (!parent) {
+            throw new Error(`Parent node '${event.parentId}' not found in nodeMap during childAttached event`);
+        }
+        // Validation 1: Check if child already has a different parent (single-parent rule)
+        if (child.parent !== null && child.parent !== parent) {
+            throw new Error(`Child '${child.name}' already has a parent. A node can only have one parent.`);
+        }
+        // Validation 2: Check for circular references
+        if (this.isNodeDescendantOf(parent, child)) {
+            throw new Error(`Cannot attach '${child.name}' as child of '${parent.name}' - would create circular reference`);
+        }
+        // Set bidirectional parent-child links
+        child.parent = parent;
+        parent.children.push(child);
+        // Add child and all descendants to nodeMap
+        this.buildNodeMap(child);
+        // Establish root if this is the first attachment and parent has no parent
+        if (this.root === null && parent.parent === null) {
+            this.root = parent;
+        }
+    }
+    /**
+     * Handle childDetached event - remove subtree from tree.
+     *
+     * **Strategy:**
+     * 1. Find child node via nodeMap.get(event.childId)
+     * 2. Find parent node via nodeMap.get(event.parentId)
+     * 3. Validate: parent and child exist, child is direct child of parent
+     * 4. Remove child from parent.children array
+     * 5. Clear child.parent reference
+     * 6. Remove child and all descendants from nodeMap via removeSubtreeNodes()
+     *
+     * **Invariants:**
+     * - Both parent and child must exist in nodeMap
+     * - Child must be a direct child of parent (not just any descendant)
+     *
+     * **Error Handling:**
+     * - Logs warning and returns early if parent or child not found
+     * - Does not throw for missing nodes (replay continues)
+     *
+     * @param event - ChildDetachedEvent with parentId and childId
+     *
+     * @example
+     * ```typescript
+     * // Event structure
+     * { type: 'childDetached', parentId: 'workflow-123', childId: 'workflow-456' }
+     * // Result: workflow-456 and its descendants are removed from tree
+     * ```
+     */
+    handleChildDetached(event) {
+        // Find parent and child
+        const parent = this.nodeMap.get(event.parentId);
+        const child = this.nodeMap.get(event.childId);
+        if (!parent) {
+            console.warn(`Parent node '${event.parentId}' not found in nodeMap during childDetached event`);
+            return;
+        }
+        if (!child) {
+            console.warn(`Child node '${event.childId}' not found in nodeMap during childDetached event`);
+            return;
+        }
+        // Validate child is direct child of parent
+        const index = parent.children.indexOf(child);
+        if (index === -1) {
+            console.warn(`Child '${child.name}' is not a direct child of parent '${parent.name}' during childDetached event`);
+            return;
+        }
+        // Remove from parent's children array
+        parent.children.splice(index, 1);
+        // Clear child's parent reference
+        child.parent = null;
+        // Remove child and all descendants from nodeMap
+        this.removeSubtreeNodes(event.childId);
+    }
+    /**
+     * Handle treeUpdated event - update root reference.
+     *
+     * **Strategy:**
+     * 1. Verify event.root is a valid WorkflowNode
+     * 2. Update this.root = event.root
+     * 3. Clear nodeMap
+     * 4. Rebuild nodeMap from new root via buildNodeMap()
+     *
+     * **Use Case:**
+     * - Represents a complete tree replacement (not incremental update)
+     * - Rare in practice; most updates use childAttached/childDetached
+     *
+     * @param event - TreeUpdatedEvent with new root node
+     * @throws {Error} If event.root is null or undefined
+     *
+     * @example
+     * ```typescript
+     * // Event structure
+     * { type: 'treeUpdated', root: { id: 'workflow-123', children: [], ... } }
+     * // Result: this.root points to new tree, nodeMap rebuilt
+     * ```
+     */
+    handleTreeUpdated(event) {
+        if (!event.root) {
+            throw new Error('treeUpdated event has null or undefined root');
+        }
+        this.root = event.root;
+        // Clear and rebuild nodeMap from new root
+        this.nodeMap.clear();
+        this.buildNodeMap(event.root);
+    }
+    /**
+     * Handle stateSnapshot event - update node's state snapshot.
+     *
+     * **Strategy:**
+     * 1. Find node via nodeMap.get(event.node.id)
+     * 2. Extract event.node.stateSnapshot (not the entire node!)
+     * 3. Assign to node.stateSnapshot (direct assignment, last write wins)
+     *
+     * **Invariants:**
+     * - Node must exist in nodeMap
+     * - stateSnapshot can be null (no snapshot captured)
+     *
+     * **Error Handling:**
+     * - Logs warning if node not found (graceful degradation)
+     * - Does not throw for missing nodes
+     *
+     * **Null Handling:**
+     * - Allows null stateSnapshot values (valid state)
+     * - Don't throw error for null snapshots
+     *
+     * **Gotcha:** Event contains full node, but we only extract stateSnapshot field
+     * to avoid circular reference issues.
+     *
+     * @param event - StateSnapshotEvent with updated node
+     *
+     * @example
+     * ```typescript
+     * // Event structure
+     * { type: 'stateSnapshot', node: { id: 'workflow-123', stateSnapshot: { count: 42 }, ... } }
+     * // Result: node.stateSnapshot = { count: 42 }
+     * ```
+     */
+    handleStateSnapshot(event) {
+        // Find node in map
+        const node = this.nodeMap.get(event.node.id);
+        if (!node) {
+            // Graceful degradation - log warning and continue
+            console.warn(`Node '${event.node.id}' not found in nodeMap during stateSnapshot event. ` +
+                `This may indicate out-of-order events or missing structural events.`);
+            return;
+        }
+        // Extract just the snapshot data, not the entire node
+        // Gotcha: event.node contains full node, but we only need stateSnapshot
+        node.stateSnapshot = event.node.stateSnapshot;
+    }
+    /**
+     * Handle error event - record error on node.
+     *
+     * **Strategy:**
+     * 1. Find node via nodeMap.get(event.node.id)
+     * 2. Append event to node.events array (accumulation pattern)
+     *
+     * **Invariants:**
+     * - Node must exist in nodeMap
+     * - Error includes rich context (state, logs, stack)
+     *
+     * **Error Handling:**
+     * - Logs warning if node not found (graceful degradation)
+     * - Does not throw for missing nodes
+     *
+     * **Accumulation Pattern:**
+     * - Multiple errors are accumulated (not overwritten)
+     * - All errors preserved in node.events[] array
+     * - To find all errors: node.events.filter(e => e.type === 'error')
+     *
+     * **Gotcha:** WorkflowNode has no dedicated errors[] field.
+     * All errors are stored in the events[] array.
+     *
+     * @param event - ErrorEvent with error details
+     *
+     * @example
+     * ```typescript
+     * // Event structure
+     * { type: 'error', node: {...}, error: { message: 'Failed', state: {...}, logs: [...] } }
+     * // Result: Error event appended to node.events[]
+     * ```
+     */
+    handleErrorEvent(event) {
+        // Find node in map
+        const node = this.nodeMap.get(event.node.id);
+        if (!node) {
+            // Graceful degradation - log warning and continue
+            console.warn(`Node '${event.node.id}' not found in nodeMap during error event. ` +
+                `This may indicate out-of-order events or missing structural events.`);
+            return;
+        }
+        // Accumulate error in events array (append-only pattern)
+        // Gotcha: No dedicated errors[] field - use node.events[]
+        node.events.push(event);
+    }
+    /**
+     * Handle stepStart event - track step execution start.
+     *
+     * **Strategy:**
+     * 1. Find node via nodeMap.get(event.node.id)
+     * 2. Append event to node.events array for tracking
+     *
+     * **Invariants:**
+     * - Step nodes are created via @Step decorator
+     * - Step node may not exist yet if childAttached event hasn't been processed
+     *
+     * **Error Handling:**
+     * - Returns silently if step node not found (childAttached will add it later)
+     * - Does not log warning (step nodes are expected to be added separately)
+     *
+     * **Use Case:**
+     * - Tracks step execution for debugging and performance analysis
+     * - Metadata only - doesn't modify tree structure
+     *
+     * @param event - StepStartEvent with step name
+     *
+     * @example
+     * ```typescript
+     * // Event structure
+     * { type: 'stepStart', node: { id: 'step-123', ... }, step: 'processData' }
+     * // Result: Event appended to node.events[]
+     * ```
+     */
+    handleStepStart(event) {
+        // Find node in map
+        const node = this.nodeMap.get(event.node.id);
+        if (!node) {
+            // Step node may not exist yet - childAttached will add it later
+            // Don't log warning (expected for step nodes)
+            return;
+        }
+        // Track step start in events array
+        node.events.push(event);
+    }
+    /**
+     * Handle stepEnd event - track step execution completion with duration.
+     *
+     * **Strategy:**
+     * 1. Find node via nodeMap.get(event.node.id)
+     * 2. Append event to node.events array for tracking
+     * 3. Duration info is in event.duration field
+     *
+     * **Invariants:**
+     * - Step nodes are created via @Step decorator
+     * - Step node may not exist yet if childAttached event hasn't been processed
+     *
+     * **Error Handling:**
+     * - Returns silently if step node not found (childAttached will add it later)
+     * - Does not log warning (step nodes are expected to be added separately)
+     *
+     * **Use Case:**
+     * - Tracks step execution time for performance analysis
+     * - Metadata only - doesn't modify tree structure
+     *
+     * **Timing Info:**
+     * - Duration is in milliseconds
+     * - Access via event.duration field
+     *
+     * @param event - StepEndEvent with step name and duration
+     *
+     * @example
+     * ```typescript
+     * // Event structure
+     * { type: 'stepEnd', node: { id: 'step-123', ... }, step: 'processData', duration: 1500 }
+     * // Result: Event appended to node.events[], duration accessible
+     * ```
+     */
+    handleStepEnd(event) {
+        // Find node in map
+        const node = this.nodeMap.get(event.node.id);
+        if (!node) {
+            // Step node may not exist yet - childAttached will add it later
+            // Don't log warning (expected for step nodes)
+            return;
+        }
+        // Track step end with duration in events array
+        node.events.push(event);
+    }
+    /**
+     * Handle taskStart event - track task execution start.
+     *
+     * **Strategy:**
+     * 1. Find node via nodeMap.get(event.node.id)
+     * 2. Append event to node.events array for tracking
+     *
+     * **Invariants:**
+     * - Task events reference parent node (not a separate task node)
+     * - Parent node should exist in nodeMap
+     *
+     * **Error Handling:**
+     * - Logs warning if node not found (graceful degradation)
+     * - Does not throw for missing nodes
+     *
+     * **Use Case:**
+     * - Tracks task execution for debugging
+     * - Metadata only - doesn't modify tree structure
+     *
+     * **Difference from Steps:**
+     * - Tasks don't create separate nodes
+     * - Task events reference parent node
+     * - No duration tracking in task events
+     *
+     * @param event - TaskStartEvent with task name
+     *
+     * @example
+     * ```typescript
+     * // Event structure
+     * { type: 'taskStart', node: { id: 'workflow-123', ... }, task: 'cleanup' }
+     * // Result: Event appended to node.events[]
+     * ```
+     */
+    handleTaskStart(event) {
+        // Find node in map
+        const node = this.nodeMap.get(event.node.id);
+        if (!node) {
+            // Graceful degradation - log warning and continue
+            console.warn(`Node '${event.node.id}' not found in nodeMap during taskStart event. ` +
+                `This may indicate out-of-order events or missing structural events.`);
+            return;
+        }
+        // Track task start in events array
+        node.events.push(event);
+    }
+    /**
+     * Handle taskEnd event - track task execution completion.
+     *
+     * **Strategy:**
+     * 1. Find node via nodeMap.get(event.node.id)
+     * 2. Append event to node.events array for tracking
+     *
+     * **Invariants:**
+     * - Task events reference parent node (not a separate task node)
+     * - Parent node should exist in nodeMap
+     *
+     * **Error Handling:**
+     * - Logs warning if node not found (graceful degradation)
+     * - Does not throw for missing nodes
+     *
+     * **Use Case:**
+     * - Tracks task execution for debugging
+     * - Metadata only - doesn't modify tree structure
+     *
+     * **Gotcha:** taskEnd event does NOT have a duration field (unlike stepEnd)
+     *
+     * @param event - TaskEndEvent with task name
+     *
+     * @example
+     * ```typescript
+     * // Event structure
+     * { type: 'taskEnd', node: { id: 'workflow-123', ... }, task: 'cleanup' }
+     * // Result: Event appended to node.events[]
+     * ```
+     */
+    handleTaskEnd(event) {
+        // Find node in map
+        const node = this.nodeMap.get(event.node.id);
+        if (!node) {
+            // Graceful degradation - log warning and continue
+            console.warn(`Node '${event.node.id}' not found in nodeMap during taskEnd event. ` +
+                `This may indicate out-of-order events or missing structural events.`);
+            return;
+        }
+        // Track task end in events array
+        // Gotcha: No duration field in taskEnd event
+        node.events.push(event);
+    }
+    /**
+     * Build node lookup map recursively (pattern from WorkflowTreeDebugger).
+     *
+     * **Strategy:**
+     * - Depth-first traversal of subtree
+     * - Add each node to nodeMap: nodeMap.set(node.id, node)
+     * - Recurse for all children
+     *
+     * **Complexity:** O(k) where k = number of nodes in subtree
+     *
+     * @param node - Root of subtree to add to nodeMap
+     *
+     * @example
+     * ```typescript
+     * // After attaching a child, add it and descendants to map
+     * this.buildNodeMap(event.child);
+     * // Result: child and all descendants are now in nodeMap
+     * ```
+     */
+    buildNodeMap(node) {
+        this.nodeMap.set(node.id, node);
+        for (const child of node.children) {
+            this.buildNodeMap(child);
+        }
+    }
+    /**
+     * Remove entire subtree from node map using BFS traversal.
+     *
+     * **Strategy:**
+     * - BFS traversal to collect all descendant IDs
+     * - Batch delete all collected keys from nodeMap
+     * - Iterative (not recursive) to avoid stack overflow on deep trees
+     *
+     * **Complexity:** O(k) where k = number of nodes in subtree
+     *
+     * @param nodeId - ID of root node of subtree to remove
+     *
+     * @example
+     * ```typescript
+     * // After detaching a child, remove it and descendants from map
+     * this.removeSubtreeNodes(event.childId);
+     * // Result: child and all descendants removed from nodeMap
+     * ```
+     */
+    removeSubtreeNodes(nodeId) {
+        const node = this.nodeMap.get(nodeId);
+        if (!node)
+            return; // Already removed or never existed
+        // BFS traversal to collect all descendant IDs
+        const toRemove = [];
+        const queue = [node];
+        while (queue.length > 0) {
+            const current = queue.shift();
+            toRemove.push(current.id);
+            // Add children to queue for BFS traversal
+            queue.push(...current.children);
+        }
+        // Batch delete all collected keys (atomic update)
+        for (const id of toRemove) {
+            this.nodeMap.delete(id);
+        }
+    }
+    /**
+     * Check if node is descendant of potential ancestor.
+     * Uses cycle detection to prevent infinite loops during traversal.
+     *
+     * **Strategy:**
+     * - Traverse parent chain upward from node
+     * - Track visited nodes to detect cycles
+     * - Return true if ancestor found in parent chain
+     *
+     * **Complexity:** O(d) where d = depth of hierarchy
+     *
+     * @param node - Node to start traversal from
+     * @param potentialAncestor - Potential ancestor to search for
+     * @returns true if ancestor found in parent chain
+     * @throws {Error} If circular reference detected
+     *
+     * @example
+     * ```typescript
+     * // Check if attaching would create cycle
+     * if (this.isNodeDescendantOf(parent, child)) {
+     *   throw new Error('Would create circular reference');
+     * }
+     * ```
+     */
+    isNodeDescendantOf(node, potentialAncestor) {
+        const visited = new Set();
+        let current = node.parent;
+        while (current !== null) {
+            // Cycle detection
+            if (visited.has(current)) {
+                throw new Error('Circular parent-child relationship detected');
+            }
+            visited.add(current);
+            // Check if we found the ancestor
+            if (current === potentialAncestor) {
+                return true;
+            }
+            current = current.parent;
+        }
+        return false;
+    }
+}
+//# sourceMappingURL=event-replayer.js.map

package/dist/debugger/event-replayer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"event-replayer.js","sourceRoot":"","sources":["../../src/debugger/event-replayer.ts"],"names":[],"mappings":"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"}

package/dist/debugger/index.d.ts

@@ -0,0 +1,2 @@
+export { WorkflowTreeDebugger } from './tree-debugger.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/debugger/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/debugger/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,oBAAoB,CAAC"}

package/{src/debugger/index.ts → dist/debugger/index.js}

@@ -1 +1,2 @@
 export { WorkflowTreeDebugger } from './tree-debugger.js';
+//# sourceMappingURL=index.js.map

package/dist/debugger/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/debugger/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,oBAAoB,CAAC"}