groundswell 0.0.2 → 0.0.3

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

@@ -1,321 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { Observable, ObservableLogger } from '../../utils/observable';
-
-describe('Observable', () => {
-  describe('with logger injection', () => {
-    let mockLogger: ObservableLogger;
-
-    beforeEach(() => {
-      mockLogger = {
-        error: vi.fn(),
-      };
-    });
-
-    it('should log subscriber next() errors via logger', () => {
-      const observable = new Observable<number>(mockLogger);
-      const testError = new Error('Next error');
-
-      const throwingSubscriber = {
-        next: () => {
-          throw testError;
-        },
-      };
-
-      observable.subscribe(throwingSubscriber);
-      observable.next(42);
-
-      expect(mockLogger.error).toHaveBeenCalledWith('Observable subscriber error', {
-        error: testError,
-      });
-    });
-
-    it('should log subscriber error() errors via logger', () => {
-      const observable = new Observable<number>(mockLogger);
-      const testError = new Error('Error handler failed');
-      const handlerError = new Error('Handler threw');
-
-      const throwingSubscriber = {
-        error: () => {
-          throw handlerError;
-        },
-      };
-
-      observable.subscribe(throwingSubscriber);
-      observable.error(testError);
-
-      expect(mockLogger.error).toHaveBeenCalledWith('Observable error handler failed', {
-        error: handlerError,
-      });
-    });
-
-    it('should log subscriber complete() errors via logger', () => {
-      const observable = new Observable<number>(mockLogger);
-      const completeError = new Error('Complete handler failed');
-
-      const throwingSubscriber = {
-        complete: () => {
-          throw completeError;
-        },
-      };
-
-      observable.subscribe(throwingSubscriber);
-      observable.complete();
-
-      expect(mockLogger.error).toHaveBeenCalledWith('Observable complete handler failed', {
-        error: completeError,
-      });
-    });
-
-    it('should continue notifying other subscribers after one throws', () => {
-      const observable = new Observable<number>(mockLogger);
-      const testError = new Error('First subscriber error');
-
-      const results: number[] = [];
-
-      const throwingSubscriber = {
-        next: () => {
-          throw testError;
-        },
-      };
-
-      const workingSubscriber = {
-        next: (value: number) => {
-          results.push(value);
-        },
-      };
-
-      observable.subscribe(throwingSubscriber);
-      observable.subscribe(workingSubscriber);
-      observable.next(42);
-
-      expect(results).toEqual([42]);
-      expect(mockLogger.error).toHaveBeenCalled();
-    });
-
-    it('should handle multiple throwing subscribers', () => {
-      const observable = new Observable<number>(mockLogger);
-      const error1 = new Error('Error 1');
-      const error2 = new Error('Error 2');
-
-      const throwingSubscriber1 = {
-        next: () => {
-          throw error1;
-        },
-      };
-
-      const throwingSubscriber2 = {
-        next: () => {
-          throw error2;
-        },
-      };
-
-      observable.subscribe(throwingSubscriber1);
-      observable.subscribe(throwingSubscriber2);
-      observable.next(42);
-
-      expect(mockLogger.error).toHaveBeenCalledTimes(2);
-      expect(mockLogger.error).toHaveBeenNthCalledWith(1, 'Observable subscriber error', {
-        error: error1,
-      });
-      expect(mockLogger.error).toHaveBeenNthCalledWith(2, 'Observable subscriber error', {
-        error: error2,
-      });
-    });
-  });
-
-  describe('without logger (fallback)', () => {
-    it('should fall back to console.error when no logger provided', () => {
-      const consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
-      const observable = new Observable<number>();
-      const testError = new Error('Next error');
-
-      const throwingSubscriber = {
-        next: () => {
-          throw testError;
-        },
-      };
-
-      observable.subscribe(throwingSubscriber);
-      observable.next(42);
-
-      expect(consoleErrorSpy).toHaveBeenCalledWith('Observable subscriber error', testError);
-      consoleErrorSpy.mockRestore();
-    });
-
-    it('should fall back to console.error for error() method', () => {
-      const consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
-      const observable = new Observable<number>();
-      const handlerError = new Error('Handler threw');
-
-      const throwingSubscriber = {
-        error: () => {
-          throw handlerError;
-        },
-      };
-
-      observable.subscribe(throwingSubscriber);
-      observable.error(new Error('Original error'));
-
-      expect(consoleErrorSpy).toHaveBeenCalledWith('Observable error handler failed', handlerError);
-      consoleErrorSpy.mockRestore();
-    });
-
-    it('should fall back to console.error for complete() method', () => {
-      const consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
-      const observable = new Observable<number>();
-      const completeError = new Error('Complete threw');
-
-      const throwingSubscriber = {
-        complete: () => {
-          throw completeError;
-        },
-      };
-
-      observable.subscribe(throwingSubscriber);
-      observable.complete();
-
-      expect(consoleErrorSpy).toHaveBeenCalledWith('Observable complete handler failed', completeError);
-      consoleErrorSpy.mockRestore();
-    });
-  });
-
-  describe('backward compatibility', () => {
-    it('should work without any constructor arguments', () => {
-      const observable = new Observable<number>();
-      const results: number[] = [];
-
-      const subscriber = {
-        next: (value: number) => {
-          results.push(value);
-        },
-      };
-
-      observable.subscribe(subscriber);
-      observable.next(1);
-      observable.next(2);
-      observable.next(3);
-
-      expect(results).toEqual([1, 2, 3]);
-    });
-
-    it('should support subscribe/unsubscribe cycle', () => {
-      const observable = new Observable<number>();
-      const results: number[] = [];
-
-      const subscriber = {
-        next: (value: number) => {
-          results.push(value);
-        },
-      };
-
-      const subscription = observable.subscribe(subscriber);
-      observable.next(1);
-      subscription.unsubscribe();
-      observable.next(2);
-
-      expect(results).toEqual([1]);
-    });
-
-    it('should report subscriber count correctly', () => {
-      const observable = new Observable<number>();
-
-      const subscriber1 = { next: () => {} };
-      const subscriber2 = { next: () => {} };
-
-      expect(observable.subscriberCount).toBe(0);
-
-      const sub1 = observable.subscribe(subscriber1);
-      expect(observable.subscriberCount).toBe(1);
-
-      const sub2 = observable.subscribe(subscriber2);
-      expect(observable.subscriberCount).toBe(2);
-
-      sub1.unsubscribe();
-      expect(observable.subscriberCount).toBe(1);
-
-      sub2.unsubscribe();
-      expect(observable.subscriberCount).toBe(0);
-    });
-
-    it('should clear subscribers on complete', () => {
-      const observable = new Observable<number>();
-      const subscriber = { next: () => {}, complete: () => {} };
-
-      observable.subscribe(subscriber);
-      expect(observable.subscriberCount).toBe(1);
-
-      observable.complete();
-      expect(observable.subscriberCount).toBe(0);
-    });
-  });
-
-  describe('error isolation', () => {
-    let mockLogger: ObservableLogger;
-
-    beforeEach(() => {
-      mockLogger = {
-        error: vi.fn(),
-      };
-    });
-
-    it('should not propagate errors outside try-catch', () => {
-      const observable = new Observable<number>(mockLogger);
-      const testError = new Error('Subscriber error');
-
-      const throwingSubscriber = {
-        next: () => {
-          throw testError;
-        },
-      };
-
-      observable.subscribe(throwingSubscriber);
-
-      // This should not throw
-      expect(() => {
-        observable.next(42);
-      }).not.toThrow();
-
-      expect(mockLogger.error).toHaveBeenCalled();
-    });
-
-    it('should handle undefined optional callbacks', () => {
-      const consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
-      const observable = new Observable<number>();
-
-      const subscriberWithMissingCallbacks = {
-        // next is undefined
-        // error is undefined
-        // complete is undefined
-      };
-
-      observable.subscribe(subscriberWithMissingCallbacks);
-
-      // Should not throw when callbacks are undefined
-      expect(() => {
-        observable.next(42);
-        observable.error(new Error('test'));
-        observable.complete();
-      }).not.toThrow();
-
-      consoleErrorSpy.mockRestore();
-    });
-  });
-
-  describe('ObservableLogger interface', () => {
-    it('should match WorkflowLogger.error() signature', () => {
-      const mockLogger: ObservableLogger = {
-        error: vi.fn(),
-      };
-
-      const observable = new Observable<number>(mockLogger);
-
-      // Test the signature matches: error(message: string, data?: unknown): void
-      mockLogger.error('test message');
-      mockLogger.error('test message', { key: 'value' });
-      mockLogger.error('test message', { error: new Error('test') });
-      mockLogger.error('test message', undefined);
-
-      expect(mockLogger.error).toHaveBeenCalledTimes(4);
-    });
-  });
-});

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

