groundswell 0.0.2 → 0.0.3

package/src/__tests__/unit/tree-debugger-incremental.test.ts

@@ -1,170 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { Workflow, WorkflowTreeDebugger } from '../../index.js';
-
-class IncrementalTestWorkflow extends Workflow {
-  async run(): Promise<void> {
-    this.setStatus('completed');
-  }
-}
-
-describe('Incremental Node Map Updates', () => {
-  it('childDetached removes entire subtree (node + descendants)', () => {
-    const root = new IncrementalTestWorkflow('Root');
-    const child1 = new IncrementalTestWorkflow('Child1', root);
-    const grandchild = new IncrementalTestWorkflow('Grandchild', child1);
-    const child2 = new IncrementalTestWorkflow('Child2', root);
-
-    const debugger_ = new WorkflowTreeDebugger(root);
-
-    // Verify all nodes are initially in the map
-    expect(debugger_.getNode(root.id)).toBe(root.getNode());
-    expect(debugger_.getNode(child1.id)).toBe(child1.getNode());
-    expect(debugger_.getNode(grandchild.id)).toBe(grandchild.getNode());
-    expect(debugger_.getNode(child2.id)).toBe(child2.getNode());
-    expect(debugger_.getStats().totalNodes).toBe(4);
-
-    // Detach child1 (should remove child1 + grandchild)
-    root.detachChild(child1);
-
-    // Verify child1 and grandchild are removed
-    expect(debugger_.getNode(child1.id)).toBeUndefined();
-    expect(debugger_.getNode(grandchild.id)).toBeUndefined();
-
-    // Verify root and child2 are still present
-    expect(debugger_.getNode(root.id)).toBe(root.getNode());
-    expect(debugger_.getNode(child2.id)).toBe(child2.getNode());
-
-    // Verify total node count decreased by 2
-    expect(debugger_.getStats().totalNodes).toBe(2);
-  });
-
-  it('childDetached on already-removed node is no-op', () => {
-    const root = new IncrementalTestWorkflow('Root');
-    const child1 = new IncrementalTestWorkflow('Child1', root);
-    const grandchild = new IncrementalTestWorkflow('Grandchild', child1);
-
-    const debugger_ = new WorkflowTreeDebugger(root);
-    expect(debugger_.getStats().totalNodes).toBe(3);
-
-    // Detach child1
-    root.detachChild(child1);
-    expect(debugger_.getStats().totalNodes).toBe(1);
-    expect(debugger_.getNode(child1.id)).toBeUndefined();
-    expect(debugger_.getNode(grandchild.id)).toBeUndefined();
-
-    // Simulate the edge case where nodeMap still has orphaned nodes
-    // by directly removing a node that was never properly attached
-    // This tests the removeSubtreeNodes() no-op behavior
-    const orphanId = 'nonexistent-node';
-    expect(debugger_.getNode(orphanId)).toBeUndefined();
-
-    // Calling removeSubtreeNodes on a non-existent node should be safe
-    // We can't call detachChild twice because it throws, but we can
-    // verify the nodeMap state is consistent
-    expect(debugger_.getStats().totalNodes).toBe(1);
-  });
-
-  it('childAttached adds subtree (verify existing behavior)', () => {
-    const root = new IncrementalTestWorkflow('Root');
-
-    const debugger_ = new WorkflowTreeDebugger(root);
-    expect(debugger_.getStats().totalNodes).toBe(1);
-
-    // Attach a child with its own subtree
-    const child1 = new IncrementalTestWorkflow('Child1', root);
-    const grandchild = new IncrementalTestWorkflow('Grandchild', child1);
-
-    // Verify all nodes are in the map
-    expect(debugger_.getNode(root.id)).toBe(root.getNode());
-    expect(debugger_.getNode(child1.id)).toBe(child1.getNode());
-    expect(debugger_.getNode(grandchild.id)).toBe(grandchild.getNode());
-    expect(debugger_.getStats().totalNodes).toBe(3);
-  });
-
-  it('onTreeChanged does not rebuild map', () => {
-    const root = new IncrementalTestWorkflow('Root');
-    const child1 = new IncrementalTestWorkflow('Child1', root);
-    const grandchild = new IncrementalTestWorkflow('Grandchild', child1);
-    const child2 = new IncrementalTestWorkflow('Child2', root);
-
-    const debugger_ = new WorkflowTreeDebugger(root);
-
-    // Get reference to the nodeMap (we'll check it's the same object)
-    const nodeMapBefore = debugger_.getStats();
-
-    // Detach child1
-    root.detachChild(child1);
-
-    // Verify map was updated incrementally (nodes removed)
-    expect(debugger_.getStats().totalNodes).toBe(2);
-    expect(debugger_.getNode(child1.id)).toBeUndefined();
-    expect(debugger_.getNode(grandchild.id)).toBeUndefined();
-
-    // Verify remaining nodes are still accessible
-    expect(debugger_.getNode(root.id)).toBe(root.getNode());
-    expect(debugger_.getNode(child2.id)).toBe(child2.getNode());
-  });
-
-  it('multiple rapid attach/detach operations work correctly', () => {
-    const root = new IncrementalTestWorkflow('Root');
-    const child1 = new IncrementalTestWorkflow('Child1', root);
-    const child2 = new IncrementalTestWorkflow('Child2', root);
-    const grandchild1 = new IncrementalTestWorkflow('Grandchild1', child1);
-    const grandchild2 = new IncrementalTestWorkflow('Grandchild2', child1);
-
-    const debugger_ = new WorkflowTreeDebugger(root);
-    expect(debugger_.getStats().totalNodes).toBe(5);
-
-    // Detach child1 (removes child1 + 2 grandchildren)
-    root.detachChild(child1);
-    expect(debugger_.getStats().totalNodes).toBe(2);
-
-    // Attach a new child
-    const child3 = new IncrementalTestWorkflow('Child3', root);
-    expect(debugger_.getStats().totalNodes).toBe(3);
-    expect(debugger_.getNode(child3.id)).toBe(child3.getNode());
-
-    // Detach child2
-    root.detachChild(child2);
-    expect(debugger_.getStats().totalNodes).toBe(2);
-
-    // Verify final state
-    expect(debugger_.getNode(root.id)).toBe(root.getNode());
-    expect(debugger_.getNode(child3.id)).toBe(child3.getNode());
-    expect(debugger_.getNode(child1.id)).toBeUndefined();
-    expect(debugger_.getNode(child2.id)).toBeUndefined();
-    expect(debugger_.getNode(grandchild1.id)).toBeUndefined();
-    expect(debugger_.getNode(grandchild2.id)).toBeUndefined();
-  });
-
-  it('detaching node with many descendants removes all', () => {
-    const root = new IncrementalTestWorkflow('Root');
-
-    // Build a deep subtree
-    const child1 = new IncrementalTestWorkflow('Child1', root);
-    let current = child1;
-    const descendants: IncrementalTestWorkflow[] = [];
-    for (let i = 0; i < 10; i++) {
-      const descendant = new IncrementalTestWorkflow(`Descendant${i}`, current);
-      descendants.push(descendant);
-      current = descendant;
-    }
-
-    const debugger_ = new WorkflowTreeDebugger(root);
-    // Total: 1 root + 1 child1 + 10 descendants = 12 nodes
-    expect(debugger_.getStats().totalNodes).toBe(12);
-
-    // Detach child1 (should remove child1 + all 10 descendants)
-    root.detachChild(child1);
-
-    // Verify all were removed
-    expect(debugger_.getStats().totalNodes).toBe(1);
-    expect(debugger_.getNode(child1.id)).toBeUndefined();
-    for (const descendant of descendants) {
-      expect(debugger_.getNode(descendant.id)).toBeUndefined();
-    }
-
-    // Verify root is still there
-    expect(debugger_.getNode(root.id)).toBe(root.getNode());
-  });
-});

