@treenity/core 1.0.48 → 3.0.1

package/src/mod/prefab.ts

@@ -0,0 +1,62 @@
+// Treenity Prefab Registry — in-memory store for module prefab declarations
+// Modules call registerPrefab() during import; mods-mount exposes data as virtual tree.
+// Prefabs named 'seed' are auto-deployed at startup by deploySeedPrefabs().
+
+import { type NodeData } from '#core';
+
+export type PrefabSetup = (nodes: NodeData[], params?: unknown) => NodeData[] | Promise<NodeData[]>;
+
+export type PrefabMeta = { tier?: 'core' };
+
+export type PrefabEntry = {
+  nodes: NodeData[];
+  setup?: PrefabSetup;
+  meta?: PrefabMeta;
+};
+
+// Key: "mod/name"
+const prefabs = new Map<string, PrefabEntry>();
+
+export function registerPrefab(
+  mod: string,
+  name: string,
+  nodes: NodeData[],
+  setup?: PrefabSetup,
+  meta?: PrefabMeta,
+): void {
+  const key = `${mod}/${name}`;
+  if (prefabs.has(key)) return; // sealed, like registry
+  prefabs.set(key, { nodes, setup, meta });
+}
+
+export function getPrefab(mod: string, name: string): PrefabEntry | undefined {
+  return prefabs.get(`${mod}/${name}`);
+}
+
+export function getModPrefabs(mod: string): [string, PrefabEntry][] {
+  const result: [string, PrefabEntry][] = [];
+  for (const [k, v] of prefabs) {
+    if (k.startsWith(mod + '/')) result.push([k.slice(mod.length + 1), v]);
+  }
+  return result;
+}
+
+export function getRegisteredMods(): string[] {
+  const mods = new Set<string>();
+  for (const k of prefabs.keys()) mods.add(k.split('/')[0]);
+  return [...mods];
+}
+
+/** All seed prefabs: [mod, PrefabEntry][] */
+export function getSeedPrefabs(): [string, PrefabEntry][] {
+  const result: [string, PrefabEntry][] = [];
+  for (const [k, v] of prefabs) {
+    if (k.endsWith('/seed')) result.push([k.split('/')[0], v]);
+  }
+  return result;
+}
+
+// For tests
+export function clearPrefabs(): void {
+  prefabs.clear();
+}

package/src/mod/tracking.test.ts

@@ -0,0 +1,59 @@
+import assert from 'node:assert/strict';
+import { afterEach, describe, it } from 'node:test';
+import { clearTracking, getCurrentMod, getTypesForMod, inferModFromType, setCurrentMod, trackType } from './tracking';
+
+describe('mod/tracking', () => {
+  afterEach(() => clearTracking());
+
+  it('setCurrentMod + trackType maps type to mod', () => {
+    setCurrentMod('cafe');
+    trackType('cafe.contact');
+    trackType('cafe.mail');
+    setCurrentMod(null);
+
+    assert.deepEqual(getTypesForMod('cafe').sort(), ['cafe.contact', 'cafe.mail']);
+  });
+
+  it('trackType without currentMod does not track', () => {
+    trackType('orphan.type');
+    assert.deepEqual(getTypesForMod('orphan'), []);
+  });
+
+  it('getTypesForMod returns empty for unknown mod', () => {
+    assert.deepEqual(getTypesForMod('nope'), []);
+  });
+
+  it('getCurrentMod reflects setCurrentMod', () => {
+    assert.equal(getCurrentMod(), null);
+    setCurrentMod('test');
+    assert.equal(getCurrentMod(), 'test');
+    setCurrentMod(null);
+    assert.equal(getCurrentMod(), null);
+  });
+
+  it('inferModFromType uses tracked mapping first', () => {
+    setCurrentMod('my-cafe');
+    trackType('cafe.contact');
+    setCurrentMod(null);
+
+    assert.equal(inferModFromType('cafe.contact'), 'my-cafe');
+  });
+
+  it('inferModFromType falls back to first segment', () => {
+    assert.equal(inferModFromType('sim.agent'), 'sim');
+    assert.equal(inferModFromType('mabu.block.hero'), 'mabu');
+  });
+
+  it('inferModFromType uses alias map', () => {
+    assert.equal(inferModFromType('order.status'), 'orders');
+  });
+
+  it('clearTracking resets all state', () => {
+    setCurrentMod('x');
+    trackType('x.foo');
+    clearTracking();
+
+    assert.equal(getCurrentMod(), null);
+    assert.deepEqual(getTypesForMod('x'), []);
+  });
+});

