groundswell 0.0.2 → 1.0.0

package/src/__tests__/integration/tree-mirroring.test.ts

@@ -1,151 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import {
-  TDDOrchestrator,
-  WorkflowTreeDebugger,
-  WorkflowEvent,
-  WorkflowObserver,
-} from '../../index.js';
-
-describe('Tree Mirroring Integration', () => {
-  it('should create 1:1 tree mirror of workflow execution', async () => {
-    const orchestrator = new TDDOrchestrator('TDDOrchestrator');
-    (orchestrator as any).maxCycles = 1; // Limit to one cycle for test
-
-    const debugger_ = new WorkflowTreeDebugger(orchestrator);
-    const events: WorkflowEvent[] = [];
-
-    debugger_.events.subscribe({
-      next: (event) => events.push(event),
-    });
-
-    try {
-      await orchestrator.run();
-    } catch {
-      // May fail due to random test failures, that's ok
-    }
-
-    // Verify tree structure
-    const tree = debugger_.getTree();
-    expect(tree.name).toBe('TDDOrchestrator');
-
-    // Should have at least one child (the cycle)
-    expect(tree.children.length).toBeGreaterThanOrEqual(1);
-
-    // Child should be named Cycle-N
-    const cycleChild = tree.children.find((c) => c.name.startsWith('Cycle-'));
-    expect(cycleChild).toBeDefined();
-
-    // Verify events were captured
-    expect(events.some((e) => e.type === 'stepStart')).toBe(true);
-    expect(events.some((e) => e.type === 'taskStart')).toBe(true);
-  });
-
-  it('should propagate events to root observer', async () => {
-    const orchestrator = new TDDOrchestrator('Root');
-    (orchestrator as any).maxCycles = 1;
-
-    const allEvents: WorkflowEvent[] = [];
-    const allLogs: any[] = [];
-
-    const observer: WorkflowObserver = {
-      onLog: (entry) => allLogs.push(entry),
-      onEvent: (event) => allEvents.push(event),
-      onStateUpdated: () => {},
-      onTreeChanged: () => {},
-    };
-
-    orchestrator.addObserver(observer);
-
-    try {
-      await orchestrator.run();
-    } catch {
-      // May fail
-    }
-
-    // Events from child workflows should reach root
-    expect(allLogs.length).toBeGreaterThan(0);
-    expect(allEvents.length).toBeGreaterThan(0);
-
-    // Should have events from both parent and child
-    const parentEvents = allEvents.filter(
-      (e) => 'node' in e && e.node.name === 'Root'
-    );
-    const childEvents = allEvents.filter(
-      (e) => 'node' in e && e.node.name.startsWith('Cycle-')
-    );
-
-    expect(parentEvents.length).toBeGreaterThan(0);
-    expect(childEvents.length).toBeGreaterThan(0);
-  });
-
-  it('should include state snapshot on error', async () => {
-    const orchestrator = new TDDOrchestrator('ErrorTest');
-    (orchestrator as any).maxCycles = 1;
-
-    const errorEvents: WorkflowEvent[] = [];
-
-    orchestrator.addObserver({
-      onLog: () => {},
-      onEvent: (event) => {
-        if (event.type === 'error') {
-          errorEvents.push(event);
-        }
-      },
-      onStateUpdated: () => {},
-      onTreeChanged: () => {},
-    });
-
-    try {
-      await orchestrator.run();
-    } catch {
-      // Expected
-    }
-
-    // If there was an error, it should have state
-    if (errorEvents.length > 0) {
-      const errEvent = errorEvents[0];
-      if (errEvent.type === 'error') {
-        expect(errEvent.error.state).toBeDefined();
-        expect(errEvent.error.logs).toBeDefined();
-        expect(errEvent.error.workflowId).toBeDefined();
-      }
-    }
-  });
-
-  it('should propagate treeUpdated events to root observers', () => {
-    // ARRANGE: Create parent-child workflow tree
-    const parent = new TDDOrchestrator('Parent');
-    const child = new TDDOrchestrator('Child', parent);
-
-    // ARRANGE: Set up observer with collection arrays
-    const events: WorkflowEvent[] = [];
-    const treeChangedCalls: any[] = [];
-
-    // ARRANGE: Create inline observer
-    const observer: WorkflowObserver = {
-      onLog: () => {}, // Empty - not testing logs
-      onEvent: (event) => events.push(event), // Capture events
-      onStateUpdated: () => {}, // Empty - not testing state updates
-      onTreeChanged: (root) => treeChangedCalls.push(root), // Capture tree changes
-    };
-
-    // ARRANGE: Attach observer to ROOT (parent, not child)
-    parent.addObserver(observer);
-
-    // ACT: Trigger status change on CHILD workflow
-    child.setStatus('completed');
-
-    // ASSERT: Verify treeUpdated event was received via onEvent
-    const treeUpdatedEvent = events.find((e) => e.type === 'treeUpdated');
-    expect(treeUpdatedEvent).toBeDefined();
-
-    // ASSERT: Type guard for discriminated union + verify root node
-    if (treeUpdatedEvent && treeUpdatedEvent.type === 'treeUpdated') {
-      expect(treeUpdatedEvent.root).toBe(parent.getNode());
-    }
-
-    // ASSERT: Verify onTreeChanged callback was invoked
-    expect(treeChangedCalls).toHaveLength(1);
-    expect(treeChangedCalls[0]).toBe(parent.getNode());
-  });
-});

