@charming_groot/core 0.1.0

package/tests/event-bus.test.ts

@@ -0,0 +1,89 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { EventBus } from '../src/event-bus.js';
+
+describe('EventBus', () => {
+  let bus: EventBus;
+
+  beforeEach(() => {
+    bus = new EventBus();
+  });
+
+  it('should emit and receive events', () => {
+    const handler = vi.fn();
+    bus.on('agent:start', handler);
+    bus.emit('agent:start', { runId: 'run-1' });
+    expect(handler).toHaveBeenCalledWith({ runId: 'run-1' });
+  });
+
+  it('should support multiple listeners for same event', () => {
+    const handler1 = vi.fn();
+    const handler2 = vi.fn();
+    bus.on('agent:start', handler1);
+    bus.on('agent:start', handler2);
+    bus.emit('agent:start', { runId: 'run-1' });
+    expect(handler1).toHaveBeenCalledOnce();
+    expect(handler2).toHaveBeenCalledOnce();
+  });
+
+  it('should not fire handler after unsubscribe', () => {
+    const handler = vi.fn();
+    const unsub = bus.on('agent:start', handler);
+    unsub();
+    bus.emit('agent:start', { runId: 'run-1' });
+    expect(handler).not.toHaveBeenCalled();
+  });
+
+  it('should fire once listener only once', () => {
+    const handler = vi.fn();
+    bus.once('agent:start', handler);
+    bus.emit('agent:start', { runId: 'run-1' });
+    bus.emit('agent:start', { runId: 'run-2' });
+    expect(handler).toHaveBeenCalledOnce();
+    expect(handler).toHaveBeenCalledWith({ runId: 'run-1' });
+  });
+
+  it('should remove all listeners for an event', () => {
+    const handler1 = vi.fn();
+    const handler2 = vi.fn();
+    bus.on('agent:start', handler1);
+    bus.on('agent:end', handler2);
+    bus.removeAllListeners('agent:start');
+    bus.emit('agent:start', { runId: 'run-1' });
+    bus.emit('agent:end', { runId: 'run-1', reason: 'done' });
+    expect(handler1).not.toHaveBeenCalled();
+    expect(handler2).toHaveBeenCalledOnce();
+  });
+
+  it('should remove all listeners when no event specified', () => {
+    const handler1 = vi.fn();
+    const handler2 = vi.fn();
+    bus.on('agent:start', handler1);
+    bus.on('agent:end', handler2);
+    bus.removeAllListeners();
+    bus.emit('agent:start', { runId: 'run-1' });
+    bus.emit('agent:end', { runId: 'run-1', reason: 'done' });
+    expect(handler1).not.toHaveBeenCalled();
+    expect(handler2).not.toHaveBeenCalled();
+  });
+
+  it('should report listener count', () => {
+    expect(bus.listenerCount('agent:start')).toBe(0);
+    const unsub = bus.on('agent:start', vi.fn());
+    bus.on('agent:start', vi.fn());
+    expect(bus.listenerCount('agent:start')).toBe(2);
+    unsub();
+    expect(bus.listenerCount('agent:start')).toBe(1);
+  });
+
+  it('should not throw when emitting with no listeners', () => {
+    expect(() => bus.emit('agent:start', { runId: 'run-1' })).not.toThrow();
+  });
+
+  it('should handle once unsubscribe before emit', () => {
+    const handler = vi.fn();
+    const unsub = bus.once('agent:start', handler);
+    unsub();
+    bus.emit('agent:start', { runId: 'run-1' });
+    expect(handler).not.toHaveBeenCalled();
+  });
+});

package/tests/logger.test.ts

@@ -0,0 +1,34 @@
+import { describe, it, expect } from 'vitest';
+import { createLogger, createChildLogger, getRootLogger } from '../src/logger.js';
+
+describe('Logger', () => {
+  it('should create a named logger', () => {
+    const logger = createLogger('test-module');
+    expect(logger).toBeDefined();
+    expect(typeof logger.info).toBe('function');
+    expect(typeof logger.error).toBe('function');
+  });
+
+  it('should create a logger with custom level', () => {
+    const logger = createLogger('debug-module', 'debug');
+    expect(logger.level).toBe('debug');
+  });
+
+  it('should return root logger', () => {
+    const root = getRootLogger();
+    expect(root).toBeDefined();
+    expect(typeof root.info).toBe('function');
+  });
+
+  it('should return same root logger instance', () => {
+    const root1 = getRootLogger();
+    const root2 = getRootLogger();
+    expect(root1).toBe(root2);
+  });
+
+  it('should create a child logger', () => {
+    const child = createChildLogger('child-module');
+    expect(child).toBeDefined();
+    expect(typeof child.info).toBe('function');
+  });
+});

package/tests/registry.test.ts