package/src/mod/tracking.ts

@@ -0,0 +1,51 @@
+// Type→Mod tracking — runtime map of which mod registered which types
+// setCurrentMod() wraps import() in loader; trackType() called from registerType.
+// Convention fallback: first segment of type name = mod name (cafe.contact → cafe).
+
+let currentMod: string | null = null;
+
+// type → mod name
+const typeToMod = new Map<string, string>();
+
+// Aliases for types whose first segment ≠ mod dir name
+const MOD_ALIASES: Record<string, string> = {
+  order: 'orders',
+  pult: 'pult',
+};
+
+export function setCurrentMod(name: string | null): void {
+  currentMod = name;
+}
+
+export function getCurrentMod(): string | null {
+  return currentMod;
+}
+
+export function trackType(typeName: string): void {
+  if (currentMod) {
+    typeToMod.set(typeName, currentMod);
+  }
+}
+
+export function getTypesForMod(modName: string): string[] {
+  const types: string[] = [];
+  for (const [type, mod] of typeToMod) {
+    if (mod === modName) types.push(type);
+  }
+  return types;
+}
+
+/** Infer mod name from type name: tracked → exact; else first segment + alias lookup */
+export function inferModFromType(typeName: string): string {
+  const tracked = typeToMod.get(typeName);
+  if (tracked) return tracked;
+
+  const first = typeName.split('.')[0];
+  return MOD_ALIASES[first] ?? first;
+}
+
+// For tests
+export function clearTracking(): void {
+  typeToMod.clear();
+  currentMod = null;
+}

package/src/mod/types.ts

@@ -0,0 +1,40 @@
+// Treenity Module System — type definitions
+
+import type { Tree } from '#tree';
+
+export interface TreenityMod {
+  name: string;
+  dependencies?: string[];
+  server?: () => Promise<unknown>;
+  client?: () => Promise<unknown>;
+  seed?: (store: Tree) => Promise<void>;
+  onLoad?: () => void | Promise<void>;
+  onUnload?: () => void | Promise<void>;
+}
+
+// package.json "treenity" field shape (npm discovery)
+export interface ModManifest {
+  name: string;
+  version: string;
+  types?: string[];
+  dependencies?: string[];
+  server?: string;
+  client?: string;
+  seed?: string;
+  packagePath?: string;
+}
+
+export type ModState = 'discovered' | 'loading' | 'loaded' | 'failed' | 'disabled';
+
+export interface LoadedMod {
+  manifest?: ModManifest;
+  mod?: TreenityMod;
+  name: string;
+  state: ModState;
+  error?: Error;
+  loadedAt?: number;
+}
+
+export function defineMod(mod: TreenityMod): TreenityMod {
+  return mod;
+}

package/src/mod.ts

@@ -0,0 +1 @@
+export * from './mod/index.ts';

package/src/mods/autostart/CLAUDE.md

@@ -0,0 +1,6 @@
+# autostart
+
+Init.d-паттерн. Обходит `/sys/autostart`, резолвит ref-детей, запускает service-контекст каждого. Отслеживает состояние в `/proc/`. Экспонирует `start`/`stop` actions.
+
+## Types
+- `autostart` — start/stop actions

package/src/mods/autostart/autostart.test.ts