package/src/__tests__/integration/workflow-reparenting.test.ts

@@ -1,303 +0,0 @@
-/**
- * Integration Test: Reparenting Observer Propagation
- *
- * Validates that observer propagation correctly updates when a child
- * workflow is reparented from one parent to another.
- *
- * Pattern 7 (from bug_fix_tasks.json):
- * "Observer propagation should update after reparenting.
- *  Events from child should only reach new parent's observers."
- */
-
-import { describe, it, expect } from 'vitest';
-import {
-  Workflow,
-  WorkflowObserver,
-  WorkflowEvent,
-  WorkflowTreeDebugger,
-} from '../../index.js';
-
-/**
- * SimpleWorkflow class for testing
- * Pattern from: src/__tests__/unit/workflow.test.ts:4-11
- */
-class SimpleWorkflow extends Workflow {
-  async run(): Promise<string> {
-    this.setStatus('running');
-    this.setStatus('completed');
-    return 'done';
-  }
-}
-
-describe('Integration: Reparenting Observer Propagation', () => {
-  it('should update observer propagation after reparenting', () => {
-    // ============================================================
-    // PHASE 1: Setup - Create parent1, parent2, and child
-    // ============================================================
-    // ARRANGE: Create two root workflows (both have parent = null)
-    const parent1 = new SimpleWorkflow('Parent1');
-    const parent2 = new SimpleWorkflow('Parent2');
-
-    // ARRANGE: Create child attached to parent1 (via constructor)
-    const child = new SimpleWorkflow('Child', parent1);
-
-    // ASSERT: Verify initial state
-    expect(child.parent).toBe(parent1);
-    expect(parent1.children).toContain(child);
-    expect(parent2.children).not.toContain(child);
-
-    // ============================================================
-    // PHASE 2: Verify parent1 observer receives events
-    // ============================================================
-    // ARRANGE: Create observer for parent1
-    const parent1Events: WorkflowEvent[] = [];
-
-    const parent1Observer: WorkflowObserver = {
-      onLog: () => {}, // Empty - not testing logs
-      onEvent: (event) => parent1Events.push(event), // Capture events
-      onStateUpdated: () => {}, // Empty - not testing state updates
-      onTreeChanged: () => {}, // Empty - not testing tree changes
-    };
-
-    // ACT: Attach observer to parent1 (must be root workflow)
-    parent1.addObserver(parent1Observer);
-
-    // ACT: Child emits event (triggers treeUpdated via setStatus)
-    // PATTERN: setStatus() emits treeUpdated event
-    parent1Events.length = 0; // Clear any construction events
-    child.setStatus('running');
-
-    // ASSERT: Verify parent1 observer received the event
-    const parent1ReceivedEvent = parent1Events.find(
-      (e) => e.type === 'treeUpdated'
-    );
-    expect(parent1ReceivedEvent).toBeDefined();
-
-    // ============================================================
-    // PHASE 3: Reparent child from parent1 to parent2
-    // ============================================================
-    // ARRANGE: Create observer for parent2
-    const parent2Events: WorkflowEvent[] = [];
-
-    const parent2Observer: WorkflowObserver = {
-      onLog: () => {},
-      onEvent: (event) => parent2Events.push(event),
-      onStateUpdated: () => {},
-      onTreeChanged: () => {},
-    };
-
-    // ACT: Reparent using detach + attach pattern
-    // CRITICAL: Must detach before attaching to new parent
-    parent1.detachChild(child);
-    parent2.attachChild(child);
-    parent2.addObserver(parent2Observer);
-
-    // ASSERT: Verify reparenting succeeded
-    expect(child.parent).toBe(parent2);
-    expect(parent2.children).toContain(child);
-    expect(parent1.children).not.toContain(child);
-
-    // ============================================================
-    // PHASE 4: Verify parent2 observer receives events after reparenting
-    // ============================================================
-    // ACT: Clear events to isolate post-reparenting behavior
-    parent1Events.length = 0;
-    parent2Events.length = 0;
-
-    // ACT: Child emits event again
-    child.setStatus('completed');
-
-    // ASSERT: Verify parent2 observer received the event
-    const parent2ReceivedEvent = parent2Events.find(
-      (e) => e.type === 'treeUpdated'
-    );
-    expect(parent2ReceivedEvent).toBeDefined();
-
-    // ============================================================
-    // PHASE 5: CRITICAL VALIDATION - parent1 observer does NOT receive events
-    // ============================================================
-    // ASSERT: Verify parent1 observer did NOT receive the post-reparenting event
-    const parent1DidNotReceive = parent1Events.find(
-      (e) => e.type === 'treeUpdated'
-    );
-    expect(parent1DidNotReceive).toBeUndefined();
-
-    // ASSERT: Verify event count for parent1 is zero
-    expect(parent1Events.length).toBe(0);
-  });
-
-  it('should handle multiple reparenting cycles correctly', () => {
-    // ARRANGE: Create three potential parents
-    const parentA = new SimpleWorkflow('ParentA');
-    const parentB = new SimpleWorkflow('ParentB');
-    const parentC = new SimpleWorkflow('ParentC');
-
-    // ARRANGE: Create child and observers for each parent
-    const child = new SimpleWorkflow('Child', parentA);
-
-    const eventsA: WorkflowEvent[] = [];
-    const eventsB: WorkflowEvent[] = [];
-    const eventsC: WorkflowEvent[] = [];
-
-    const createObserver = (eventsArray: WorkflowEvent[]): WorkflowObserver => ({
-      onLog: () => {},
-      onEvent: (e) => eventsArray.push(e),
-      onStateUpdated: () => {},
-      onTreeChanged: () => {},
-    });
-
-    parentA.addObserver(createObserver(eventsA));
-    parentB.addObserver(createObserver(eventsB));
-    parentC.addObserver(createObserver(eventsC));
-
-    // ACT & ASSERT: Cycle 1 - A -> B
-    eventsA.length = 0;
-    child.setStatus('running');
-    expect(eventsA.some((e) => e.type === 'treeUpdated')).toBe(true);
-
-    parentA.detachChild(child);
-    parentB.attachChild(child);
-
-    eventsA.length = 0;
-    eventsB.length = 0;
-    child.setStatus('completed');
-    expect(eventsB.some((e) => e.type === 'treeUpdated')).toBe(true);
-    expect(eventsA.some((e) => e.type === 'treeUpdated')).toBe(false);
-
-    // ACT & ASSERT: Cycle 2 - B -> C
-    parentB.detachChild(child);
-    parentC.attachChild(child);
-
-    eventsB.length = 0;
-    eventsC.length = 0;
-    child.setStatus('running');
-    expect(eventsC.some((e) => e.type === 'treeUpdated')).toBe(true);
-    expect(eventsB.some((e) => e.type === 'treeUpdated')).toBe(false);
-
-    // ACT & ASSERT: Cycle 3 - C -> A (return to original)
-    parentC.detachChild(child);
-    parentA.attachChild(child);
-
-    eventsC.length = 0;
-    eventsA.length = 0;
-    child.setStatus('completed');
-    expect(eventsA.some((e) => e.type === 'treeUpdated')).toBe(true);
-    expect(eventsC.some((e) => e.type === 'treeUpdated')).toBe(false);
-  });
-
-  it('should verify tree consistency after reparenting using debugger', () => {
-    // ============================================================
-    // PHASE 1: Setup - Create parent1, parent2, and child
-    // ============================================================
-    // ARRANGE: Create two root workflows
-    const parent1 = new SimpleWorkflow('Parent1');
-    const parent2 = new SimpleWorkflow('Parent2');
-
-    // ARRANGE: Create child attached to parent1 (via constructor)
-    const child = new SimpleWorkflow('Child', parent1);
-
-    // ARRANGE: Create debugger attached to parent1
-    const parent1Debugger = new WorkflowTreeDebugger(parent1);
-
-    // ASSERT: Verify initial tree structure
-    expect(child.parent).toBe(parent1);
-    expect(parent1.children).toContain(child);
-    expect(parent2.children).not.toContain(child);
-
-    // ASSERT: Verify debugger sees initial structure
-    const initialTree = parent1Debugger.getTree();
-    expect(initialTree.name).toBe('Parent1');
-    expect(initialTree.children.length).toBe(1);
-    expect(initialTree.children[0].name).toBe('Child');
-
-    // ============================================================
-    // PHASE 2: Reparenting operation
-    // ============================================================
-    // ACT: Reparent child from parent1 to parent2
-    parent1.detachChild(child);
-    parent2.attachChild(child);
-
-    // ASSERT: Verify basic reparenting succeeded
-    expect(child.parent).toBe(parent2);
-    expect(parent2.children).toContain(child);
-    expect(parent1.children).not.toContain(child);
-
-    // ============================================================
-    // PHASE 3: Verify workflow tree structure
-    // ============================================================
-    // ASSERT: Verify child.parent points to new parent
-    expect(child.parent).toBe(parent2);
-
-    // ASSERT: Verify new parent.children includes child
-    expect(parent2.children).toContain(child);
-
-    // ASSERT: Verify old parent.children does NOT include child
-    expect(parent1.children).not.toContain(child);
-
-    // ============================================================
-    // PHASE 4: Verify node tree structure using debugger
-    // ============================================================
-    // NOTE: parent1Debugger is still attached to parent1, so it shows parent1's tree
-    // Create debugger for parent2 to see the new tree structure
-    const parent2Debugger = new WorkflowTreeDebugger(parent2);
-
-    // ASSERT: Verify debugger can find child node
-    const childNode = parent2Debugger.getNode(child.id);
-    expect(childNode).toBeDefined();
-    expect(childNode?.name).toBe('Child');
-
-    // ASSERT: Verify child's node parent is parent2's node (node tree mirrors workflow tree)
-    const parent2NodeDirect = parent2.getNode();
-    expect(childNode?.parent).toBe(parent2NodeDirect);
-
-    // ASSERT: Verify parent2's node children includes child's node
-    const parent2Node = parent2Debugger.getNode(parent2.id);
-    const childNodeDirect = child.getNode();
-    expect(parent2Node?.children).toContain(childNodeDirect);
-
-    // ASSERT: Verify parent1's node children does NOT include child's node
-    const parent1Node = parent1Debugger.getNode(parent1.id);
-    expect(parent1Node?.children).not.toContain(childNodeDirect);
-
-    // ============================================================
-    // PHASE 5: Visual validation using toTreeString()
-    // ============================================================
-    // ACT: Get tree string for visual debugging
-    const parent2TreeString = parent2Debugger.toTreeString();
-
-    // ASSERT: Verify tree structure in ASCII representation
-    expect(parent2TreeString).toContain('Parent2');
-    expect(parent2TreeString).toContain('Child');
-    expect(parent2TreeString).toContain('└──'); // Tree connector symbol
-
-    // ============================================================
-    // PHASE 6: Statistical validation
-    // ============================================================
-    const parent2Stats = parent2Debugger.getStats();
-    expect(parent2Stats.totalNodes).toBe(2); // parent2 + child = 2
-
-    // ============================================================
-    // CRITICAL VALIDATION: 1:1 Tree Mirror Invariant
-    // ============================================================
-    // Verify workflow tree and node tree are perfectly synchronized
-    // This is the core invariant that must be maintained
-
-    // Workflow tree state:
-    expect(child.parent).toBe(parent2);
-    expect(parent2.children).toEqual([child]);
-    expect(parent1.children).toEqual([]);
-
-    // Node tree state (via getNode() method):
-    const childNodeFinal = child.getNode();
-    const parent2NodeFinal = parent2.getNode();
-    const parent1NodeFinal = parent1.getNode();
-
-    expect(childNodeFinal.parent).toBe(parent2NodeFinal);
-    expect(parent2NodeFinal.children).toEqual([childNodeFinal]);
-    expect(parent1NodeFinal.children).toEqual([]);
-
-    // Cross-verification: debugger lookup matches direct access
-    expect(parent2Debugger.getNode(child.id)).toBe(childNodeFinal);
-    expect(parent2Debugger.getNode(parent2.id)).toBe(parent2NodeFinal);
-  });
-});

