@flowcodex/core 0.3.0

package/tests/container.test.ts

@@ -0,0 +1,224 @@
+import { describe, it, expect } from 'vitest';
+import { Container, token } from '../src/kernel/container.js';
+
+describe('Container', () => {
+  describe('bind + resolve', () => {
+    it('binds and resolves a simple value', () => {
+      const c = new Container();
+      const T = token<string>('greeting');
+      c.bind(T, () => 'hello');
+      expect(c.resolve(T)).toBe('hello');
+    });
+
+    it('resolves dependencies from the container', () => {
+      const c = new Container();
+      const TUrl = token<string>('url');
+      const TClient = token<{ url: string }>('client');
+      c.bind(TUrl, () => 'https://api.example.com');
+      c.bind(TClient, (container) => ({ url: container.resolve(TUrl) }));
+      const client = c.resolve(TClient);
+      expect(client.url).toBe('https://api.example.com');
+    });
+
+    it('caches singletons by default', () => {
+      const c = new Container();
+      let calls = 0;
+      const T = token<number>('counter');
+      c.bind(T, () => ++calls);
+      c.resolve(T);
+      c.resolve(T);
+      expect(calls).toBe(1);
+    });
+
+    it('non-singleton calls factory each time', () => {
+      const c = new Container();
+      let calls = 0;
+      const T = token<number>('counter');
+      c.bind(T, () => ++calls, { singleton: false });
+      c.resolve(T);
+      c.resolve(T);
+      expect(calls).toBe(2);
+    });
+  });
+
+  describe('duplicate binding', () => {
+    it('throws on duplicate bind', () => {
+      const c = new Container();
+      const T = token<string>('x');
+      c.bind(T, () => 'a');
+      expect(() => c.bind(T, () => 'b')).toThrow(/already bound/);
+    });
+  });
+
+  describe('override', () => {
+    it('replaces an existing binding', () => {
+      const c = new Container();
+      const T = token<string>('x');
+      c.bind(T, () => 'old');
+      c.override(T, () => 'new');
+      expect(c.resolve(T)).toBe('new');
+    });
+
+    it('throws when overriding unbound token', () => {
+      const c = new Container();
+      const T = token<string>('x');
+      expect(() => c.override(T, () => 'x')).toThrow(/not bound/);
+    });
+
+    it('preserves singleton setting from existing', () => {
+      const c = new Container();
+      const T = token<number>('n');
+      c.bind(T, () => 1, { singleton: false });
+      c.override(T, () => 2);
+      const inspect = c.inspect(T);
+      expect(inspect?.singleton).toBe(false);
+    });
+  });
+
+  describe('decorate', () => {
+    it('stacks decorators on resolve', () => {
+      const c = new Container();
+      const T = token<number>('n');
+      c.bind(T, () => 1);
+      c.decorate(T, (v) => v + 10);
+      c.decorate(T, (v) => v + 100);
+      expect(c.resolve(T)).toBe(111);
+    });
+
+    it('clears cache on decorate', () => {
+      const c = new Container();
+      const T = token<number>('n');
+      c.bind(T, () => 1);
+      c.resolve(T);
+      expect(c.inspect(T)?.cached).toBe(true);
+      c.decorate(T, (v) => v + 1);
+      expect(c.inspect(T)?.cached).toBe(false);
+    });
+
+    it('throws when decorating unbound token', () => {
+      const c = new Container();
+      const T = token<string>('x');
+      expect(() => c.decorate(T, (v) => v)).toThrow(/not bound/);
+    });
+  });
+
+  describe('circular dependency', () => {
+    it('detects A → B → A', () => {
+      const c = new Container();
+      const TA = token<string>('A');
+      const TB = token<string>('B');
+      c.bind(TA, (container) => container.resolve(TB));
+      c.bind(TB, (container) => container.resolve(TA));
+      expect(() => c.resolve(TA)).toThrow(/circular dependency/);
+    });
+  });
+
+  describe('has + safeResolve', () => {
+    it('has returns true for bound tokens', () => {
+      const c = new Container();
+      const T = token<string>('x');
+      c.bind(T, () => 'val');
+      expect(c.has(T)).toBe(true);
+    });
+
+    it('has returns false for unbound tokens', () => {
+      const c = new Container();
+      const T = token<string>('x');
+      expect(c.has(T)).toBe(false);
+    });
+
+    it('safeResolve returns undefined for unbound', () => {
+      const c = new Container();
+      const T = token<string>('x');
+      expect(c.safeResolve(T)).toBeUndefined();
+    });
+
+    it('safeResolve returns value for bound', () => {
+      const c = new Container();
+      const T = token<string>('x');
+      c.bind(T, () => 'val');
+      expect(c.safeResolve(T)).toBe('val');
+    });
+  });
+
+  describe('unbind', () => {
+    it('removes a binding', () => {
+      const c = new Container();
+      const T = token<string>('x');
+      c.bind(T, () => 'val');
+      expect(c.unbind(T)).toBe(true);
+      expect(c.has(T)).toBe(false);
+    });
+
+    it('returns false for unbound token', () => {
+      const c = new Container();
+      const T = token<string>('x');
+      expect(c.unbind(T)).toBe(false);
+    });
+  });
+
+  describe('clear', () => {
+    it('removes all bindings', () => {
+      const c = new Container();
+      c.bind(token('a'), () => 1);
+      c.bind(token('b'), () => 2);
+      c.clear();
+      expect(c.list()).toHaveLength(0);
+    });
+  });
+
+  describe('list', () => {
+    it('lists all bindings with owners', () => {
+      const c = new Container();
+      const TA = token<string>('A');
+      const TB = token<string>('B');
+      c.bind(TA, () => 'a', { owner: 'plugin-x' });
+      c.bind(TB, () => 'b');
+      const items = c.list();
+      expect(items).toHaveLength(2);
+      const a = items.find((i) => i.token === TA);
+      expect(a?.owner).toBe('plugin-x');
+    });
+  });
+
+  describe('inspect', () => {
+    it('returns null for unbound token', () => {
+      const c = new Container();
+      expect(c.inspect(token('x'))).toBeNull();
+    });
+
+    it('returns binding metadata', () => {
+      const c = new Container();
+      const T = token<number>('n');
+      c.bind(T, () => 1);
+      c.decorate(T, (v) => v + 1);
+      const info = c.inspect(T);
+      expect(info?.owner).toBe('core+core');
+      expect(info?.singleton).toBe(true);
+      expect(info?.decoratorCount).toBe(1);
+      expect(info?.cached).toBe(false);
+    });
+
+    it('shows cached after resolve', () => {
+      const c = new Container();
+      const T = token<number>('n');
+      c.bind(T, () => 1);
+      c.resolve(T);
+      expect(c.inspect(T)?.cached).toBe(true);
+    });
+  });
+
+  describe('ownerOf', () => {
+    it('returns owner for bound token', () => {
+      const c = new Container();
+      const T = token<string>('x');
+      c.bind(T, () => 'v', { owner: 'plugin-y' });
+      expect(c.ownerOf(T)).toBe('plugin-y');
+    });
+
+    it('returns undefined for unbound', () => {
+      const c = new Container();
+      expect(c.ownerOf(token('x'))).toBeUndefined();
+    });
+  });
+});

