@treenity/mods 3.0.1 → 3.0.3

package/whisper/inbox.ts

@@ -19,7 +19,7 @@ register('whisper.inbox', 'service', async (node, ctx) => {
   const sent = new Set<string>();
 
   // Mark existing COMPLETED transcriptions as already processed
-  const { items } = await ctx.store.getChildren(config.source);
+  const { items } = await ctx.tree.getChildren(config.source);
   for (const child of items) {
     if (child.$type !== 'whisper.transcription') continue;
     if (getText(child)) sent.add(child.$path);
@@ -29,7 +29,7 @@ register('whisper.inbox', 'service', async (node, ctx) => {
   const unsub = ctx.subscribe(config.source, (event) => {
     if (event.type !== 'set' && event.type !== 'patch') return;
 
-    ctx.store.get(event.path).then(async (n) => {
+    ctx.tree.get(event.path).then(async (n) => {
       if (!n || n.$type !== 'whisper.transcription') return;
       if (sent.has(n.$path)) return;
 
@@ -40,7 +40,7 @@ register('whisper.inbox', 'service', async (node, ctx) => {
 
       const taskId = `t-${Date.now()}`;
       const taskPath = `${config.target}/tasks/${taskId}`;
-      await ctx.store.set(createNode(taskPath, 'agent.task', {
+      await ctx.tree.set(createNode(taskPath, 'agent.task', {
         prompt: text,
         status: 'pending',
         createdAt: Date.now(),

package/whisper/route.ts

@@ -3,7 +3,7 @@
 
 import { type AutomaticSpeechRecognitionPipeline, pipeline } from '@huggingface/transformers';
 import { createNode } from '@treenity/core';
-import { newComp } from '@treenity/core/comp';
+import { newComponent } from '@treenity/core/comp';
 import type { Tree } from '@treenity/core/tree';
 import { execFile } from 'node:child_process';
 import { mkdir, readFile, unlink, writeFile } from 'node:fs/promises';
@@ -76,7 +76,7 @@ export function createWhisperHandler(cfg: WhisperRouteConfig) {
   // Pre-warm the pipeline
   getTranscriber(cfg.model);
 
-  return async (req: IncomingMessage, res: ServerResponse, store: Tree) => {
+  return async (req: IncomingMessage, res: ServerResponse, tree: Tree) => {
     if (req.method !== 'POST') {
       return respond(res, 405, { error: 'Method not allowed' });
     }
@@ -113,18 +113,18 @@ export function createWhisperHandler(cfg: WhisperRouteConfig) {
 
       // Ensure {servicePath}/{id} dir exists
       const idDirPath = `${cfg.nodePath}/${id}`;
-      if (!(await store.get(idDirPath))) {
-        await store.set(createNode(idDirPath, 'whisper.channel', {}, {
-          checklist: newComp(WhisperChecklist, {}),
+      if (!(await tree.get(idDirPath))) {
+        await tree.set(createNode(idDirPath, 'whisper.channel', {}, {
+          checklist: newComponent(WhisperChecklist, {}),
         }));
       }
 
       // 1. Create node immediately with audio — appears in tree right away
       const nodePath = `${idDirPath}/${noteId}`;
       const node = createNode(nodePath, 'whisper.transcription', {}, {
-        audio: newComp(WhisperAudio, { filename, size: body.length, mime }),
-        text: newComp(WhisperText, { content: '...' }),
-        meta: newComp(WhisperMeta, {
+        audio: newComponent(WhisperAudio, { filename, size: body.length, mime }),
+        text: newComponent(WhisperText, { content: '...' }),
+        meta: newComponent(WhisperMeta, {
           model: cfg.model,
           language: cfg.language,
           duration: 0,
@@ -132,7 +132,7 @@ export function createWhisperHandler(cfg: WhisperRouteConfig) {
           transcribedAt: Date.now(),
         }),
       });
-      await store.set(node);
+      await tree.set(node);
       console.log(`[whisper] ${filename} → ${nodePath} (processing...)`);
 
       // 2. Respond immediately — client sees the node path
@@ -156,17 +156,17 @@ export function createWhisperHandler(cfg: WhisperRouteConfig) {
             ? (outputChunks[outputChunks.length - 1].timestamp[1] ?? 0)
             : 0;
 
-          const updated = await store.get(nodePath);
+          const updated = await tree.get(nodePath);
           if (!updated) return;
-          updated.text = newComp(WhisperText, { content: text });
-          updated.meta = newComp(WhisperMeta, {
+          updated.text = newComponent(WhisperText, { content: text });
+          updated.meta = newComponent(WhisperMeta, {
             model: cfg.model,
             language: cfg.language,
             duration,
             segments: outputChunks?.length ?? 0,
             transcribedAt: Date.now(),
           });
-          await store.set(updated);
+          await tree.set(updated);
           console.log(`[whisper] ${nodePath} done (${outputChunks?.length ?? 0} seg, ${duration}s)`);
         })
         .catch((err) => console.error(`[whisper] ${nodePath} transcription failed:`, err))

package/board/board.test.ts

@@ -1,212 +0,0 @@
-// Board task tests — status flow, actions, field updates
-
-import { type NodeData, resolve } from '@treenity/core';
-import './types';
-import { createMemoryTree } from '@treenity/core/tree';
-import assert from 'node:assert/strict';
-import { describe, it } from 'node:test';
-
-function makeTask(overrides?: Partial<NodeData>): NodeData {
-  return {
-    $path: '/board/data/t-1',
-    $type: 'board.task',
-    title: 'Test task',
-    description: '',
-    status: 'backlog',
-    assignee: '',
-    priority: 'normal',
-    result: '',
-    createdAt: Date.now(),
-    updatedAt: 0,
-    ...overrides,
-  } as NodeData;
-}
-
-async function execAction(store: ReturnType<typeof createMemoryTree>, path: string, action: string, data?: unknown) {
-  const handler = resolve('board.task', `action:${action}`) as any;
-  assert.ok(handler, `action:${action} must be registered`);
-  const node = await store.get(path);
-  assert.ok(node, `node at ${path} must exist`);
-  await handler({ node, comp: node, store, signal: AbortSignal.timeout(5000) }, data);
-  return node;
-}
-
-describe('board.task registration', () => {
-  it('registers all expected actions', () => {
-    const actions = ['assign', 'start', 'submit', 'approve', 'reject', 'reopen'];
-    for (const action of actions) {
-      assert.ok(resolve('board.task', `action:${action}`), `action:${action} should be registered`);
-    }
-  });
-});
-
-describe('board.task.assign', () => {
-  it('sets assignee and moves to todo', async () => {
-    const store = createMemoryTree();
-    await store.set(makeTask());
-
-    const node = await execAction(store, '/board/data/t-1', 'assign', { to: 'alice' });
-    assert.equal(node.assignee, 'alice');
-    assert.equal(node.status, 'todo');
-    assert.ok((node.updatedAt as number) > 0);
-  });
-
-  it('trims whitespace from assignee', async () => {
-    const store = createMemoryTree();
-    await store.set(makeTask());
-
-    const node = await execAction(store, '/board/data/t-1', 'assign', { to: '  bob  ' });
-    assert.equal(node.assignee, 'bob');
-  });
-
-  it('throws on empty assignee', async () => {
-    const store = createMemoryTree();
-    await store.set(makeTask());
-
-    await assert.rejects(
-      () => execAction(store, '/board/data/t-1', 'assign', { to: '' }),
-      (err: Error) => err.message.includes('assignee'),
-    );
-  });
-});
-
-describe('board.task.start', () => {
-  it('moves from backlog to doing', async () => {
-    const store = createMemoryTree();
-    await store.set(makeTask({ status: 'backlog' }));
-
-    const node = await execAction(store, '/board/data/t-1', 'start');
-    assert.equal(node.status, 'doing');
-  });
-
-  it('moves from todo to doing', async () => {
-    const store = createMemoryTree();
-    await store.set(makeTask({ status: 'todo' }));
-
-    const node = await execAction(store, '/board/data/t-1', 'start');
-    assert.equal(node.status, 'doing');
-  });
-
-  it('throws from review', async () => {
-    const store = createMemoryTree();
-    await store.set(makeTask({ status: 'review' }));
-
-    await assert.rejects(
-      () => execAction(store, '/board/data/t-1', 'start'),
-      (err: Error) => err.message.includes('review'),
-    );
-  });
-});
-
-describe('board.task.submit', () => {
-  it('moves from doing to review', async () => {
-    const store = createMemoryTree();
-    await store.set(makeTask({ status: 'doing' }));
-
-    const node = await execAction(store, '/board/data/t-1', 'submit');
-    assert.equal(node.status, 'review');
-  });
-
-  it('stores result in result field', async () => {
-    const store = createMemoryTree();
-    await store.set(makeTask({ status: 'doing' }));
-
-    const node = await execAction(store, '/board/data/t-1', 'submit', { result: 'done it' });
-    assert.equal(node.result, 'done it');
-  });
-
-  it('throws from backlog', async () => {
-    const store = createMemoryTree();
-    await store.set(makeTask({ status: 'backlog' }));
-
-    await assert.rejects(
-      () => execAction(store, '/board/data/t-1', 'submit'),
-      (err: Error) => err.message.includes('backlog'),
-    );
-  });
-});
-
-describe('board.task.approve', () => {
-  it('moves from review to done', async () => {
-    const store = createMemoryTree();
-    await store.set(makeTask({ status: 'review' }));
-
-    const node = await execAction(store, '/board/data/t-1', 'approve');
-    assert.equal(node.status, 'done');
-  });
-
-  it('throws from doing', async () => {
-    const store = createMemoryTree();
-    await store.set(makeTask({ status: 'doing' }));
-
-    await assert.rejects(
-      () => execAction(store, '/board/data/t-1', 'approve'),
-      (err: Error) => err.message.includes('doing'),
-    );
-  });
-});
-
-describe('board.task.reject', () => {
-  it('moves from review back to doing', async () => {
-    const store = createMemoryTree();
-    await store.set(makeTask({ status: 'review' }));
-
-    const node = await execAction(store, '/board/data/t-1', 'reject');
-    assert.equal(node.status, 'doing');
-  });
-
-  it('stores rejection reason in result', async () => {
-    const store = createMemoryTree();
-    await store.set(makeTask({ status: 'review' }));
-
-    const node = await execAction(store, '/board/data/t-1', 'reject', { reason: 'needs tests' });
-    assert.ok((node.result as string).includes('needs tests'));
-  });
-
-  it('throws from backlog', async () => {
-    const store = createMemoryTree();
-    await store.set(makeTask({ status: 'backlog' }));
-
-    await assert.rejects(
-      () => execAction(store, '/board/data/t-1', 'reject'),
-      (err: Error) => err.message.includes('backlog'),
-    );
-  });
-});
-
-describe('board.task.reopen', () => {
-  it('resets to backlog, clears assignee and result', async () => {
-    const store = createMemoryTree();
-    await store.set(makeTask({ status: 'done', assignee: 'alice', result: 'old result' }));
-
-    const node = await execAction(store, '/board/data/t-1', 'reopen');
-    assert.equal(node.status, 'backlog');
-    assert.equal(node.assignee, '');
-    assert.equal(node.result, '');
-    assert.ok((node.updatedAt as number) > 0);
-  });
-});
-
-describe('board.task full lifecycle', () => {
-  it('backlog → assign → start → submit → approve', async () => {
-    const store = createMemoryTree();
-    await store.set(makeTask());
-
-    await execAction(store, '/board/data/t-1', 'assign', { to: 'ai-agent' });
-    const a1 = await store.get('/board/data/t-1');
-    assert.equal(a1?.status, 'todo');
-
-    await execAction(store, '/board/data/t-1', 'start');
-    const a2 = await store.get('/board/data/t-1');
-    assert.equal(a2?.status, 'doing');
-
-    await execAction(store, '/board/data/t-1', 'submit', { result: 'implemented' });
-    const a3 = await store.get('/board/data/t-1');
-    assert.equal(a3?.status, 'review');
-    assert.equal(a3?.result, 'implemented');
-
-    await execAction(store, '/board/data/t-1', 'approve');
-    const a4 = await store.get('/board/data/t-1');
-    assert.equal(a4?.status, 'done');
-  });
-});