@treenity/mods 3.0.1

package/todo/seed.ts

@@ -0,0 +1,9 @@
+import { type NodeData } from '@treenity/core';
+import { registerPrefab } from '@treenity/core/mod';
+
+registerPrefab('todo', 'seed', [
+  { $path: 'todo', $type: 'dir' },
+  { $path: 'todo/list', $type: 'todo.list', title: 'My Todos' },
+  { $path: 'todo/list/1', $type: 'todo.item', title: 'Read the quickstart', done: true },
+  { $path: 'todo/list/2', $type: 'todo.item', title: 'Build something', done: false },
+] as NodeData[]);

package/todo/server.ts

@@ -0,0 +1,2 @@
+import './types';
+import './seed';

package/todo/types.ts

@@ -0,0 +1,32 @@
+import { getCtx, registerType } from '@treenity/core/comp';
+
+class TodoItem {
+  title = '';
+  done = false;
+
+  /** @description Toggle done state */
+  toggle() {
+    this.done = !this.done;
+  }
+}
+
+class TodoList {
+  title = 'My Todos';
+
+  /** @description Add a new todo item */
+  async add(data: { title: string }) {
+    if (!data.title?.trim()) throw new Error('Title required');
+    const { node, store } = getCtx();
+    const id = Date.now().toString(36);
+    await store.set({
+      $path: `${node.$path}/${id}`,
+      $type: 'todo.item',
+      title: data.title.trim(),
+      done: false,
+    });
+  }
+}
+
+registerType('todo.item', TodoItem);
+registerType('todo.list', TodoList);
+export { TodoItem, TodoList };

package/todo/view.tsx

@@ -0,0 +1,67 @@
+import { type NodeData, register } from '@treenity/core';
+import { useChildren, usePath } from '@treenity/react/hooks';
+import { useState } from 'react';
+import { TodoItem, TodoList } from './types';
+
+function TodoListView({ value }: { value: NodeData }) {
+  const list = usePath(value.$path, TodoList);
+  const children = useChildren(value.$path, { watch: true, watchNew: true });
+  const [draft, setDraft] = useState('');
+
+  const handleAdd = async () => {
+    if (!draft.trim()) return;
+    await list.add({ title: draft });
+    setDraft('');
+  };
+
+  return (
+    <div className="max-w-md mx-auto p-4">
+      <h2 className="text-xl font-bold mb-4">{list.title}</h2>
+
+      <div className="flex gap-2 mb-4">
+        <input
+          className="flex-1 border rounded px-3 py-1.5 text-sm"
+          placeholder="What needs to be done?"
+          value={draft}
+          onChange={e => setDraft(e.target.value)}
+          onKeyDown={e => e.key === 'Enter' && handleAdd()}
+        />
+        <button
+          className="bg-blue-600 text-white px-3 py-1.5 rounded text-sm"
+          onClick={handleAdd}
+        >Add</button>
+      </div>
+
+      <ul className="space-y-1">
+        {children.map(child => (
+          <TodoItemRow key={child.$path} value={child} />
+        ))}
+      </ul>
+    </div>
+  );
+}
+
+function TodoItemRow({ value }: { value: NodeData }) {
+  const item = usePath(value.$path, TodoItem);
+
+  return (
+    <li
+      className="flex items-center gap-2 px-3 py-2 rounded
+        hover:bg-neutral-100 cursor-pointer"
+      onClick={() => item.toggle()}
+    >
+      <span className={`w-4 h-4 rounded border flex items-center
+        justify-center text-xs ${item.done
+          ? 'bg-blue-600 border-blue-600 text-white'
+          : 'border-neutral-300'}`}>
+        {item.done ? '✓' : ''}
+      </span>
+      <span className={item.done ? 'line-through text-neutral-400' : ''}>
+        {item.title}
+      </span>
+    </li>
+  );
+}
+
+register('todo.list', 'react', TodoListView as any);
+register('todo.item', 'react', TodoItemRow as any);

package/whisper/CLAUDE.md