@@ -1,135 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { z } from 'zod';
-import { Prompt } from '../../core/prompt.js';
-
-describe('Prompt', () => {
-  it('should create with unique id', () => {
-    const p1 = new Prompt({
-      user: 'Test',
-      responseFormat: z.object({ message: z.string() }),
-    });
-    const p2 = new Prompt({
-      user: 'Test',
-      responseFormat: z.object({ message: z.string() }),
-    });
-    expect(p1.id).not.toBe(p2.id);
-  });
-
-  it('should store user message and data', () => {
-    const prompt = new Prompt({
-      user: 'Hello world',
-      data: { key: 'value' },
-      responseFormat: z.object({ result: z.string() }),
-    });
-
-    expect(prompt.user).toBe('Hello world');
-    expect(prompt.data).toEqual({ key: 'value' });
-  });
-
-  it('should validate response successfully', () => {
-    const schema = z.object({
-      name: z.string(),
-      age: z.number(),
-    });
-
-    const prompt = new Prompt({
-      user: 'Get person',
-      responseFormat: schema,
-    });
-
-    const result = prompt.validateResponse({ name: 'John', age: 30 });
-    expect(result).toEqual({ name: 'John', age: 30 });
-  });
-
-  it('should throw on invalid response', () => {
-    const schema = z.object({
-      name: z.string(),
-      age: z.number(),
-    });
-
-    const prompt = new Prompt({
-      user: 'Get person',
-      responseFormat: schema,
-    });
-
-    expect(() => prompt.validateResponse({ name: 'John' })).toThrow();
-  });
-
-  it('should safely validate response', () => {
-    const schema = z.object({ value: z.number() });
-    const prompt = new Prompt({
-      user: 'Test',
-      responseFormat: schema,
-    });
-
-    const success = prompt.safeValidateResponse({ value: 42 });
-    expect(success.success).toBe(true);
-    if (success.success) {
-      expect(success.data).toEqual({ value: 42 });
-    }
-
-    const failure = prompt.safeValidateResponse({ value: 'not a number' });
-    expect(failure.success).toBe(false);
-  });
-
-  it('should build user message without data', () => {
-    const prompt = new Prompt({
-      user: 'Simple message',
-      responseFormat: z.string(),
-    });
-
-    expect(prompt.buildUserMessage()).toBe('Simple message');
-  });
-
-  it('should build user message with data', () => {
-    const prompt = new Prompt({
-      user: 'Message with data',
-      data: { items: ['a', 'b', 'c'] },
-      responseFormat: z.string(),
-    });
-
-    const message = prompt.buildUserMessage();
-    expect(message).toContain('Message with data');
-    expect(message).toContain('<items>');
-    expect(message).toContain('</items>');
-  });
-
-  it('should create new prompt with updated data', () => {
-    const original = new Prompt({
-      user: 'Test',
-      data: { a: 1 },
-      responseFormat: z.string(),
-    });
-
-    const updated = original.withData({ b: 2 });
-
-    expect(original.data).toEqual({ a: 1 });
-    expect(updated.data).toEqual({ a: 1, b: 2 });
-    expect(original.id).not.toBe(updated.id);
-  });
-
-  it('should store override fields', () => {
-    const prompt = new Prompt({
-      user: 'Test',
-      responseFormat: z.string(),
-      system: 'Custom system prompt',
-      tools: [{ name: 'test', description: 'Test tool', input_schema: { type: 'object', properties: {} } }],
-      enableReflection: true,
-    });
-
-    expect(prompt.systemOverride).toBe('Custom system prompt');
-    expect(prompt.toolsOverride).toHaveLength(1);
-    expect(prompt.enableReflection).toBe(true);
-  });
-
-  it('should be immutable', () => {
-    const prompt = new Prompt({
-      user: 'Test',
-      data: { key: 'value' },
-      responseFormat: z.string(),
-    });
-
-    expect(Object.isFrozen(prompt)).toBe(true);
-    expect(Object.isFrozen(prompt.data)).toBe(true);
-  });
-});

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