@@ -0,0 +1,85 @@
+// Autostart dynamic start/stop tests
+// Tests: startService creates ref + starts, stopService removes ref + stops, boot walks children
+
+import { startServices } from '#contexts/service/index';
+import type { NodeData } from '#core';
+import { createNode, register } from '#core';
+import { createMemoryTree } from '#tree';
+import assert from 'node:assert/strict';
+import { describe, it } from 'node:test';
+
+// Import real autostart module — registers 'autostart' type + service handler
+import { startService, stopService } from './service';
+
+// Register test service types once (sealed registry)
+const svcLog: string[] = [];
+register('test.autosvc', 'service', async (node) => {
+  svcLog.push(`start:${node.$path}`);
+  return { stop: async () => { svcLog.push(`stop:${node.$path}`); } };
+});
+
+describe('autostart dynamic start/stop', () => {
+  async function boot() {
+    svcLog.length = 0;
+    const store = createMemoryTree();
+    await store.set(createNode('/sys/autostart', 'autostart'));
+    const handle = await startServices(store, () => () => {});
+    assert.ok(handle);
+    return { store, handle: handle! };
+  }
+
+  it('startService creates ref child and starts service', async () => {
+    const { store, handle } = await boot();
+
+    await store.set({ $path: '/srv/a', $type: 'test.autosvc' } as NodeData);
+    await startService('/srv/a');
+
+    assert.deepEqual(svcLog, ['start:/srv/a']);
+
+    const { items } = await store.getChildren('/sys/autostart');
+    const ref = items.find(n => (n as any).$ref === '/srv/a');
+    assert.ok(ref, 'ref child created');
+    assert.equal(ref!.$type, 'ref');
+
+    await handle.stop();
+  });
+
+  it('stopService stops service and removes ref', async () => {
+    const { store, handle } = await boot();
+
+    await store.set({ $path: '/srv/b', $type: 'test.autosvc' } as NodeData);
+    await startService('/srv/b');
+    await stopService('/srv/b');
+
+    assert.deepEqual(svcLog, ['start:/srv/b', 'stop:/srv/b']);
+
+    const { items } = await store.getChildren('/sys/autostart');
+    const ref = items.find(n => (n as any).$ref === '/srv/b');
+    assert.equal(ref, undefined, 'ref removed after stop');
+
+    await handle.stop();
+  });
+
+  it('startService is idempotent', async () => {
+    const { store, handle } = await boot();
+
+    await store.set({ $path: '/srv/c', $type: 'test.autosvc' } as NodeData);
+    await startService('/srv/c');
+    await startService('/srv/c');
+
+    assert.deepEqual(svcLog, ['start:/srv/c'], 'started only once');
+    await handle.stop();
+  });
+
+  it('boot walks existing ref children', async () => {
+    svcLog.length = 0;
+    const store = createMemoryTree();
+    await store.set(createNode('/sys/autostart', 'autostart'));
+    await store.set({ $path: '/srv/d', $type: 'test.autosvc' } as NodeData);
+    await store.set({ $path: '/sys/autostart/d', $type: 'ref', $ref: '/srv/d' } as NodeData);
+
+    const handle = await startServices(store, () => () => {});
+    assert.deepEqual(svcLog, ['start:/srv/d']);
+    await handle!.stop();
+  });
+});

package/src/mods/autostart/server.ts

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

package/src/mods/autostart/service.ts

@@ -0,0 +1,98 @@
+// Autostart — service coordinator with dynamic start/stop
+// Walks children at boot, tracks handles, exposes start/stop actions
+// Tree = truth: ref child exists ↔ service is running
+
+import { registerType } from '#comp';
+import { type ServiceCtx, type ServiceHandle } from '#contexts/service/index';
+import { isRef, type NodeData, register, resolve as coreResolve } from '#core';
+import { resolveRef } from '#tree';
+
+// ── Module-scope service tracking ──
+
+const handles = new Map<string, ServiceHandle>();
+let _svcCtx: ServiceCtx | null = null;
+let _autostartPath = '/sys/autostart';
+
+async function _startService(path: string): Promise<void> {
+  if (handles.has(path)) return;
+  if (!_svcCtx) throw new Error('autostart: not initialized');
+
+  const node = await _svcCtx.store.get(path);
+  if (!node) throw new Error(`autostart: node not found: ${path}`);
+
+  const handler = coreResolve(node.$type, 'service');
+  if (!handler) throw new Error(`autostart: no service handler for ${node.$type}`);
+
+  handles.set(path, await handler(node, _svcCtx));
+  console.log(`[autostart] started ${path}`);
+}
+
+async function _stopService(path: string): Promise<void> {
+  const h = handles.get(path);
+  if (!h) return;
+  await h.stop();
+  handles.delete(path);
+  console.log(`[autostart] stopped ${path}`);
+}
+
+// ── Public API — direct import for server code, typed actions for MCP/tRPC ──
+
+export async function startService(path: string): Promise<void> {
+  if (!_svcCtx) throw new Error('autostart: not initialized');
+  if (handles.has(path)) return;
+
+  // Add ref child → tree reflects reality
+  const name = path.split('/').filter(Boolean).join('-');
+  const refPath = `${_autostartPath}/${name}`;
+  const existing = await _svcCtx.store.get(refPath);
+  if (!existing) {
+    await _svcCtx.store.set({ $path: refPath, $type: 'ref', $ref: path } as NodeData);
+  }
+
+  await _startService(path);
+}
+
+export async function stopService(path: string): Promise<void> {
+  if (!_svcCtx) throw new Error('autostart: not initialized');
+
+  await _stopService(path);
+
+  // Remove ref child → tree reflects reality
+  const { items } = await _svcCtx.store.getChildren(_autostartPath);
+  const ref = items.find(n => isRef(n) && n.$ref === path);
+  if (ref) await _svcCtx.store.remove(ref.$path);
+}
+
+/** Service lifecycle manager — start/stop services via ref children */
+export class Autostart {
+  /** @description Start a service at given path */
+  async start(data: { /** service to start */ path: string }) { await startService(data.path); }
+  /** @description Stop a service at given path */
+  async stop(data: { path: string }) { await stopService(data.path); }
+}
+registerType('autostart', Autostart);
+
+// ── Boot service handler ──
+
+register('autostart', 'service', async (node, ctx) => {
+  _svcCtx = ctx;
+  _autostartPath = node.$path;
+
+  const { items } = await ctx.store.getChildren(node.$path);
+  for (const child of items) {
+    try {
+      const target = await resolveRef(ctx.store, child);
+      await _startService(target.$path);
+    } catch (e) {
+      console.error(`[autostart] failed ${child.$path}:`, e);
+    }
+  }
+
+  return {
+    stop: async () => {
+      for (const path of [...handles.keys()]) {
+        await _stopService(path).catch(console.error);
+      }
+    },
+  };
+});