@@ -0,0 +1,16 @@
+## mods/whisper
+Audio transcription via @huggingface/transformers (Whisper). HTTP POST → node in tree immediately, transcribe in background.
+
+### Файлы
+- route.ts — createWhisperHandler(cfg): POST audio → create node with status '...', respond 200, transcribe async via ffmpeg+transformers.js, update node
+- types.ts — WhisperAudio, WhisperText, WhisperMeta, WhisperChecklist component classes
+- service.ts — service registration
+- server.ts — mounts HTTP handler, tRPC routes
+- client.ts — frontend API
+- view.tsx — React UI
+
+### Конвенции
+- Pipeline: POST → ffmpeg → 16kHz mono WAV → Float32Array → Whisper pipeline
+- Node appears in tree immediately (status '...'), updated when transcription finishes
+- Models lazy-loaded and cached: `onnx-community/whisper-{model}` or full HF model id
+- timeId() = YYYYMMDD-HHmmss-SSS for sortable node names

package/whisper/client.ts

@@ -0,0 +1 @@
+import './view';

package/whisper/inbox.ts

@@ -0,0 +1,54 @@
+// Whisper → Agent bridge service
+// Watches a whisper channel for completed transcriptions, creates agent tasks
+
+import { createNode, getComponent, type NodeData, register } from '@treenity/core';
+import { WhisperInbox, WhisperText } from './types';
+
+const log = (msg: string) => console.log(`[whisper.inbox] ${msg}`);
+
+function getText(node: NodeData): string | undefined {
+  const comp = getComponent(node, WhisperText);
+  if (!comp) return undefined;
+  return comp.content && comp.content !== '...' ? comp.content : undefined;
+}
+
+register('whisper.inbox', 'service', async (node, ctx) => {
+  const config = getComponent(node, WhisperInbox);
+  if (!config) throw new Error(`missing config on ${node.$path}`);
+
+  const sent = new Set<string>();
+
+  // Mark existing COMPLETED transcriptions as already processed
+  const { items } = await ctx.store.getChildren(config.source);
+  for (const child of items) {
+    if (child.$type !== 'whisper.transcription') continue;
+    if (getText(child)) sent.add(child.$path);
+  }
+  log(`watching ${config.source} → ${config.target} (${sent.size} existing)`);
+
+  const unsub = ctx.subscribe(config.source, (event) => {
+    if (event.type !== 'set' && event.type !== 'patch') return;
+
+    ctx.store.get(event.path).then(async (n) => {
+      if (!n || n.$type !== 'whisper.transcription') return;
+      if (sent.has(n.$path)) return;
+
+      const text = getText(n);
+      if (!text) return;
+
+      sent.add(n.$path);
+
+      const taskId = `t-${Date.now()}`;
+      const taskPath = `${config.target}/tasks/${taskId}`;
+      await ctx.store.set(createNode(taskPath, 'agent.task', {
+        prompt: text,
+        status: 'pending',
+        createdAt: Date.now(),
+      }));
+
+      log(`${n.$path} → ${taskPath}`);
+    }).catch(err => console.error(`[whisper.inbox] error processing ${event.path}:`, err));
+  }, { children: true });
+
+  return { stop: async () => unsub() };
+});

package/whisper/route.ts