@@ -0,0 +1,90 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { Registry } from '../src/registry.js';
+import { RegistryError } from '../src/errors/base-error.js';
+
+describe('Registry', () => {
+  let registry: Registry<string>;
+
+  beforeEach(() => {
+    registry = new Registry<string>('TestItem');
+  });
+
+  it('should register and retrieve an item', () => {
+    registry.register('foo', 'bar');
+    expect(registry.get('foo')).toBe('bar');
+  });
+
+  it('should throw on duplicate registration', () => {
+    registry.register('foo', 'bar');
+    expect(() => registry.register('foo', 'baz')).toThrow(RegistryError);
+    expect(() => registry.register('foo', 'baz')).toThrow(
+      "TestItem 'foo' is already registered"
+    );
+  });
+
+  it('should throw on get for unregistered item', () => {
+    expect(() => registry.get('missing')).toThrow(RegistryError);
+    expect(() => registry.get('missing')).toThrow(
+      "TestItem 'missing' is not registered"
+    );
+  });
+
+  it('should return undefined for tryGet on missing item', () => {
+    expect(registry.tryGet('missing')).toBeUndefined();
+  });
+
+  it('should report has correctly', () => {
+    registry.register('exists', 'value');
+    expect(registry.has('exists')).toBe(true);
+    expect(registry.has('nope')).toBe(false);
+  });
+
+  it('should return all items', () => {
+    registry.register('a', '1');
+    registry.register('b', '2');
+    const all = registry.getAll();
+    expect(all.size).toBe(2);
+    expect(all.get('a')).toBe('1');
+    expect(all.get('b')).toBe('2');
+  });
+
+  it('should return all names', () => {
+    registry.register('x', '1');
+    registry.register('y', '2');
+    expect(registry.getAllNames()).toEqual(['x', 'y']);
+  });
+
+  it('should unregister an item', () => {
+    registry.register('item', 'val');
+    expect(registry.unregister('item')).toBe(true);
+    expect(registry.has('item')).toBe(false);
+  });
+
+  it('should throw when unregistering non-existent item', () => {
+    expect(() => registry.unregister('ghost')).toThrow(RegistryError);
+  });
+
+  it('should clear all items', () => {
+    registry.register('a', '1');
+    registry.register('b', '2');
+    registry.clear();
+    expect(registry.size).toBe(0);
+  });
+
+  it('should track size correctly', () => {
+    expect(registry.size).toBe(0);
+    registry.register('a', '1');
+    expect(registry.size).toBe(1);
+    registry.register('b', '2');
+    expect(registry.size).toBe(2);
+    registry.unregister('a');
+    expect(registry.size).toBe(1);
+  });
+
+  it('should work with complex types', () => {
+    const objRegistry = new Registry<{ id: number; name: string }>('Object');
+    const item = { id: 1, name: 'test' };
+    objRegistry.register('obj', item);
+    expect(objRegistry.get('obj')).toBe(item);
+  });
+});

package/tests/run-context.test.ts

@@ -0,0 +1,80 @@
+import { describe, it, expect } from 'vitest';
+import { RunContext } from '../src/run-context.js';
+import { EventBus } from '../src/event-bus.js';
+import type { AgentConfig } from '../src/config.js';
+
+const TEST_CONFIG: AgentConfig = {
+  provider: {
+    providerId: 'test',
+    model: 'test-model',
+    auth: { type: 'api-key' as const, apiKey: 'test-key' },
+    maxTokens: 4096,
+    temperature: 0.7,
+  },
+  maxIterations: 50,
+  workingDirectory: '/tmp/test',
+};
+
+describe('RunContext', () => {
+  it('should generate a unique runId', () => {
+    const ctx1 = new RunContext(TEST_CONFIG);
+    const ctx2 = new RunContext(TEST_CONFIG);
+    expect(ctx1.runId).toBeTruthy();
+    expect(ctx2.runId).toBeTruthy();
+    expect(ctx1.runId).not.toBe(ctx2.runId);
+  });
+
+  it('should use provided EventBus', () => {
+    const bus = new EventBus();
+    const ctx = new RunContext(TEST_CONFIG, bus);
+    expect(ctx.eventBus).toBe(bus);
+  });
+
+  it('should create a default EventBus if none provided', () => {
+    const ctx = new RunContext(TEST_CONFIG);
+    expect(ctx.eventBus).toBeInstanceOf(EventBus);
+  });
+
+  it('should expose config and workingDirectory', () => {
+    const ctx = new RunContext(TEST_CONFIG);
+    expect(ctx.config).toBe(TEST_CONFIG);
+    expect(ctx.workingDirectory).toBe('/tmp/test');
+  });
+
+  it('should set and get metadata', () => {
+    const ctx = new RunContext(TEST_CONFIG);
+    ctx.setMetadata('key', 'value');
+    expect(ctx.getMetadata('key')).toBe('value');
+  });
+
+  it('should return undefined for missing metadata', () => {
+    const ctx = new RunContext(TEST_CONFIG);
+    expect(ctx.getMetadata('missing')).toBeUndefined();
+  });
+
+  it('should return all metadata', () => {
+    const ctx = new RunContext(TEST_CONFIG);
+    ctx.setMetadata('a', 1);
+    ctx.setMetadata('b', 'two');
+    const all = ctx.getAllMetadata();
+    expect(all.size).toBe(2);
+    expect(all.get('a')).toBe(1);
+    expect(all.get('b')).toBe('two');
+  });
+
+  it('should support abort', () => {
+    const ctx = new RunContext(TEST_CONFIG);
+    expect(ctx.isAborted).toBe(false);
+    ctx.abort('user cancelled');
+    expect(ctx.isAborted).toBe(true);
+    expect(ctx.signal.aborted).toBe(true);
+  });
+
+  it('should have a createdAt timestamp', () => {
+    const before = new Date();
+    const ctx = new RunContext(TEST_CONFIG);
+    const after = new Date();
+    expect(ctx.createdAt.getTime()).toBeGreaterThanOrEqual(before.getTime());
+    expect(ctx.createdAt.getTime()).toBeLessThanOrEqual(after.getTime());
+  });
+});

package/tsconfig.json

@@ -0,0 +1,9 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": "./src"
+  },
+  "include": ["src/**/*.ts"],
+  "exclude": ["node_modules", "dist", "tests"]
+}

package/vitest.config.ts

@@ -0,0 +1,9 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    globals: true,
+    environment: 'node',
+    include: ['tests/**/*.test.ts'],
+  },
+});