package/src/__tests__/unit/tree-debugger.test.ts

@@ -1,85 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { Workflow, WorkflowTreeDebugger } from '../../index.js';
-
-class DebugTestWorkflow extends Workflow {
-  async run(): Promise<void> {
-    this.setStatus('completed');
-  }
-}
-
-describe('WorkflowTreeDebugger', () => {
-  it('should render tree string', () => {
-    const wf = new DebugTestWorkflow('Root');
-    const debugger_ = new WorkflowTreeDebugger(wf);
-
-    const tree = debugger_.toTreeString();
-    expect(tree).toContain('Root');
-    expect(tree).toContain('[idle]');
-  });
-
-  it('should show child nodes in tree', () => {
-    const parent = new DebugTestWorkflow('Parent');
-    const child1 = new DebugTestWorkflow('Child1', parent);
-    const child2 = new DebugTestWorkflow('Child2', parent);
-
-    const debugger_ = new WorkflowTreeDebugger(parent);
-    const tree = debugger_.toTreeString();
-
-    expect(tree).toContain('Parent');
-    expect(tree).toContain('Child1');
-    expect(tree).toContain('Child2');
-    expect(tree).toContain('├──');
-    expect(tree).toContain('└──');
-  });
-
-  it('should find node by ID', () => {
-    const parent = new DebugTestWorkflow('Parent');
-    const child = new DebugTestWorkflow('Child', parent);
-
-    const debugger_ = new WorkflowTreeDebugger(parent);
-
-    expect(debugger_.getNode(parent.id)).toBe(parent.getNode());
-    expect(debugger_.getNode(child.id)).toBe(child.getNode());
-    expect(debugger_.getNode('nonexistent')).toBeUndefined();
-  });
-
-  it('should collect logs from all nodes', async () => {
-    const parent = new DebugTestWorkflow('Parent');
-    const child = new DebugTestWorkflow('Child', parent);
-
-    const debugger_ = new WorkflowTreeDebugger(parent);
-
-    // Add some logs manually
-    parent.getNode().logs.push({
-      id: '1',
-      workflowId: parent.id,
-      timestamp: Date.now(),
-      level: 'info',
-      message: 'Parent log',
-    });
-
-    child.getNode().logs.push({
-      id: '2',
-      workflowId: child.id,
-      timestamp: Date.now(),
-      level: 'info',
-      message: 'Child log',
-    });
-
-    const logString = debugger_.toLogString();
-    expect(logString).toContain('Parent log');
-    expect(logString).toContain('Child log');
-  });
-
-  it('should return stats', () => {
-    const parent = new DebugTestWorkflow('Parent');
-    new DebugTestWorkflow('Child1', parent);
-    new DebugTestWorkflow('Child2', parent);
-
-    const debugger_ = new WorkflowTreeDebugger(parent);
-    const stats = debugger_.getStats();
-
-    expect(stats.totalNodes).toBe(3);
-    expect(stats.byStatus.idle).toBe(3);
-  });
-});