@@ -0,0 +1,182 @@
+// Whisper audio transcription — HTTP handler
+// POST ?id=channel-id with audio body → create node immediately, transcribe in background, update node
+
+import { type AutomaticSpeechRecognitionPipeline, pipeline } from '@huggingface/transformers';
+import { createNode } from '@treenity/core';
+import { newComp } 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';
+import { type IncomingMessage, type ServerResponse } from 'node:http';
+import { join, resolve } from 'node:path';
+import { promisify } from 'node:util';
+import WaveFile from 'wavefile';
+import { WhisperAudio, WhisperChecklist, WhisperMeta, WhisperText } from './types';
+
+const execFileAsync = promisify(execFile);
+
+// Lazy-initialized pipelines keyed by model name
+const pipelines = new Map<string, Promise<AutomaticSpeechRecognitionPipeline>>();
+
+function getTranscriber(model: string): Promise<AutomaticSpeechRecognitionPipeline> {
+  let p = pipelines.get(model);
+  if (!p) {
+    const modelId = model.includes('/') ? model : `onnx-community/whisper-${model}`;
+    console.log(`[whisper] loading model ${modelId}...`);
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any -- pipeline() union type is too complex for TS
+    p = (pipeline as any)('automatic-speech-recognition', modelId, {
+      dtype: {
+        encoder_model: 'fp32',
+        decoder_model_merged: 'q4',
+      },
+    }) as Promise<AutomaticSpeechRecognitionPipeline>;
+    p.then(() => console.log(`[whisper] model ${modelId} ready`))
+      .catch((e: unknown) => {
+        console.error(`[whisper] model ${modelId} failed:`, e);
+        pipelines.delete(model); // allow retry on next request
+      });
+    pipelines.set(model, p);
+  }
+  return p;
+}
+
+function respond(res: ServerResponse, status: number, body: unknown) {
+  res.writeHead(status, { 'Content-Type': 'application/json' });
+  res.end(JSON.stringify(body));
+}
+
+// Sortable time-based id: YYYYMMDD-HHmmss-SSS
+function timeId(): string {
+  const d = new Date();
+  const pad = (n: number, w = 2) => String(n).padStart(w, '0');
+  return `${d.getFullYear()}${pad(d.getMonth() + 1)}${pad(d.getDate())}-${pad(d.getHours())}${pad(d.getMinutes())}${pad(d.getSeconds())}-${pad(d.getMilliseconds(), 3)}`;
+}
+
+/** Read 16kHz mono WAV file → Float32Array for transformers.js */
+async function readWavAsFloat32(wavPath: string): Promise<Float32Array> {
+  const buf = await readFile(wavPath);
+  const wav = new WaveFile.WaveFile(buf);
+  wav.toBitDepth('32f');
+  wav.toSampleRate(16000);
+  let samples = wav.getSamples();
+  if (Array.isArray(samples)) samples = samples[0];
+  return new Float32Array(samples);
+}
+
+export type WhisperRouteConfig = {
+  nodePath: string;
+  model: string;
+  language: string;
+  audioDir: string;
+};
+
+export function createWhisperHandler(cfg: WhisperRouteConfig) {
+  const audioDir = resolve(cfg.audioDir);
+
+  // Pre-warm the pipeline
+  getTranscriber(cfg.model);
+
+  return async (req: IncomingMessage, res: ServerResponse, store: Tree) => {
+    if (req.method !== 'POST') {
+      return respond(res, 405, { error: 'Method not allowed' });
+    }
+
+    const url = new URL(req.url ?? '/', 'http://localhost');
+    const id = url.searchParams.get('id');
+    if (!id) {
+      return respond(res, 400, { error: 'Missing ?id= query parameter' });
+    }
+
+    const chunks: Buffer[] = [];
+    for await (const chunk of req) chunks.push(chunk as Buffer);
+    const body = Buffer.concat(chunks);
+
+    if (body.length === 0) {
+      return respond(res, 400, { error: 'Empty request body' });
+    }
+
+    const mime = req.headers['content-type'] || 'audio/wav';
+    const ext = mime.includes('mp3') ? 'mp3'
+      : mime.includes('ogg') ? 'ogg'
+      : mime.includes('webm') ? 'webm'
+      : mime.includes('m4a') ? 'm4a'
+      : 'wav';
+
+    const noteId = timeId();
+    const filename = `${id}-${noteId}.${ext}`;
+    const filePath = join(audioDir, filename);
+    const wavPath = join(audioDir, `${id}-${noteId}_16k.wav`);
+
+    try {
+      await mkdir(audioDir, { recursive: true });
+      await writeFile(filePath, body);
+
+      // 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, {}),
+        }));
+      }
+
+      // 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, {
+          model: cfg.model,
+          language: cfg.language,
+          duration: 0,
+          segments: 0,
+          transcribedAt: Date.now(),
+        }),
+      });
+      await store.set(node);
+      console.log(`[whisper] ${filename} → ${nodePath} (processing...)`);
+
+      // 2. Respond immediately — client sees the node path
+      respond(res, 200, { path: nodePath, status: 'processing' });
+
+      // 3. Transcribe in background, update node when done
+      execFileAsync('ffmpeg', ['-i', filePath, '-ar', '16000', '-ac', '1', '-f', 'wav', '-y', wavPath])
+        .then(() => readWavAsFloat32(wavPath))
+        .then(async (audioData) => {
+          const transcriber = await getTranscriber(cfg.model);
+          const result = await transcriber(audioData, {
+            language: cfg.language,
+            return_timestamps: true,
+          });
+
+          const output = Array.isArray(result) ? result[0] : result;
+          const text = (output.text ?? '').trim();
+          const outputChunks = (output as any).chunks as Array<{ text: string; timestamp: [number, number | null] }> | undefined;
+
+          const duration = outputChunks?.length
+            ? (outputChunks[outputChunks.length - 1].timestamp[1] ?? 0)
+            : 0;
+
+          const updated = await store.get(nodePath);
+          if (!updated) return;
+          updated.text = newComp(WhisperText, { content: text });
+          updated.meta = newComp(WhisperMeta, {
+            model: cfg.model,
+            language: cfg.language,
+            duration,
+            segments: outputChunks?.length ?? 0,
+            transcribedAt: Date.now(),
+          });
+          await store.set(updated);
+          console.log(`[whisper] ${nodePath} done (${outputChunks?.length ?? 0} seg, ${duration}s)`);
+        })
+        .catch((err) => console.error(`[whisper] ${nodePath} transcription failed:`, err))
+        .finally(() => {
+          unlink(wavPath).catch(() => {});
+        });
+
+    } catch (err) {
+      console.error('[whisper] transcription error:', err);
+      respond(res, 500, { error: String(err) });
+    }
+  };
+}

