@treenity/mods 3.0.1 → 3.0.2

package/doc/fs-codec.test.ts

@@ -1,119 +0,0 @@
-import type { Tree } from '@treenity/core/tree';
-import { createFsTree } from '@treenity/core/tree/fs';
-import assert from 'node:assert/strict';
-import { mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { afterEach, beforeEach, describe, it } from 'node:test';
-
-// Register the codec — side effect import
-import './fs-codec';
-
-describe('doc fs-codec', () => {
-  let dir: string;
-  let store: Tree;
-
-  beforeEach(async () => {
-    dir = await mkdtemp(join(tmpdir(), 'treenity-doc-codec-'));
-    store = await createFsTree(dir);
-  });
-
-  afterEach(async () => {
-    if (dir) await rm(dir, { recursive: true, force: true });
-  });
-
-  it('decode: .md file → doc.page node', async () => {
-    await writeFile(join(dir, 'readme.md'), '# Hello World\n\nSome content here.\n');
-
-    const node = await store.get('/readme');
-    assert.equal(node?.$type, 'doc.page');
-    assert.equal((node as any).title, 'Hello World');
-
-    const content = JSON.parse((node as any).content);
-    assert.equal(content.type, 'doc');
-    assert.ok(content.content.length > 0);
-  });
-
-  it('decode: .md without H1 — empty title', async () => {
-    await writeFile(join(dir, 'notes.md'), 'Just a paragraph.\n\n## Second heading\n');
-
-    const node = await store.get('/notes');
-    assert.equal(node?.$type, 'doc.page');
-    assert.equal((node as any).title, '');
-
-    const content = JSON.parse((node as any).content);
-    assert.equal(content.content[0].type, 'paragraph');
-    assert.equal(content.content[1].type, 'heading');
-  });
-
-  it('encode: doc.page node → .md file', async () => {
-    const tiptapDoc = {
-      type: 'doc',
-      content: [{ type: 'paragraph', content: [{ type: 'text', text: 'Hello from Tiptap' }] }],
-    };
-
-    await store.set({
-      $path: '/output',
-      $type: 'doc.page',
-      title: 'My Doc',
-      content: JSON.stringify(tiptapDoc),
-    } as any);
-
-    const raw = await readFile(join(dir, 'output.md'), 'utf-8');
-    assert.ok(raw.startsWith('# My Doc'));
-    assert.ok(raw.includes('Hello from Tiptap'));
-  });
-
-  it('encode: no title — no H1 prefix', async () => {
-    const tiptapDoc = {
-      type: 'doc',
-      content: [{ type: 'paragraph', content: [{ type: 'text', text: 'Just text' }] }],
-    };
-
-    await store.set({
-      $path: '/bare',
-      $type: 'doc.page',
-      title: '',
-      content: JSON.stringify(tiptapDoc),
-    } as any);
-
-    const raw = await readFile(join(dir, 'bare.md'), 'utf-8');
-    assert.ok(!raw.startsWith('#'));
-    assert.ok(raw.includes('Just text'));
-  });
-
-  it('roundtrip: .md → node → .md preserves content', async () => {
-    const original = '# Project Notes\n\nThis is **bold** and *italic*.\n\n- item one\n- item two\n\n```ts\nconst x = 1;\n```\n';
-    await writeFile(join(dir, 'notes.md'), original);
-
-    // Decode
-    const node = await store.get('/notes');
-    assert.equal(node?.$type, 'doc.page');
-    assert.equal((node as any).title, 'Project Notes');
-
-    // Encode back
-    await store.set(node!);
-    const result = await readFile(join(dir, 'notes.md'), 'utf-8');
-
-    // Verify key elements survived roundtrip
-    assert.ok(result.includes('# Project Notes'));
-    assert.ok(result.includes('**bold**'));
-    assert.ok(result.includes('*italic*'));
-    assert.ok(result.includes('- item one'));
-    assert.ok(result.includes('```ts'));
-    assert.ok(result.includes('const x = 1;'));
-  });
-
-  it('getChildren lists .md files as doc.page', async () => {
-    await writeFile(join(dir, 'a.md'), '# Alpha\n\nContent A\n');
-    await writeFile(join(dir, 'b.md'), '# Beta\n\nContent B\n');
-    await writeFile(join(dir, 'c.txt'), 'plain text');
-
-    const { items } = await store.getChildren('/');
-    const types = Object.fromEntries(items.map(n => [n.$path, n.$type]));
-
-    assert.equal(types['/a'], 'doc.page');
-    assert.equal(types['/b'], 'doc.page');
-    assert.equal(types['/c'], 'text/plain');
-  });
-});

package/doc/markdown.test.ts

@@ -1,152 +0,0 @@
-import assert from 'node:assert/strict';
-import { describe, it } from 'node:test';
-import { mdToTiptap, type TiptapNode, tiptapToMd } from './markdown';
-
-describe('mdToTiptap', () => {
-  it('parses heading', () => {
-    const doc = mdToTiptap('# Hello');
-    assert.equal(doc.type, 'doc');
-    assert.equal(doc.content?.[0].type, 'heading');
-    assert.equal(doc.content?.[0].attrs?.level, 1);
-    assert.equal(doc.content?.[0].content?.[0].text, 'Hello');
-  });
-
-  it('parses multiple heading levels', () => {
-    const doc = mdToTiptap('## Second\n### Third');
-    assert.equal(doc.content?.[0].attrs?.level, 2);
-    assert.equal(doc.content?.[1].attrs?.level, 3);
-  });
-
-  it('parses paragraph', () => {
-    const doc = mdToTiptap('Just some text');
-    assert.equal(doc.content?.[0].type, 'paragraph');
-    assert.equal(doc.content?.[0].content?.[0].text, 'Just some text');
-  });
-
-  it('parses bold and italic', () => {
-    const doc = mdToTiptap('This is **bold** and *italic*');
-    const nodes = doc.content?.[0].content ?? [];
-    assert.ok(nodes.some((n) => n.text === 'bold' && n.marks?.[0]?.type === 'bold'));
-    assert.ok(nodes.some((n) => n.text === 'italic' && n.marks?.[0]?.type === 'italic'));
-  });
-
-  it('parses inline code', () => {
-    const doc = mdToTiptap('Use `foo()` here');
-    const nodes = doc.content?.[0].content ?? [];
-    assert.ok(nodes.some((n) => n.text === 'foo()' && n.marks?.[0]?.type === 'code'));
-  });
-
-  it('parses bullet list', () => {
-    const doc = mdToTiptap('- one\n- two\n- three');
-    assert.equal(doc.content?.[0].type, 'bulletList');
-    assert.equal(doc.content?.[0].content?.length, 3);
-  });
-
-  it('parses ordered list', () => {
-    const doc = mdToTiptap('1. first\n2. second');
-    assert.equal(doc.content?.[0].type, 'orderedList');
-    assert.equal(doc.content?.[0].content?.length, 2);
-  });
-
-  it('parses code block', () => {
-    const doc = mdToTiptap('```ts\nconst x = 1;\n```');
-    assert.equal(doc.content?.[0].type, 'codeBlock');
-    assert.equal(doc.content?.[0].attrs?.language, 'ts');
-    assert.equal(doc.content?.[0].content?.[0].text, 'const x = 1;');
-  });
-
-  it('parses blockquote', () => {
-    const doc = mdToTiptap('> quoted text');
-    assert.equal(doc.content?.[0].type, 'blockquote');
-  });
-
-  it('parses horizontal rule', () => {
-    const doc = mdToTiptap('---');
-    assert.equal(doc.content?.[0].type, 'horizontalRule');
-  });
-
-  it('handles empty input', () => {
-    const doc = mdToTiptap('');
-    assert.equal(doc.type, 'doc');
-    assert.ok(doc.content?.length);
-  });
-
-  it('handles mixed content', () => {
-    const md = '# Title\n\nSome text\n\n- item 1\n- item 2\n\n```\ncode\n```';
-    const doc = mdToTiptap(md);
-    const types = doc.content?.map((c) => c.type);
-    assert.deepEqual(types, ['heading', 'paragraph', 'bulletList', 'codeBlock']);
-  });
-});
-
-describe('tiptapToMd', () => {
-  it('converts heading', () => {
-    const doc: TiptapNode = {
-      type: 'doc',
-      content: [{ type: 'heading', attrs: { level: 2 }, content: [{ type: 'text', text: 'Title' }] }],
-    };
-    assert.equal(tiptapToMd(doc), '## Title');
-  });
-
-  it('converts paragraph with marks', () => {
-    const doc: TiptapNode = {
-      type: 'doc',
-      content: [{
-        type: 'paragraph',
-        content: [
-          { type: 'text', text: 'Hello ' },
-          { type: 'text', text: 'world', marks: [{ type: 'bold' }] },
-        ],
-      }],
-    };
-    assert.equal(tiptapToMd(doc), 'Hello **world**');
-  });
-
-  it('converts bullet list', () => {
-    const doc: TiptapNode = {
-      type: 'doc',
-      content: [{
-        type: 'bulletList',
-        content: [
-          { type: 'listItem', content: [{ type: 'paragraph', content: [{ type: 'text', text: 'a' }] }] },
-          { type: 'listItem', content: [{ type: 'paragraph', content: [{ type: 'text', text: 'b' }] }] },
-        ],
-      }],
-    };
-    assert.equal(tiptapToMd(doc), '- a\n- b');
-  });
-
-  it('converts code block', () => {
-    const doc: TiptapNode = {
-      type: 'doc',
-      content: [{ type: 'codeBlock', attrs: { language: 'js' }, content: [{ type: 'text', text: 'x = 1' }] }],
-    };
-    assert.equal(tiptapToMd(doc), '```js\nx = 1\n```');
-  });
-
-  it('converts horizontal rule', () => {
-    const doc: TiptapNode = { type: 'doc', content: [{ type: 'horizontalRule' }] };
-    assert.equal(tiptapToMd(doc), '---');
-  });
-});
-
-describe('roundtrip md → tiptap → md', () => {
-  it('preserves basic structure', () => {
-    const original = '# Hello\n\nSome paragraph\n\n- one\n- two';
-    const tiptap = mdToTiptap(original);
-    const result = tiptapToMd(tiptap);
-    // Should contain the same elements (whitespace may differ)
-    assert.ok(result.includes('# Hello'));
-    assert.ok(result.includes('Some paragraph'));
-    assert.ok(result.includes('- one'));
-    assert.ok(result.includes('- two'));
-  });
-
-  it('preserves code block', () => {
-    const original = '```ts\nconst x = 1;\n```';
-    const tiptap = mdToTiptap(original);
-    const result = tiptapToMd(tiptap);
-    assert.ok(result.includes('```ts'));
-    assert.ok(result.includes('const x = 1;'));
-  });
-});

package/sim/sim.test.ts

@@ -1,282 +0,0 @@
-// AgentSim tests — round engine, proximity, tools, quorum
-
-import { createNode, getComponent, resolve } from '@treenity/core';
-import type { ServiceHandle } from '@treenity/core/contexts/service';
-import { createMemoryTree, type Tree } from '@treenity/core/tree';
-import assert from 'node:assert/strict';
-import { beforeEach, describe, it } from 'node:test';
-import './service'; // registers handlers once (ESM cache)
-
-let store: Tree;
-
-function agent(path: string, name: string, icon: string, x: number, y: number, radius = 200) {
-  return createNode(path, 'sim.agent', {}, {
-    descriptive: { $type: 'sim.descriptive', name, icon, description: `${name} agent` },
-    ai: { $type: 'sim.ai', systemPrompt: `You are ${name}.` },
-    position: { $type: 'sim.position', x, y, radius },
-    memory: { $type: 'sim.memory', entries: [] },
-  });
-}
-
-function world(path = '/w', running = false) {
-  return createNode(path, 'sim.world', {}, {
-    config: { $type: 'sim.config', width: 600, height: 400, roundDelay: 100, running },
-    round: { $type: 'sim.round', current: 0, phase: 'idle', log: [] },
-  });
-}
-
-beforeEach(() => {
-  store = createMemoryTree();
-});
-
-describe('sim.world registration', () => {
-  it('registers service handler', () => {
-    assert.ok(resolve('sim.world', 'service'));
-  });
-
-  it('registers start/stop actions', () => {
-    assert.ok(resolve('sim.world', 'action:start'));
-    assert.ok(resolve('sim.world', 'action:stop'));
-  });
-});
-
-describe('start/stop actions', () => {
-  it('action:start sets running=true', async () => {
-    const w = world();
-    await store.set(w);
-    const handler = resolve('sim.world', 'action:start')!;
-    await handler({ node: w, store, signal: AbortSignal.timeout(5000) }, {});
-    // Handlers mutate ctx.node in-place; caller persists (executeAction or service loop)
-    await store.set(w);
-    const fresh = await store.get(w.$path);
-    assert.equal((getComponent(fresh!, 'config') as any).running, true);
-  });
-
-  it('action:stop sets running=false', async () => {
-    const w = world('/w', true);
-    await store.set(w);
-    const handler = resolve('sim.world', 'action:stop')!;
-    await handler({ node: w, store, signal: AbortSignal.timeout(5000) }, {});
-    await store.set(w);
-    const fresh = await store.get(w.$path);
-    assert.equal((getComponent(fresh!, 'config') as any).running, false);
-  });
-});
-
-describe('proximity', () => {
-  it('agents within radius are nearby', async () => {
-    await store.set(world('/w', true));
-    // Large radius covers entire map — stays nearby even after random moves
-    await store.set(agent('/w/a', 'Alice', 'A', 100, 100, 900));
-    await store.set(agent('/w/b', 'Bob', 'B', 200, 200, 900));
-
-    const svc = resolve('sim.world', 'service')!;
-    const handle: ServiceHandle = await svc((await store.get('/w'))!, { store, subscribe: () => () => {} });
-    await new Promise((r) => setTimeout(r, 800));
-    await handle.stop();
-
-    const a = await store.get('/w/a');
-    const nearby = getComponent(a!, 'nearby') as any;
-    assert.ok(nearby);
-    assert.ok(nearby.agents.includes('Bob'));
-  });
-
-  it('agents outside radius are not nearby', async () => {
-    await store.set(world('/w', true));
-    await store.set(agent('/w/a', 'Alice', 'A', 0, 0, 50));
-    await store.set(agent('/w/b', 'Bob', 'B', 500, 500, 50)); // dist ~707 >> 50
-
-    const svc = resolve('sim.world', 'service')!;
-    const handle: ServiceHandle = await svc((await store.get('/w'))!, { store, subscribe: () => () => {} });
-    await new Promise((r) => setTimeout(r, 500));
-    await handle.stop();
-
-    const a = await store.get('/w/a');
-    const nearby = getComponent(a!, 'nearby') as any;
-    assert.ok(nearby);
-    assert.equal(nearby.agents.length, 0);
-  });
-});
-
-describe('round engine', () => {
-  it('advances round number after execution', async () => {
-    await store.set(world('/w', true));
-    await store.set(agent('/w/a', 'Alice', 'A', 100, 100));
-
-    const svc = resolve('sim.world', 'service')!;
-    const handle: ServiceHandle = await svc((await store.get('/w'))!, { store, subscribe: () => () => {} });
-    await new Promise((r) => setTimeout(r, 500));
-    await handle.stop();
-
-    const w = await store.get('/w');
-    const round = getComponent(w!, 'round') as any;
-    assert.ok(round.current >= 1, `expected round >= 1, got ${round.current}`);
-    assert.equal(round.phase, 'idle');
-  });
-
-  it('does not run when running=false', async () => {
-    await store.set(world('/w', false));
-    await store.set(agent('/w/a', 'Alice', 'A', 100, 100));
-
-    const svc = resolve('sim.world', 'service')!;
-    const handle: ServiceHandle = await svc((await store.get('/w'))!, { store, subscribe: () => () => {} });
-    await new Promise((r) => setTimeout(r, 400));
-    await handle.stop();
-
-    const w = await store.get('/w');
-    const round = getComponent(w!, 'round') as any;
-    assert.equal(round.current, 0);
-  });
-
-  it('produces event log entries', async () => {
-    await store.set(world('/w', true));
-    await store.set(agent('/w/a', 'Alice', 'A', 100, 100));
-    await store.set(agent('/w/b', 'Bob', 'B', 200, 200));
-
-    const svc = resolve('sim.world', 'service')!;
-    const handle: ServiceHandle = await svc((await store.get('/w'))!, { store, subscribe: () => () => {} });
-    await new Promise((r) => setTimeout(r, 500));
-    await handle.stop();
-
-    const w = await store.get('/w');
-    const round = getComponent(w!, 'round') as any;
-    assert.ok(round.log.length > 0, 'expected at least 1 event in log');
-  });
-
-  it('log entries have required fields', async () => {
-    await store.set(world('/w', true));
-    await store.set(agent('/w/a', 'Alice', 'A', 100, 100));
-
-    const svc = resolve('sim.world', 'service')!;
-    const handle: ServiceHandle = await svc((await store.get('/w'))!, { store, subscribe: () => () => {} });
-    await new Promise((r) => setTimeout(r, 500));
-    await handle.stop();
-
-    const w = await store.get('/w');
-    const round = getComponent(w!, 'round') as any;
-    for (const entry of round.log) {
-      assert.ok(typeof entry.round === 'number');
-      assert.ok(typeof entry.agent === 'string');
-      assert.ok(typeof entry.action === 'string');
-      assert.ok(typeof entry.ts === 'number');
-      assert.ok(entry.data !== undefined);
-    }
-  });
-});
-
-describe('mock tools', () => {
-  it('move clamps to world bounds', async () => {
-    await store.set(world('/w', true));
-    // Place agent so random move could exceed bounds
-    await store.set(agent('/w/a', 'Alice', 'A', 599, 399));
-
-    const svc = resolve('sim.world', 'service')!;
-    const handle: ServiceHandle = await svc((await store.get('/w'))!, { store, subscribe: () => () => {} });
-    // Run several rounds to get a move action
-    await new Promise((r) => setTimeout(r, 1500));
-    await handle.stop();
-
-    const a = await store.get('/w/a');
-    const pos = getComponent(a!, 'position') as any;
-    assert.ok(pos.x >= 0 && pos.x <= 600, `x=${pos.x} out of bounds`);
-    assert.ok(pos.y >= 0 && pos.y <= 400, `y=${pos.y} out of bounds`);
-  });
-
-  it('remember adds to memory', async () => {
-    await store.set(world('/w', true));
-    await store.set(agent('/w/a', 'Alice', 'A', 100, 100));
-
-    const svc = resolve('sim.world', 'service')!;
-    const handle: ServiceHandle = await svc((await store.get('/w'))!, { store, subscribe: () => () => {} });
-    // Run enough rounds for a remember action (mock: ~30% chance per round)
-    await new Promise((r) => setTimeout(r, 2000));
-    await handle.stop();
-
-    // Check if memory was modified (at least one remember should fire in ~10 rounds)
-    const a = await store.get('/w/a');
-    const mem = getComponent(a!, 'memory') as any;
-    // Can't guarantee remember fires, so just verify shape is intact
-    assert.ok(Array.isArray(mem.entries));
-    assert.ok(mem.entries.length <= 20, 'memory should be capped at 20');
-  });
-
-  it('speak sets heardBy for nearby agents', async () => {
-    await store.set(world('/w', true));
-    await store.set(agent('/w/a', 'Alice', 'A', 100, 100, 300));
-    await store.set(agent('/w/b', 'Bob', 'B', 150, 150, 300));
-
-    const svc = resolve('sim.world', 'service')!;
-    const handle: ServiceHandle = await svc((await store.get('/w'))!, { store, subscribe: () => () => {} });
-    await new Promise((r) => setTimeout(r, 2000));
-    await handle.stop();
-
-    const w = await store.get('/w');
-    const round = getComponent(w!, 'round') as any;
-    const speakEvents = round.log.filter((e: any) => e.action === 'speak');
-    assert.ok(speakEvents.length > 0, 'should have at least one speak event');
-    for (const e of speakEvents) {
-      assert.ok(Array.isArray(e.heardBy), 'speak event should have heardBy');
-    }
-  });
-});
-
-describe('quorum (parallel execution)', () => {
-  it('all agents act in same round', async () => {
-    await store.set(world('/w', true));
-    await store.set(agent('/w/a', 'Alice', 'A', 100, 100));
-    await store.set(agent('/w/b', 'Bob', 'B', 200, 200));
-    await store.set(agent('/w/c', 'Eve', 'C', 300, 300));
-
-    const svc = resolve('sim.world', 'service')!;
-    const handle: ServiceHandle = await svc((await store.get('/w'))!, { store, subscribe: () => () => {} });
-    // Run several rounds — remember actions don't produce log entries, need enough rounds
-    await new Promise((r) => setTimeout(r, 1500));
-    await handle.stop();
-
-    const w = await store.get('/w');
-    const round = getComponent(w!, 'round') as any;
-    assert.ok(round.log.length >= 1, 'should have at least 1 event across all rounds');
-    // Verify multiple agents produced events across rounds
-    const actors = new Set(round.log.map((e: any) => e.agent));
-    assert.ok(actors.size >= 2, `expected >= 2 actors, got ${actors.size}: ${[...actors]}`);
-  });
-});
-
-describe('service lifecycle', () => {
-  it('stop halts the service', async () => {
-    await store.set(world('/w', true));
-    await store.set(agent('/w/a', 'Alice', 'A', 100, 100));
-
-    const svc = resolve('sim.world', 'service')!;
-    const handle: ServiceHandle = await svc((await store.get('/w'))!, { store, subscribe: () => () => {} });
-    await new Promise((r) => setTimeout(r, 300));
-    await handle.stop();
-
-    const w1 = await store.get('/w');
-    const round1 = (getComponent(w1!, 'round') as any).current;
-
-    // Wait more — should NOT advance
-    await new Promise((r) => setTimeout(r, 500));
-    const w2 = await store.get('/w');
-    const round2 = (getComponent(w2!, 'round') as any).current;
-    assert.equal(round1, round2, 'round should not advance after stop');
-  });
-});
-
-describe('log trimming', () => {
-  it('log stays within 50 entries', async () => {
-    await store.set(world('/w', true));
-    await store.set(agent('/w/a', 'Alice', 'A', 100, 100, 300));
-    await store.set(agent('/w/b', 'Bob', 'B', 150, 150, 300));
-
-    const svc = resolve('sim.world', 'service')!;
-    const handle: ServiceHandle = await svc((await store.get('/w'))!, { store, subscribe: () => () => {} });
-    // Run many rounds
-    await new Promise((r) => setTimeout(r, 3000));
-    await handle.stop();
-
-    const w = await store.get('/w');
-    const round = getComponent(w!, 'round') as any;
-    assert.ok(round.log.length <= 50, `log has ${round.log.length} entries, expected <= 50`);
-  });
-});