package/src/__tests__/unit/utils/workflow-error-utils.test.ts

@@ -1,209 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { mergeWorkflowErrors } from '../../../utils/workflow-error-utils.js';
-import type { WorkflowError } from '../../../types/error.js';
-
-describe('mergeWorkflowErrors', () => {
-  // Helper function to create a mock WorkflowError
-  function createMockWorkflowError(overrides?: Partial<WorkflowError>): WorkflowError {
-    return {
-      message: 'Test error',
-      original: new Error('Original error'),
-      workflowId: 'wf-test-123',
-      stack: 'Error: Test error\n    at test.ts:10:15',
-      state: { key: 'value' },
-      logs: [
-        {
-          id: 'log-1',
-          workflowId: 'wf-test-123',
-          timestamp: Date.now(),
-          level: 'error',
-          message: 'Test log message',
-        },
-      ],
-      ...overrides,
-    };
-  }
-
-  it('should return a single error when merging one error', () => {
-    const error = createMockWorkflowError({ workflowId: 'wf-1' });
-    const result = mergeWorkflowErrors([error], 'testTask', 'parent-wf', 1);
-
-    expect(result.message).toBe("1 of 1 concurrent child workflows failed in task 'testTask'");
-    expect(result.workflowId).toBe('parent-wf');
-    expect(result.logs).toEqual(error.logs);
-    expect(result.stack).toBe(error.stack);
-    expect(result.state).toEqual(error.state);
-  });
-
-  it('should aggregate multiple errors with unique workflow IDs', () => {
-    const error1 = createMockWorkflowError({
-      message: 'Error 1',
-      workflowId: 'wf-1',
-      stack: 'stack 1',
-      state: { key1: 'value1' },
-      logs: [{ id: 'log-1', workflowId: 'wf-1', timestamp: 1000, level: 'error', message: 'Log 1' }],
-    });
-    const error2 = createMockWorkflowError({
-      message: 'Error 2',
-      workflowId: 'wf-2',
-      stack: 'stack 2',
-      state: { key2: 'value2' },
-      logs: [{ id: 'log-2', workflowId: 'wf-2', timestamp: 2000, level: 'error', message: 'Log 2' }],
-    });
-    const error3 = createMockWorkflowError({
-      message: 'Error 3',
-      workflowId: 'wf-3',
-      stack: 'stack 3',
-      state: { key3: 'value3' },
-      logs: [{ id: 'log-3', workflowId: 'wf-3', timestamp: 3000, level: 'error', message: 'Log 3' }],
-    });
-
-    const result = mergeWorkflowErrors([error1, error2, error3], 'concurrentTask', 'parent-wf', 5);
-
-    expect(result.message).toBe("3 of 5 concurrent child workflows failed in task 'concurrentTask'");
-    expect(result.workflowId).toBe('parent-wf');
-    expect(result.stack).toBe('stack 1'); // First error's stack
-    expect(result.state).toEqual({ key1: 'value1' }); // First error's state
-    expect(result.logs).toHaveLength(3); // All logs aggregated
-  });
-
-  it('should deduplicate workflow IDs when errors have duplicate IDs', () => {
-    const error1 = createMockWorkflowError({ workflowId: 'wf-dup' });
-    const error2 = createMockWorkflowError({ workflowId: 'wf-dup' });
-    const error3 = createMockWorkflowError({ workflowId: 'wf-unique' });
-
-    const result = mergeWorkflowErrors([error1, error2, error3], 'testTask', 'parent-wf', 4);
-
-    // Access the metadata from original field
-    const metadata = result.original as {
-      name: string;
-      message: string;
-      errors: WorkflowError[];
-      totalChildren: number;
-      failedChildren: number;
-      failedWorkflowIds: string[];
-    };
-
-    expect(metadata.failedWorkflowIds).toEqual(['wf-dup', 'wf-unique']);
-    expect(metadata.failedWorkflowIds).toHaveLength(2); // Deduplicated
-  });
-
-  it('should flatten logs arrays from all errors using flatMap', () => {
-    const error1 = createMockWorkflowError({
-      workflowId: 'wf-1',
-      logs: [
-        { id: 'log-1', workflowId: 'wf-1', timestamp: 1000, level: 'info', message: 'Log 1.1' },
-        { id: 'log-2', workflowId: 'wf-1', timestamp: 2000, level: 'info', message: 'Log 1.2' },
-      ],
-    });
-    const error2 = createMockWorkflowError({
-      workflowId: 'wf-2',
-      logs: [
-        { id: 'log-3', workflowId: 'wf-2', timestamp: 3000, level: 'error', message: 'Log 2.1' },
-        { id: 'log-4', workflowId: 'wf-2', timestamp: 4000, level: 'error', message: 'Log 2.2' },
-      ],
-    });
-
-    const result = mergeWorkflowErrors([error1, error2], 'testTask', 'parent-wf', 2);
-
-    expect(result.logs).toHaveLength(4);
-    expect(result.logs[0].message).toBe('Log 1.1');
-    expect(result.logs[1].message).toBe('Log 1.2');
-    expect(result.logs[2].message).toBe('Log 2.1');
-    expect(result.logs[3].message).toBe('Log 2.2');
-  });
-
-  it('should use first error stack trace', () => {
-    const error1 = createMockWorkflowError({ stack: 'First stack trace' });
-    const error2 = createMockWorkflowError({ stack: 'Second stack trace' });
-    const error3 = createMockWorkflowError({ stack: 'Third stack trace' });
-
-    const result = mergeWorkflowErrors([error1, error2, error3], 'testTask', 'parent-wf', 3);
-
-    expect(result.stack).toBe('First stack trace');
-  });
-
-  it('should use first error state', () => {
-    const error1 = createMockWorkflowError({ state: { first: 'state1' } });
-    const error2 = createMockWorkflowError({ state: { second: 'state2' } });
-
-    const result = mergeWorkflowErrors([error1, error2], 'testTask', 'parent-wf', 2);
-
-    expect(result.state).toEqual({ first: 'state1' });
-  });
-
-  it('should use empty object when first error has no state', () => {
-    const error1 = createMockWorkflowError({ state: undefined as any });
-    const error2 = createMockWorkflowError({ state: { hasState: 'yes' } });
-
-    const result = mergeWorkflowErrors([error1, error2], 'testTask', 'parent-wf', 2);
-
-    expect(result.state).toEqual({});
-  });
-
-  it('should handle undefined stack trace gracefully', () => {
-    const error1 = createMockWorkflowError({ stack: undefined });
-    const error2 = createMockWorkflowError({ stack: 'Has stack' });
-
-    const result = mergeWorkflowErrors([error1, error2], 'testTask', 'parent-wf', 2);
-
-    expect(result.stack).toBeUndefined();
-  });
-
-  it('should include metadata in original field', () => {
-    const error1 = createMockWorkflowError({ workflowId: 'wf-1' });
-    const error2 = createMockWorkflowError({ workflowId: 'wf-2' });
-    const error3 = createMockWorkflowError({ workflowId: 'wf-3' });
-
-    const result = mergeWorkflowErrors([error1, error2, error3], 'concurrentTask', 'parent-wf', 5);
-
-    const metadata = result.original as {
-      name: string;
-      message: string;
-      errors: WorkflowError[];
-      totalChildren: number;
-      failedChildren: number;
-      failedWorkflowIds: string[];
-    };
-
-    expect(metadata.name).toBe('WorkflowAggregateError');
-    expect(metadata.message).toBe("3 of 5 concurrent child workflows failed in task 'concurrentTask'");
-    expect(metadata.errors).toEqual([error1, error2, error3]);
-    expect(metadata.totalChildren).toBe(5);
-    expect(metadata.failedChildren).toBe(3);
-    expect(metadata.failedWorkflowIds).toEqual(['wf-1', 'wf-2', 'wf-3']);
-  });
-
-  it('should handle empty logs array', () => {
-    const error1 = createMockWorkflowError({ logs: [] });
-    const error2 = createMockWorkflowError({ logs: [] });
-
-    const result = mergeWorkflowErrors([error1, error2], 'testTask', 'parent-wf', 2);
-
-    expect(result.logs).toEqual([]);
-  });
-
-  it('should include task name in message', () => {
-    const error = createMockWorkflowError();
-    const result = mergeWorkflowErrors([error], 'myCustomTask', 'parent-wf', 1);
-
-    expect(result.message).toContain("task 'myCustomTask'");
-  });
-
-  it('should include correct counts in message', () => {
-    const errors = Array.from({ length: 3 }, (_, i) =>
-      createMockWorkflowError({ workflowId: `wf-${i}` })
-    );
-
-    const result = mergeWorkflowErrors(errors, 'testTask', 'parent-wf', 10);
-
-    expect(result.message).toBe("3 of 10 concurrent child workflows failed in task 'testTask'");
-  });
-
-  it('should preserve parent workflow ID', () => {
-    const error = createMockWorkflowError({ workflowId: 'child-123' });
-    const result = mergeWorkflowErrors([error], 'testTask', 'parent-abc', 1);
-
-    expect(result.workflowId).toBe('parent-abc');
-  });
-});

