groundswell 0.0.2 → 1.0.0

package/src/__tests__/unit/introspection-tools.test.ts

@@ -1,277 +0,0 @@
-/**
- * Unit tests for introspection tools
- */
-
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import {
-  INTROSPECTION_TOOLS,
-  handleInspectCurrentNode,
-  handleReadAncestorChain,
-  handleListSiblingsChildren,
-  handleInspectPriorOutputs,
-  handleInspectCacheStatus,
-  handleRequestSpawnWorkflow,
-  executeIntrospectionTool,
-} from '../../tools/introspection.js';
-import { runInContext, type AgentExecutionContext } from '../../core/context.js';
-import type { WorkflowNode } from '../../types/index.js';
-import { defaultCache } from '../../cache/cache.js';
-
-describe('Introspection Tools', () => {
-  describe('INTROSPECTION_TOOLS', () => {
-    it('should export 6 tools', () => {
-      expect(INTROSPECTION_TOOLS).toHaveLength(6);
-    });
-
-    it('should have valid tool definitions', () => {
-      for (const tool of INTROSPECTION_TOOLS) {
-        expect(tool.name).toBeDefined();
-        expect(tool.description).toBeDefined();
-        expect(tool.input_schema).toBeDefined();
-        expect(tool.input_schema.type).toBe('object');
-      }
-    });
-
-    it('should include all expected tool names', () => {
-      const names = INTROSPECTION_TOOLS.map((t) => t.name);
-      expect(names).toContain('inspect_current_node');
-      expect(names).toContain('read_ancestor_chain');
-      expect(names).toContain('list_siblings_children');
-      expect(names).toContain('inspect_prior_outputs');
-      expect(names).toContain('inspect_cache_status');
-      expect(names).toContain('request_spawn_workflow');
-    });
-  });
-
-  describe('handlers', () => {
-    const createTestNode = (
-      id: string,
-      name: string,
-      parent: WorkflowNode | null = null
-    ): WorkflowNode => ({
-      id,
-      name,
-      parent,
-      children: [],
-      status: 'running',
-      logs: [],
-      events: [],
-      stateSnapshot: null,
-    });
-
-    const createContext = (node: WorkflowNode): AgentExecutionContext => ({
-      workflowNode: node,
-      emitEvent: () => {},
-      workflowId: 'test-workflow',
-    });
-
-    describe('handleInspectCurrentNode', () => {
-      it('should throw when not in workflow context', async () => {
-        await expect(handleInspectCurrentNode()).rejects.toThrow(
-          'Not in workflow context'
-        );
-      });
-
-      it('should return current node info', async () => {
-        const parent = createTestNode('parent-1', 'Parent');
-        const node = createTestNode('child-1', 'Child', parent);
-        parent.children.push(node);
-
-        const result = await runInContext(createContext(node), () =>
-          handleInspectCurrentNode()
-        );
-
-        expect(result.id).toBe('child-1');
-        expect(result.name).toBe('Child');
-        expect(result.status).toBe('running');
-        expect(result.parentId).toBe('parent-1');
-        expect(result.parentName).toBe('Parent');
-        expect(result.depth).toBe(1);
-      });
-
-      it('should handle root node (no parent)', async () => {
-        const node = createTestNode('root-1', 'Root');
-
-        const result = await runInContext(createContext(node), () =>
-          handleInspectCurrentNode()
-        );
-
-        expect(result.parentId).toBeUndefined();
-        expect(result.depth).toBe(0);
-      });
-    });
-
-    describe('handleReadAncestorChain', () => {
-      it('should throw when not in workflow context', async () => {
-        await expect(handleReadAncestorChain({})).rejects.toThrow(
-          'Not in workflow context'
-        );
-      });
-
-      it('should return ancestor chain', async () => {
-        const root = createTestNode('root-1', 'Root');
-        const parent = createTestNode('parent-1', 'Parent', root);
-        root.children.push(parent);
-        const child = createTestNode('child-1', 'Child', parent);
-        parent.children.push(child);
-
-        const result = await runInContext(createContext(child), () =>
-          handleReadAncestorChain({})
-        );
-
-        expect(result.ancestors).toHaveLength(2);
-        expect(result.ancestors[0].id).toBe('parent-1');
-        expect(result.ancestors[1].id).toBe('root-1');
-        expect(result.totalDepth).toBe(2);
-      });
-
-      it('should respect maxDepth limit', async () => {
-        const root = createTestNode('root-1', 'Root');
-        const parent = createTestNode('parent-1', 'Parent', root);
-        root.children.push(parent);
-        const child = createTestNode('child-1', 'Child', parent);
-        parent.children.push(child);
-
-        const result = await runInContext(createContext(child), () =>
-          handleReadAncestorChain({ maxDepth: 1 })
-        );
-
-        expect(result.ancestors).toHaveLength(1);
-        expect(result.ancestors[0].id).toBe('parent-1');
-      });
-    });
-
-    describe('handleListSiblingsChildren', () => {
-      it('should throw when not in workflow context', async () => {
-        await expect(
-          handleListSiblingsChildren({ type: 'children' })
-        ).rejects.toThrow('Not in workflow context');
-      });
-
-      it('should return children', async () => {
-        const parent = createTestNode('parent-1', 'Parent');
-        const child1 = createTestNode('child-1', 'Child 1', parent);
-        const child2 = createTestNode('child-2', 'Child 2', parent);
-        parent.children.push(child1, child2);
-
-        const result = await runInContext(createContext(parent), () =>
-          handleListSiblingsChildren({ type: 'children' })
-        );
-
-        expect(result.type).toBe('children');
-        expect(result.nodes).toHaveLength(2);
-      });
-
-      it('should return siblings (excluding self)', async () => {
-        const parent = createTestNode('parent-1', 'Parent');
-        const child1 = createTestNode('child-1', 'Child 1', parent);
-        const child2 = createTestNode('child-2', 'Child 2', parent);
-        parent.children.push(child1, child2);
-
-        const result = await runInContext(createContext(child1), () =>
-          handleListSiblingsChildren({ type: 'siblings' })
-        );
-
-        expect(result.type).toBe('siblings');
-        expect(result.nodes).toHaveLength(1);
-        expect(result.nodes[0].id).toBe('child-2');
-      });
-    });
-
-    describe('handleInspectPriorOutputs', () => {
-      it('should throw when not in workflow context', async () => {
-        await expect(handleInspectPriorOutputs({})).rejects.toThrow(
-          'Not in workflow context'
-        );
-      });
-
-      it('should return completed sibling outputs', async () => {
-        const parent = createTestNode('parent-1', 'Parent');
-        const completed = createTestNode('completed-1', 'Completed', parent);
-        completed.status = 'completed';
-        // Add a valid workflow event for testing
-        completed.events.push({
-          type: 'stepEnd',
-          node: completed,
-          step: 'test-step',
-          duration: 100,
-        } as never); // Cast to avoid strict type checking in tests
-        const current = createTestNode('current-1', 'Current', parent);
-        parent.children.push(completed, current);
-
-        const result = await runInContext(createContext(current), () =>
-          handleInspectPriorOutputs({})
-        );
-
-        expect(result).toHaveLength(1);
-        expect(result[0].nodeId).toBe('completed-1');
-        expect(result[0].status).toBe('completed');
-      });
-    });
-
-    describe('handleInspectCacheStatus', () => {
-      beforeEach(async () => {
-        await defaultCache.clear();
-      });
-
-      it('should return false for missing cache key', async () => {
-        const result = await handleInspectCacheStatus({
-          promptHash: 'nonexistent-key',
-        });
-
-        expect(result.exists).toBe(false);
-        expect(result.key).toBe('nonexistent-key');
-      });
-
-      it('should return true for existing cache key', async () => {
-        await defaultCache.set('test-key', { data: 'test' });
-
-        const result = await handleInspectCacheStatus({ promptHash: 'test-key' });
-
-        expect(result.exists).toBe(true);
-      });
-    });
-
-    describe('handleRequestSpawnWorkflow', () => {
-      it('should throw when not in workflow context', async () => {
-        await expect(
-          handleRequestSpawnWorkflow({ name: 'Test', description: 'Test workflow' })
-        ).rejects.toThrow('Not in workflow context');
-      });
-
-      it('should return spawn request', async () => {
-        const node = createTestNode('node-1', 'Node');
-
-        const result = await runInContext(createContext(node), () =>
-          handleRequestSpawnWorkflow({
-            name: 'NewWorkflow',
-            description: 'A new workflow',
-          })
-        );
-
-        expect(result.name).toBe('NewWorkflow');
-        expect(result.description).toBe('A new workflow');
-        expect(result.requestId).toMatch(/^spawn-/);
-        expect(result.status).toBe('pending');
-      });
-    });
-  });
-
-  describe('executeIntrospectionTool', () => {
-    it('should execute tool by name', async () => {
-      await defaultCache.set('cache-test', 'value');
-
-      const result = await executeIntrospectionTool('inspect_cache_status', {
-        promptHash: 'cache-test',
-      });
-
-      expect(result).toMatchObject({ exists: true, key: 'cache-test' });
-    });
-
-    it('should throw for unknown tool', async () => {
-      await expect(
-        executeIntrospectionTool('unknown_tool', {})
-      ).rejects.toThrow('Unknown introspection tool');
-    });
-  });
-});

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