package/tests/conversation-state.test.ts

@@ -0,0 +1,75 @@
+import { describe, it, expect, vi } from 'vitest';
+import { DefaultConversationState } from '../src/agent/conversation-state.js';
+import type { Message } from '../src/types/blocks.js';
+
+function msg(text: string): Message {
+  return { role: 'user', content: [{ type: 'text', text }] };
+}
+
+describe('DefaultConversationState', () => {
+  it('starts empty', () => {
+    const s = new DefaultConversationState();
+    expect(s.messages).toHaveLength(0);
+  });
+
+  it('appendMessage adds and is visible via messages', () => {
+    const s = new DefaultConversationState();
+    s.appendMessage(msg('a'));
+    s.appendMessage(msg('b'));
+    expect(s.messages).toHaveLength(2);
+    expect(s.messages[1]!.content).toEqual([{ type: 'text', text: 'b' }]);
+  });
+
+  it('replaceMessages swaps the whole array', () => {
+    const s = new DefaultConversationState();
+    s.appendMessage(msg('old'));
+    s.replaceMessages([msg('new1'), msg('new2')]);
+    expect(s.messages).toHaveLength(2);
+    const first = s.messages[0]!;
+    expect((first.content as [{ type: 'text'; text: string }])[0]!.text).toBe('new1');
+  });
+
+  it('replaceMessages with empty clears', () => {
+    const s = new DefaultConversationState();
+    s.appendMessage(msg('x'));
+    s.replaceMessages([]);
+    expect(s.messages).toHaveLength(0);
+  });
+
+  it('onChange fires on append and replace', () => {
+    const s = new DefaultConversationState();
+    const fn = vi.fn();
+    s.onChange(fn);
+    s.appendMessage(msg('a'));
+    s.replaceMessages([msg('b')]);
+    expect(fn).toHaveBeenCalledTimes(2);
+  });
+
+  it('onChange unsubscribe stops further calls', () => {
+    const s = new DefaultConversationState();
+    const fn = vi.fn();
+    const unsub = s.onChange(fn);
+    s.appendMessage(msg('a'));
+    unsub();
+    s.appendMessage(msg('b'));
+    expect(fn).toHaveBeenCalledTimes(1);
+  });
+
+  it('a throwing listener does not block siblings', () => {
+    const s = new DefaultConversationState();
+    const ok = vi.fn();
+    s.onChange(() => {
+      throw new Error('boom');
+    });
+    s.onChange(ok);
+    s.appendMessage(msg('a'));
+    expect(ok).toHaveBeenCalledTimes(1);
+  });
+
+  it('push on the live array mutates state (AgentContext.messages contract)', () => {
+    const s = new DefaultConversationState();
+    const live = s.messages as Message[];
+    live.push(msg('direct'));
+    expect(s.messages).toHaveLength(1);
+  });
+});