package/src/__tests__/unit/workflow-detachChild.test.ts

@@ -1,100 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { Workflow, WorkflowObserver, WorkflowEvent } from '../../index.js';
-
-class SimpleWorkflow extends Workflow {
-  async run(): Promise<string> {
-    this.setStatus('running');
-    this.setStatus('completed');
-    return 'done';
-  }
-}
-
-describe('Workflow.detachChild()', () => {
-  it('should remove child from parent.children array', () => {
-    // Arrange: Create parent with child
-    const parent = new SimpleWorkflow('Parent');
-    const child = new SimpleWorkflow('Child', parent);
-
-    // Assert: Verify child is in parent.children
-    expect(parent.children).toContain(child);
-
-    // Act: Call detachChild (will fail - method doesn't exist)
-    parent.detachChild(child);
-
-    // Assert: Verify child removed from parent.children
-    expect(parent.children).not.toContain(child);
-  });
-
-  it('should clear child.parent to null', () => {
-    // Arrange: Create parent with child
-    const parent = new SimpleWorkflow('Parent');
-    const child = new SimpleWorkflow('Child', parent);
-
-    // Assert: Verify child.parent is set
-    expect(child.parent).toBe(parent);
-
-    // Act: Call detachChild
-    parent.detachChild(child);
-
-    // Assert: Verify child.parent is null
-    expect(child.parent).toBeNull();
-  });
-
-  it('should remove child.node from parent.node.children array', () => {
-    // Arrange: Create parent with child
-    const parent = new SimpleWorkflow('Parent');
-    const child = new SimpleWorkflow('Child', parent);
-
-    // Assert: Verify child.node is in parent.node.children
-    expect(parent.getNode().children).toContain(child.getNode());
-
-    // Act: Call detachChild
-    parent.detachChild(child);
-
-    // Assert: Verify child.node removed from parent.node.children
-    expect(parent.getNode().children).not.toContain(child.getNode());
-  });
-
-  it('should emit childDetached event with correct payload', () => {
-    // Arrange: Create parent with observer
-    const parent = new SimpleWorkflow('Parent');
-    const events: WorkflowEvent[] = [];
-
-    const observer: WorkflowObserver = {
-      onLog: () => {},
-      onEvent: (event) => events.push(event),
-      onStateUpdated: () => {},
-      onTreeChanged: () => {},
-    };
-
-    parent.addObserver(observer);
-
-    // Act: Create child (triggers attachChild event), then detach
-    const child = new SimpleWorkflow('Child', parent);
-    events.length = 0; // Clear attachChild events
-
-    parent.detachChild(child);
-
-    // Assert: Verify childDetached event was emitted
-    const detachEvent = events.find((e) => e.type === 'childDetached');
-    expect(detachEvent).toBeDefined();
-
-    // Assert: Verify event payload (with type guard for discriminated union)
-    expect(detachEvent?.type === 'childDetached' && detachEvent.parentId).toBe(parent.id);
-    expect(detachEvent?.type === 'childDetached' && detachEvent.childId).toBe(child.id);
-  });
-
-  it('should throw error when child is not attached to parent', () => {
-    // Arrange: Create parent and child separately (no attachment)
-    const parent = new SimpleWorkflow('Parent');
-    const child = new SimpleWorkflow('Child');
-
-    // Assert: Verify child is NOT in parent.children
-    expect(parent.children).not.toContain(child);
-
-    // Act & Assert: Calling detachChild should throw error
-    expect(() => parent.detachChild(child)).toThrow(
-      /not attached/i
-    );
-  });
-});