package/whisper/seed.ts

@@ -0,0 +1,15 @@
+import { type NodeData } from '@treenity/core';
+import { registerPrefab } from '@treenity/core/mod';
+
+registerPrefab('whisper', 'seed', [
+  { $path: 'whisper', $type: 'whisper.service',
+    config: {
+      $type: 'whisper.config', model: 'small', language: 'ru',
+      audioDir: './data/audio', url: '/api/notice/audio',
+    },
+  },
+  { $path: '/sys/autostart/whisper', $type: 'ref', $ref: '/whisper' },
+  { $path: 'whisper/inbox', $type: 'whisper.inbox',
+    source: '/whisper/default', target: '/agent' },
+  { $path: '/sys/autostart/whisper-inbox', $type: 'ref', $ref: '/whisper/inbox' },
+] as NodeData[]);

package/whisper/server.ts

@@ -0,0 +1,4 @@
+import './types';
+import './service';
+import './inbox';
+import './seed';

package/whisper/service.ts

@@ -0,0 +1,29 @@
+// Whisper service — autostart-compatible, registers HTTP route dynamically
+
+import { getComponent, register } from '@treenity/core';
+import { routeRegistry } from '@treenity/core/server/server';
+import { createWhisperHandler } from './route';
+import { WhisperConfig } from './types';
+
+register('whisper.service', 'service', async (node, _ctx) => {
+  const config = getComponent(node, WhisperConfig);
+  if (!config) throw new Error(`[whisper] missing config on ${node.$path}`);
+
+  const routePath = config.url || node.$path;
+  const handler = createWhisperHandler({
+    nodePath: node.$path,
+    model: config.model,
+    language: config.language,
+    audioDir: config.audioDir,
+  });
+
+  routeRegistry.set(routePath, handler);
+  console.log(`[whisper] route ${routePath} (model: ${config.model})`);
+
+  return {
+    stop: async () => {
+      routeRegistry.delete(routePath);
+      console.log(`[whisper] unregistered ${routePath}`);
+    },
+  };
+});

package/whisper/types.ts