package/src/mods/clients.ts

@@ -0,0 +1,2 @@
+// Barrel: all core mod client registrations
+import './uix/client';

package/src/mods/llm/CLAUDE.md

@@ -0,0 +1,6 @@
+# llm
+
+Мост для LLM-контекста. Выгружает все зарегистрированные типы со схемами (`schema` action) и рендерит поддерево как текст (`describe` action) — для промптов и AI-потребления.
+
+## Types
+- `t.llm` — actions: `schema`, `describe`

package/src/mods/llm/index.ts

@@ -0,0 +1,57 @@
+// Treenity LLM Context — Layer 6
+// Schema export + tree description for LLM consumption
+// Type: t.llm — node at /llm, actions: schema, describe
+
+import { getContextsForType, getRegisteredTypes, register, resolve } from '#core';
+import { basename } from '#core/path';
+import { type ActionCtx } from '#server/actions';
+
+export type TypeInfo = {
+  type: string;
+  schema: Record<string, unknown> | null;
+  contexts: string[];
+  actions: string[];
+};
+
+export type SchemaExport = { types: TypeInfo[] };
+
+export function exportSchemaForLLM(): SchemaExport {
+  const types = getRegisteredTypes();
+  return {
+    types: types.map((type) => {
+      const contexts = getContextsForType(type);
+      const schemaHandler = resolve(type, 'schema');
+      return {
+        type,
+        schema: schemaHandler ? (schemaHandler() as Record<string, unknown>) : null,
+        contexts: contexts.filter((c) => !c.startsWith('action:')),
+        actions: contexts.filter((c) => c.startsWith('action:')).map((c) => c.slice(7)),
+      };
+    }),
+  };
+}
+
+export async function describeTree(ctx: ActionCtx, data: unknown): Promise<string> {
+  const depth = Number((data as Record<string, unknown>)?.depth) || 3;
+  const path = ctx.node.$path;
+  const lines: string[] = [];
+
+  async function walk(p: string, indent: number, remaining: number): Promise<void> {
+    if (remaining <= 0) return;
+    const { items } = await ctx.store.getChildren(p);
+    items.sort((a, b) => a.$path.localeCompare(b.$path));
+    for (const child of items) {
+      lines.push(`${'  '.repeat(indent)}${basename(child.$path)} (${child.$type})`);
+      await walk(child.$path, indent + 1, remaining - 1);
+    }
+  }
+
+  lines.push(`${path} (${ctx.node.$type})`);
+  await walk(path, 1, depth);
+  return lines.join('\n');
+}
+
+/** @description Export all registered types with schemas, contexts, and actions for LLM consumption */
+register('t.llm', 'action:schema', () => exportSchemaForLLM());
+/** @description Describe the subtree under this node as indented text (depth-limited) */
+register('t.llm', 'action:describe', describeTree);

package/src/mods/llm/llm.test.ts