@@ -1,210 +0,0 @@
-/**
- * Unit tests for ReflectionManager
- */
-
-import { describe, it, expect, beforeEach } from 'vitest';
-import { ReflectionManager } from '../../reflection/reflection.js';
-import type { ReflectionContext, WorkflowNode } from '../../types/index.js';
-
-describe('ReflectionManager', () => {
-  const createTestNode = (): WorkflowNode => ({
-    id: 'test-node-1',
-    name: 'Test Node',
-    parent: null,
-    children: [],
-    status: 'failed',
-    logs: [],
-    events: [],
-    stateSnapshot: null,
-  });
-
-  const createContext = (
-    error: Error,
-    attemptNumber: number = 1
-  ): ReflectionContext => ({
-    level: 'workflow',
-    failedNode: createTestNode(),
-    error,
-    attemptNumber,
-    previousAttempts: [],
-  });
-
-  describe('isEnabled', () => {
-    it('should return true when enabled', () => {
-      const manager = new ReflectionManager({ enabled: true, maxAttempts: 3 });
-      expect(manager.isEnabled()).toBe(true);
-    });
-
-    it('should return false when disabled', () => {
-      const manager = new ReflectionManager({ enabled: false, maxAttempts: 3 });
-      expect(manager.isEnabled()).toBe(false);
-    });
-  });
-
-  describe('getMaxAttempts', () => {
-    it('should return configured maxAttempts', () => {
-      const manager = new ReflectionManager({ enabled: true, maxAttempts: 5 });
-      expect(manager.getMaxAttempts()).toBe(5);
-    });
-  });
-
-  describe('getRetryDelayMs', () => {
-    it('should return 0 when not configured', () => {
-      const manager = new ReflectionManager({ enabled: true, maxAttempts: 3 });
-      expect(manager.getRetryDelayMs()).toBe(0);
-    });
-
-    it('should return configured delay', () => {
-      const manager = new ReflectionManager({
-        enabled: true,
-        maxAttempts: 3,
-        retryDelayMs: 1000,
-      });
-      expect(manager.getRetryDelayMs()).toBe(1000);
-    });
-  });
-
-  describe('triggerReflection', () => {
-    it('should throw when reflection is disabled', async () => {
-      const manager = new ReflectionManager({ enabled: false, maxAttempts: 3 });
-
-      await expect(manager.triggerReflection()).rejects.toThrow(
-        'Reflection is not enabled'
-      );
-    });
-
-    it('should record reflection in history', async () => {
-      const manager = new ReflectionManager({ enabled: true, maxAttempts: 3 });
-
-      await manager.triggerReflection('test reason');
-
-      const history = manager.getReflectionHistory();
-      expect(history).toHaveLength(1);
-      expect(history[0].reason).toBe('test reason');
-    });
-  });
-
-  describe('getReflectionHistory', () => {
-    it('should return empty array initially', () => {
-      const manager = new ReflectionManager({ enabled: true, maxAttempts: 3 });
-      expect(manager.getReflectionHistory()).toEqual([]);
-    });
-
-    it('should return copy of history (not reference)', () => {
-      const manager = new ReflectionManager({ enabled: true, maxAttempts: 3 });
-      const history1 = manager.getReflectionHistory();
-      const history2 = manager.getReflectionHistory();
-
-      expect(history1).not.toBe(history2);
-    });
-  });
-
-  describe('reflect (heuristic mode)', () => {
-    it('should not retry rate limit errors', async () => {
-      const manager = new ReflectionManager({ enabled: true, maxAttempts: 3 });
-      const context = createContext(new Error('rate limit exceeded'));
-
-      const result = await manager.reflect(context);
-
-      expect(result.shouldRetry).toBe(false);
-      expect(result.reason).toContain('Non-retryable error');
-    });
-
-    it('should not retry authentication errors', async () => {
-      const manager = new ReflectionManager({ enabled: true, maxAttempts: 3 });
-      const context = createContext(new Error('authentication failed'));
-
-      const result = await manager.reflect(context);
-
-      expect(result.shouldRetry).toBe(false);
-    });
-
-    it('should retry validation errors', async () => {
-      const manager = new ReflectionManager({ enabled: true, maxAttempts: 3 });
-      const context = createContext(new Error('validation failed: missing field'));
-
-      const result = await manager.reflect(context);
-
-      expect(result.shouldRetry).toBe(true);
-      expect(result.reason).toContain('Validation/parsing error');
-    });
-
-    it('should retry JSON parse errors', async () => {
-      const manager = new ReflectionManager({ enabled: true, maxAttempts: 3 });
-      const context = createContext(new Error('JSON parse error at position 10'));
-
-      const result = await manager.reflect(context);
-
-      expect(result.shouldRetry).toBe(true);
-    });
-
-    it('should retry timeout errors (up to limit)', async () => {
-      const manager = new ReflectionManager({ enabled: true, maxAttempts: 3 });
-
-      const context1 = createContext(new Error('timeout'), 1);
-      const result1 = await manager.reflect(context1);
-      expect(result1.shouldRetry).toBe(true);
-
-      const context2 = createContext(new Error('timeout'), 2);
-      const result2 = await manager.reflect(context2);
-      expect(result2.shouldRetry).toBe(false);
-    });
-
-    it('should stop retrying after max attempts', async () => {
-      const manager = new ReflectionManager({ enabled: true, maxAttempts: 2 });
-      const context = createContext(new Error('generic error'), 2);
-
-      const result = await manager.reflect(context);
-
-      expect(result.shouldRetry).toBe(false);
-      expect(result.reason).toContain('Max attempts');
-    });
-
-    it('should record reflection in history', async () => {
-      const manager = new ReflectionManager({ enabled: true, maxAttempts: 3 });
-      const context = createContext(new Error('test error'));
-
-      await manager.reflect(context);
-
-      const history = manager.getReflectionHistory();
-      expect(history).toHaveLength(1);
-      expect(history[0].level).toBe('workflow');
-      expect(history[0].error.message).toBe('test error');
-    });
-  });
-
-  describe('markLastReflectionSuccessful', () => {
-    it('should mark last entry as successful', async () => {
-      const manager = new ReflectionManager({ enabled: true, maxAttempts: 3 });
-      const context = createContext(new Error('test error'));
-
-      await manager.reflect(context);
-      manager.markLastReflectionSuccessful();
-
-      const history = manager.getReflectionHistory();
-      expect(history[0].success).toBe(true);
-    });
-
-    it('should do nothing when history is empty', () => {
-      const manager = new ReflectionManager({ enabled: true, maxAttempts: 3 });
-
-      // Should not throw
-      expect(() => manager.markLastReflectionSuccessful()).not.toThrow();
-    });
-  });
-
-  describe('event emission', () => {
-    it('should emit reflectionStart and reflectionEnd events', async () => {
-      const events: { type: string }[] = [];
-      const manager = new ReflectionManager({ enabled: true, maxAttempts: 3 });
-      manager.setEventEmitter((event) => events.push(event));
-
-      const context = createContext(new Error('test error'));
-      await manager.reflect(context);
-
-      expect(events).toHaveLength(2);
-      expect(events[0].type).toBe('reflectionStart');
-      expect(events[1].type).toBe('reflectionEnd');
-    });
-  });
-});