package/src/__tests__/unit/agent.test.ts

@@ -1,169 +0,0 @@
-import { describe, it, expect, vi } from 'vitest';
-import { Agent } from '../../core/agent.js';
-import { MCPHandler } from '../../core/mcp-handler.js';
-
-describe('Agent', () => {
-  it('should create with unique id', () => {
-    const a1 = new Agent();
-    const a2 = new Agent();
-    expect(a1.id).not.toBe(a2.id);
-  });
-
-  it('should use default name when not provided', () => {
-    const agent = new Agent();
-    expect(agent.name).toBe('Agent');
-  });
-
-  it('should use custom name when provided', () => {
-    const agent = new Agent({ name: 'CustomAgent' });
-    expect(agent.name).toBe('CustomAgent');
-  });
-
-  it('should provide access to MCP handler', () => {
-    const agent = new Agent();
-    const handler = agent.getMcpHandler();
-    expect(handler).toBeInstanceOf(MCPHandler);
-  });
-
-  it('should register MCP servers from config', () => {
-    const agent = new Agent({
-      mcps: [
-        {
-          name: 'test-mcp',
-          transport: 'inprocess',
-          tools: [
-            {
-              name: 'test_tool',
-              description: 'A test tool',
-              input_schema: { type: 'object', properties: {} },
-            },
-          ],
-        },
-      ],
-    });
-
-    const handler = agent.getMcpHandler();
-    expect(handler.getServerNames()).toContain('test-mcp');
-    expect(handler.hasTool('test-mcp__test_tool')).toBe(true);
-  });
-});
-
-describe('MCPHandler', () => {
-  it('should register and unregister servers', () => {
-    const handler = new MCPHandler();
-
-    handler.registerServer({
-      name: 'server1',
-      transport: 'inprocess',
-    });
-
-    expect(handler.getServerNames()).toContain('server1');
-
-    handler.unregisterServer('server1');
-    expect(handler.getServerNames()).not.toContain('server1');
-  });
-
-  it('should throw when registering duplicate server', () => {
-    const handler = new MCPHandler();
-
-    handler.registerServer({
-      name: 'server1',
-      transport: 'inprocess',
-    });
-
-    expect(() =>
-      handler.registerServer({
-        name: 'server1',
-        transport: 'inprocess',
-      })
-    ).toThrow("MCP server 'server1' is already registered");
-  });
-
-  it('should convert tools to full names', () => {
-    const handler = new MCPHandler();
-
-    handler.registerServer({
-      name: 'myserver',
-      transport: 'inprocess',
-      tools: [
-        {
-          name: 'tool1',
-          description: 'Tool 1',
-          input_schema: { type: 'object', properties: {} },
-        },
-        {
-          name: 'tool2',
-          description: 'Tool 2',
-          input_schema: { type: 'object', properties: {} },
-        },
-      ],
-    });
-
-    const tools = handler.getTools();
-    expect(tools).toHaveLength(2);
-    expect(tools[0].name).toBe('myserver__tool1');
-    expect(tools[1].name).toBe('myserver__tool2');
-  });
-
-  it('should execute registered tool', async () => {
-    const handler = new MCPHandler();
-
-    handler.registerServer({
-      name: 'math',
-      transport: 'inprocess',
-      tools: [
-        {
-          name: 'add',
-          description: 'Add two numbers',
-          input_schema: {
-            type: 'object',
-            properties: {
-              a: { type: 'number' },
-              b: { type: 'number' },
-            },
-          },
-        },
-      ],
-    });
-
-    handler.registerToolExecutor('math', 'add', async (input: unknown) => {
-      const { a, b } = input as { a: number; b: number };
-      return a + b;
-    });
-
-    const result = await handler.executeTool('math__add', { a: 2, b: 3 });
-    expect(result.content).toBe('5');
-    expect(result.is_error).toBeUndefined();
-  });
-
-  it('should return error for unknown tool', async () => {
-    const handler = new MCPHandler();
-    const result = await handler.executeTool('unknown__tool', {});
-    expect(result.is_error).toBe(true);
-    expect(result.content).toContain('not found');
-  });
-
-  it('should return error when tool throws', async () => {
-    const handler = new MCPHandler();
-
-    handler.registerServer({
-      name: 'failing',
-      transport: 'inprocess',
-      tools: [
-        {
-          name: 'fail',
-          description: 'Always fails',
-          input_schema: { type: 'object', properties: {} },
-        },
-      ],
-    });
-
-    handler.registerToolExecutor('failing', 'fail', async () => {
-      throw new Error('Tool error');
-    });
-
-    const result = await handler.executeTool('failing__fail', {});
-    expect(result.is_error).toBe(true);
-    expect(result.content).toContain('Tool error');
-  });
-});