@@ -0,0 +1,109 @@
+import { createNode, type NodeData, register } from '#core';
+import { clearRegistry } from '#core/index.test';
+import { type ActionCtx, serverNodeHandle } from '#server/actions';
+import { createMemoryTree } from '#tree';
+import assert from 'node:assert/strict';
+import { beforeEach, describe, it } from 'node:test';
+import { describeTree, exportSchemaForLLM } from '.';
+
+function makeCtx(store: ReturnType<typeof createMemoryTree>, node: NodeData): ActionCtx {
+  const nc = serverNodeHandle(store);
+  return { node, store, signal: AbortSignal.timeout(5000), nc };
+}
+
+describe('exportSchemaForLLM', () => {
+  beforeEach(() => clearRegistry());
+
+  it('returns types with schemas', () => {
+    register('task', 'schema', () => ({
+      title: 'Task',
+      type: 'object',
+      properties: { status: { type: 'string', title: 'Status' } },
+    }));
+    register('task', 'react', () => 'component');
+    const result = exportSchemaForLLM();
+    assert.equal(result.types.length, 1);
+    const t = result.types[0];
+    assert.equal(t.type, 't.task');
+    assert.deepEqual((t.schema as any).title, 'Task');
+    assert.ok(t.contexts.includes('schema'));
+    assert.ok(t.contexts.includes('react'));
+  });
+
+  it('extracts actions from contexts', () => {
+    register('task', 'schema', () => ({ title: 'Task', type: 'object', properties: {} }));
+    register('task', 'action:complete', () => 'done');
+    register('task', 'action:assign', () => 'assigned');
+    const result = exportSchemaForLLM();
+    const t = result.types[0];
+    assert.deepEqual(t.actions.sort(), ['assign', 'complete']);
+    assert.ok(!t.contexts.includes('action:complete'));
+  });
+
+  it('returns null schema when no schema handler', () => {
+    register('widget', 'react', () => 'component');
+    const result = exportSchemaForLLM();
+    const t = result.types.find((x) => x.type === 't.widget')!;
+    assert.equal(t.schema, null);
+  });
+
+  it('returns empty types when registry is empty', () => {
+    const result = exportSchemaForLLM();
+    assert.deepEqual(result.types, []);
+  });
+});
+
+describe('describeTree', () => {
+  beforeEach(() => clearRegistry());
+
+  it('renders tree structure', async () => {
+    const store = createMemoryTree();
+    const root = createNode('/', 'root');
+    await store.set(root);
+    await store.set(createNode('/pages', 'dir'));
+    await store.set(createNode('/pages/main', 'page'));
+    await store.set(createNode('/users', 'dir'));
+
+    const text = await describeTree(makeCtx(store, root), { depth: 3 });
+    assert.ok(text.includes('/ (t.root)'));
+    assert.ok(text.includes('  pages (t.dir)'));
+    assert.ok(text.includes('    main (t.page)'));
+    assert.ok(text.includes('  users (t.dir)'));
+  });
+
+  it('respects depth limit', async () => {
+    const store = createMemoryTree();
+    const root = createNode('/', 'root');
+    await store.set(root);
+    await store.set(createNode('/a', 'dir'));
+    await store.set(createNode('/a/b', 'dir'));
+    await store.set(createNode('/a/b/c', 'item'));
+
+    const text = await describeTree(makeCtx(store, root), { depth: 1 });
+    assert.ok(text.includes('a (t.dir)'));
+    assert.ok(!text.includes('b (t.dir)'));
+  });
+
+  it('describes subtree from given node', async () => {
+    const store = createMemoryTree();
+    const pages = createNode('/pages', 'dir');
+    await store.set(pages);
+    await store.set(createNode('/pages/main', 'page'));
+
+    const text = await describeTree(makeCtx(store, pages), {});
+    assert.ok(text.startsWith('/pages (t.dir)'));
+    assert.ok(text.includes('main (t.page)'));
+  });
+
+  it('sorts children alphabetically', async () => {
+    const store = createMemoryTree();
+    const root = createNode('/', 'root');
+    await store.set(root);
+    await store.set(createNode('/zebra', 'animal'));
+    await store.set(createNode('/apple', 'fruit'));
+
+    const text = await describeTree(makeCtx(store, root), { depth: 1 });
+    const lines = text.split('\n');
+    assert.ok(lines.indexOf('  apple (t.fruit)') < lines.indexOf('  zebra (t.animal)'));
+  });
+});

package/src/mods/llm/server.ts

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

package/src/mods/servers.ts

@@ -0,0 +1,4 @@
+// Barrel: all core mod server registrations
+import './autostart/server';
+import './llm/server';
+import './treenity/server';