@@ -1,293 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { Workflow } from '../../core/workflow';
-import type { LogEntry } from '../../types/logging';
-
-describe('WorkflowLogger.child()', () => {
-  describe('with Partial<LogEntry> containing parentLogId', () => {
-    it('should create child logger with parentLogId from Partial<LogEntry>', async () => {
-      class TestWorkflow extends Workflow {
-        async run() {
-          const childLogger = this.logger.child({ parentLogId: 'parent-123' });
-          childLogger.info('Child message');
-        }
-      }
-
-      const workflow = new TestWorkflow();
-      await workflow.run();
-
-      expect(workflow.node.logs.length).toBe(1);
-      expect(workflow.node.logs[0].parentLogId).toBe('parent-123');
-      expect(workflow.node.logs[0].message).toBe('Child message');
-    });
-
-    it('should handle parentLogId with special characters', async () => {
-      class TestWorkflow extends Workflow {
-        async run() {
-          const childLogger = this.logger.child({ parentLogId: 'parent-with-dashes-and_underscores' });
-          childLogger.info('Test');
-        }
-      }
-
-      const workflow = new TestWorkflow();
-      await workflow.run();
-
-      expect(workflow.node.logs[0].parentLogId).toBe('parent-with-dashes-and_underscores');
-    });
-  });
-
-  describe('with Partial<LogEntry> containing id field', () => {
-    it('should not use id field as parentLogId', async () => {
-      class TestWorkflow extends Workflow {
-        async run() {
-          // id field should NOT be used as parentLogId
-          const childLogger = this.logger.child({ id: 'custom-id' });
-          childLogger.info('Test message');
-        }
-      }
-
-      const workflow = new TestWorkflow();
-      await workflow.run();
-
-      // parentLogId is undefined because implementation only checks input.parentLogId
-      expect(workflow.node.logs[0].parentLogId).toBeUndefined();
-      expect(workflow.node.logs[0].message).toBe('Test message');
-    });
-
-    it('should handle both id and parentLogId fields', async () => {
-      class TestWorkflow extends Workflow {
-        async run() {
-          // parentLogId should be used, not id
-          const childLogger = this.logger.child({ id: 'custom-id', parentLogId: 'correct-parent' });
-          childLogger.info('Test');
-        }
-      }
-
-      const workflow = new TestWorkflow();
-      await workflow.run();
-
-      expect(workflow.node.logs[0].parentLogId).toBe('correct-parent');
-    });
-  });
-
-  describe('with empty Partial<LogEntry>', () => {
-    it('should create child logger with undefined parentLogId from empty object', async () => {
-      class TestWorkflow extends Workflow {
-        async run() {
-          const childLogger = this.logger.child({});
-          childLogger.info('Child log with empty parent metadata');
-        }
-      }
-
-      const workflow = new TestWorkflow();
-      await workflow.run();
-
-      expect(workflow.node.logs.length).toBe(1);
-      expect(workflow.node.logs[0].parentLogId).toBeUndefined();
-      expect(workflow.node.logs[0].message).toBe('Child log with empty parent metadata');
-    });
-  });
-
-  describe('with string parameter (backward compatibility)', () => {
-    it('should create child logger with parentLogId from string', async () => {
-      class TestWorkflow extends Workflow {
-        async run() {
-          const childLogger = this.logger.child('parent-id-123');
-          childLogger.info('Child message');
-        }
-      }
-
-      const workflow = new TestWorkflow();
-      await workflow.run();
-
-      expect(workflow.node.logs.length).toBe(1);
-      expect(workflow.node.logs[0].parentLogId).toBe('parent-id-123');
-      expect(workflow.node.logs[0].message).toBe('Child message');
-    });
-
-    it('should create child logger with parentLogId from string containing parentLogId', async () => {
-      class TestWorkflow extends Workflow {
-        async run() {
-          // String value is used directly as parentLogId
-          const childLogger = this.logger.child('log-abc-123');
-          childLogger.warn('Warning message');
-        }
-      }
-
-      const workflow = new TestWorkflow();
-      await workflow.run();
-
-      expect(workflow.node.logs[0].parentLogId).toBe('log-abc-123');
-      expect(workflow.node.logs[0].level).toBe('warn');
-    });
-  });
-
-  describe('with empty string', () => {
-    it('should create child logger with undefined parentLogId from empty string', async () => {
-      class TestWorkflow extends Workflow {
-        async run() {
-          const childLogger = this.logger.child('');
-          childLogger.info('Child log with empty parent');
-        }
-      }
-
-      const workflow = new TestWorkflow();
-      await workflow.run();
-
-      expect(workflow.node.logs.length).toBe(1);
-      // Empty string is falsy, so parentLogId becomes undefined in log entry
-      expect(workflow.node.logs[0].parentLogId).toBeUndefined();
-    });
-  });
-
-  describe('child logger with different log levels', () => {
-    it.each([
-      { level: 'debug', method: 'debug' as const },
-      { level: 'info', method: 'info' as const },
-      { level: 'warn', method: 'warn' as const },
-      { level: 'error', method: 'error' as const },
-    ])('should log at $level level with child logger', async ({ level, method }) => {
-      class TestWorkflow extends Workflow {
-        async run() {
-          const childLogger = this.logger.child({ parentLogId: 'parent-123' });
-          childLogger[method](`Test ${level} message`);
-        }
-      }
-
-      const workflow = new TestWorkflow();
-      await workflow.run();
-
-      expect(workflow.node.logs[0].level).toBe(level);
-      expect(workflow.node.logs[0].parentLogId).toBe('parent-123');
-      expect(workflow.node.logs[0].message).toBe(`Test ${level} message`);
-    });
-
-    it('should support logging with data parameter at all levels', async () => {
-      class TestWorkflow extends Workflow {
-        async run() {
-          const childLogger = this.logger.child({ parentLogId: 'parent-data' });
-
-          childLogger.debug('Debug message', { debugData: true });
-          childLogger.info('Info message', { infoData: 123 });
-          childLogger.warn('Warn message', { warnData: 'warning' });
-          childLogger.error('Error message', { errorData: { code: 500 } });
-        }
-      }
-
-      const workflow = new TestWorkflow();
-      await workflow.run();
-
-      expect(workflow.node.logs.length).toBe(4);
-      expect(workflow.node.logs[0].data).toEqual({ debugData: true });
-      expect(workflow.node.logs[1].data).toEqual({ infoData: 123 });
-      expect(workflow.node.logs[2].data).toEqual({ warnData: 'warning' });
-      expect(workflow.node.logs[3].data).toEqual({ errorData: { code: 500 } });
-    });
-  });
-
-  describe('parent-child log hierarchy', () => {
-    it('should maintain parent-child relationship in log entries', async () => {
-      class TestWorkflow extends Workflow {
-        async run() {
-          // Log from parent logger
-          this.logger.info('Parent message');
-
-          // Get the parent log entry ID
-          const parentLogId = this.node.logs[0].id;
-
-          // Create child logger with that ID
-          const childLogger = this.logger.child({ parentLogId });
-          childLogger.info('Child message');
-        }
-      }
-
-      const workflow = new TestWorkflow();
-      await workflow.run();
-
-      // Verify hierarchy
-      expect(workflow.node.logs.length).toBe(2);
-      expect(workflow.node.logs[0].parentLogId).toBeUndefined(); // Root log
-      expect(workflow.node.logs[1].parentLogId).toBe(workflow.node.logs[0].id); // Child log
-      expect(workflow.node.logs[0].message).toBe('Parent message');
-      expect(workflow.node.logs[1].message).toBe('Child message');
-    });
-
-    it('should support multi-level nesting with child loggers', async () => {
-      class TestWorkflow extends Workflow {
-        async run() {
-          // Root log
-          this.logger.info('Root message');
-          const rootLogId = this.node.logs[0].id;
-
-          // First level child
-          const child1 = this.logger.child({ parentLogId: rootLogId });
-          child1.info('Level 1 child');
-          const level1LogId = this.node.logs[1].id;
-
-          // Second level child
-          const child2 = this.logger.child({ parentLogId: level1LogId });
-          child2.info('Level 2 child');
-        }
-      }
-
-      const workflow = new TestWorkflow();
-      await workflow.run();
-
-      expect(workflow.node.logs.length).toBe(3);
-      expect(workflow.node.logs[0].parentLogId).toBeUndefined();
-      expect(workflow.node.logs[1].parentLogId).toBe(workflow.node.logs[0].id);
-      expect(workflow.node.logs[2].parentLogId).toBe(workflow.node.logs[1].id);
-    });
-
-    it('should support string-based parent-child hierarchy', async () => {
-      class TestWorkflow extends Workflow {
-        async run() {
-          // Log from parent
-          this.logger.info('Parent log');
-          const parentLogId = this.node.logs[0].id;
-
-          // Create child using string parentLogId (backward compatibility)
-          const childLogger = this.logger.child(parentLogId);
-          childLogger.info('Child log');
-        }
-      }
-
-      const workflow = new TestWorkflow();
-      await workflow.run();
-
-      expect(workflow.node.logs.length).toBe(2);
-      expect(workflow.node.logs[0].parentLogId).toBeUndefined();
-      expect(workflow.node.logs[1].parentLogId).toBe(workflow.node.logs[0].id);
-    });
-
-    it('should allow multiple child loggers from same parent', async () => {
-      class TestWorkflow extends Workflow {
-        async run() {
-          // Parent log
-          this.logger.info('Parent');
-          const parentLogId = this.node.logs[0].id;
-
-          // Multiple children from same parent
-          const child1 = this.logger.child({ parentLogId });
-          child1.info('First child');
-
-          const child2 = this.logger.child({ parentLogId });
-          child2.info('Second child');
-
-          const child3 = this.logger.child({ parentLogId });
-          child3.info('Third child');
-        }
-      }
-
-      const workflow = new TestWorkflow();
-      await workflow.run();
-
-      expect(workflow.node.logs.length).toBe(4);
-      expect(workflow.node.logs[0].parentLogId).toBeUndefined();
-
-      // All children should have the same parent
-      expect(workflow.node.logs[1].parentLogId).toBe(workflow.node.logs[0].id);
-      expect(workflow.node.logs[2].parentLogId).toBe(workflow.node.logs[0].id);
-      expect(workflow.node.logs[3].parentLogId).toBe(workflow.node.logs[0].id);
-    });
-  });
-});