@@ -0,0 +1,51 @@
+import { registerType } from '@treenity/core/comp';
+
+/** Speech-to-text config — Whisper model, language, audio path */
+export class WhisperConfig {
+  model = 'small';
+  language = 'ru';
+  audioDir = './data/audio';
+  url = '';  // override route path; empty = use node's $path
+}
+
+/** Audio file metadata — filename, size, MIME type */
+export class WhisperAudio {
+  filename = '';
+  size = 0;
+  mime = 'audio/wav';
+}
+
+/** Transcription result — recognized text content */
+export class WhisperText {
+  /** @format textarea */
+  content = '';
+}
+
+/** Transcription metadata — model, language, duration, segments */
+export class WhisperMeta {
+  model = '';
+  language = '';
+  duration = 0;
+  segments = 0;
+  transcribedAt = 0;
+}
+
+/** Meeting checklist — action items from transcription */
+export class WhisperChecklist {
+  checked: string[] = [];
+}
+
+/** Bridge: auto-send whisper transcriptions to a task inbox */
+export class WhisperInbox {
+  /** @format path @description Whisper channel to watch, e.g. /whisper/kriz */
+  source = '';
+  /** @format path @description Target inbox, e.g. /agent */
+  target = '';
+}
+
+registerType('whisper.config', WhisperConfig);
+registerType('whisper.audio', WhisperAudio);
+registerType('whisper.text', WhisperText);
+registerType('whisper.meta', WhisperMeta);
+registerType('whisper.checklist', WhisperChecklist);
+registerType('whisper.inbox', WhisperInbox);

package/whisper/view.tsx

@@ -0,0 +1,81 @@
+// Whisper channel view — checklist of transcribed audio notes
+
+import { type NodeData, register } from '@treenity/core';
+import { set, useChildren, usePath } from '@treenity/react/hooks';
+
+function ChannelView({ value }: { value: NodeData }) {
+  const children = useChildren(value.$path, { watchNew: true });
+  const node = usePath(value.$path);
+  const checklist = node?.checklist as { $type: string; checked?: string[] } | undefined;
+
+  const checked = new Set<string>(checklist?.checked ?? []);
+
+  const items = children.filter(c => {
+    const text = c.text as { $type: string; content: string } | undefined;
+    return text?.$type === 'whisper.text' && text.content && text.content !== '...';
+  });
+
+  const processing = children.filter(c => {
+    const text = c.text as { $type: string; content: string } | undefined;
+    return text?.$type === 'whisper.text' && text.content === '...';
+  });
+
+  const toggle = (path: string) => {
+    if (!node) return;
+    const next = new Set(checked);
+    if (next.has(path)) next.delete(path);
+    else next.add(path);
+    set({ ...node, checklist: { $type: 'whisper.checklist', checked: [...next] } });
+  };
+
+  return (
+    <div className="node-default-view">
+      {items.map(child => {
+        const text = (child.text as any).content as string;
+        const name = child.$path.slice(child.$path.lastIndexOf('/') + 1);
+        const meta = child.meta as { duration?: number } | undefined;
+        const done = checked.has(child.$path);
+
+        return (
+          <label
+            key={child.$path}
+            className={`flex gap-2.5 px-3 py-2.5 cursor-pointer border-b border-[var(--border)] ${done ? 'opacity-50' : ''}`}
+          >
+            <input
+              type="checkbox"
+              checked={done}
+              onChange={() => toggle(child.$path)}
+              className="mt-0.5 shrink-0 w-4 h-4 p-0"
+            />
+            <div className="flex-1">
+              <div className={`text-[13px] leading-snug ${done ? 'line-through' : ''}`}>
+                {text}
+              </div>
+              <div className="text-[11px] text-[var(--text-3)] mt-1">
+                {name}{meta?.duration ? ` · ${meta.duration}s` : ''}
+              </div>
+            </div>
+          </label>
+        );
+      })}
+
+      {processing.map(child => {
+        const name = child.$path.slice(child.$path.lastIndexOf('/') + 1);
+        return (
+          <div
+            key={child.$path}
+            className="px-3 py-2.5 border-b border-[var(--border)] text-[var(--text-3)] text-[13px] italic"
+          >
+            {name} — transcribing...
+          </div>
+        );
+      })}
+
+      {items.length === 0 && processing.length === 0 && (
+        <div className="node-empty">No transcriptions yet</div>
+      )}
+    </div>
+  );
+}
+
+register('whisper.channel', 'react', ChannelView as any);