@treenity/core 3.0.0 → 3.0.1

package/src/mod/docs/14-mod-format.md

@@ -71,17 +71,13 @@ export default defineMod({
     const existing = await store.get('/sensors/weather');
     if (existing) return; // идемпотентно
 
-    await store.set({
-      $path: '/sensors/weather',
-      $type: 'weather.sensor',
+    await store.set(createNode('/sensors/weather', 'weather.sensor', {
       config: { $type: 'weather.config', location: 'Moscow', interval: 60 },
-    } as any);
+    }));
 
-    await store.set({
-      $path: '/sys/autostart/weather',
-      $type: 'ref',
+    await store.set(createNode('/sys/autostart/weather', 'ref', {
       $ref: '/sensors/weather',
-    } as any);
+    }));
   },
 
   onLoad: () => console.log('Weather mod loaded'),
@@ -302,3 +298,80 @@ buf.clear();                         // сбросить всё
 4. `expire()` — таймаут для зависших мутаций (сервер не ответил)
 
 **Почему хранится method + data:** `structuredClone()` стирает прототипы. Без сохранённой ссылки на метод rebase не может переиграть мутации.
+
+---
+
+## Views — register / Render / RenderContext
+
+Вьюхи НИКОГДА не рендерят дочерние компоненты напрямую. Всё через реестр:
+
+### Регистрация — типобезопасная
+
+```tsx
+import { register } from '@treenity/core/core';
+import type { View } from '@treenity/react/context';
+import { Render, RenderContext } from '@treenity/react/context';
+
+// View<T> — типизированный React-компонент: { value: T, ctx?, onChange? }
+const SensorView: View<WeatherSensor> = ({ value, ctx }) => {
+  const path = ctx!.node.$path;  // путь ноды — через ctx, НЕ из value
+  return <div>{value.location} — {value.temperature}°C</div>;
+};
+
+const SensorRow: View<WeatherSensor> = ({ value, ctx }) => { ... };
+
+// register принимает Class<T> — T пробрасывается в handler автоматически
+register(WeatherSensor, 'react', SensorView);          // detail view
+register(WeatherSensor, 'react:list', SensorRow);      // compact list view
+```
+
+**ЗАПРЕЩЕНО:**
+```tsx
+// WRONG — as any убивает типизацию, прячет ошибки:
+register('weather.sensor', 'react', SensorView as any);
+
+// WRONG — NodeData не смешивать с типами компонентов:
+function SensorRow({ value }: { value: NodeData & WeatherSensor }) { ... }
+
+// WRONG — путь из value (value — данные компонента, не нода):
+const path = value.$path;  // может не существовать!
+```
+
+### Рендер дочерних — ТОЛЬКО через `<Render>`
+
+```tsx
+// WRONG — хардкод, обходит реестр:
+{sensors.map(s => <SensorRow key={s.$path} sensor={s} />)}
+
+// RIGHT — через реестр, композабельно:
+<RenderContext name="react:list">
+  {sensors.map(s => <Render key={s.$path} value={s} />)}
+</RenderContext>
+```
+
+### Контексты
+
+| Контекст | Назначение |
+|----------|-----------|
+| `react` | default/detail view |
+| `react:list` | компактная карточка для списков |
+| `react:edit` | форма редактирования |
+
+Fallback автоматический: `react:list` → `react` → `default`.
+
+### Сигнатура view-функции
+
+```tsx
+// View<T> даёт: value: T, ctx: ViewCtx (node, path, execute), onChange
+const SensorView: View<WeatherSensor> = ({ value, ctx }) => {
+  // value — данные компонента (WeatherSensor fields)
+  // ctx!.node — полная NodeData (с $path, $type, $acl и т.д.)
+  // ctx!.execute(action, data) — вызов экшена
+};
+```
+
+### Почему это важно
+
+- **Композиция:** любой тип рендерит чужих детей, не зная их вьюх
+- **Переопределение:** зарегистрируй новый `react:list` для типа → все списки обновятся
+- **AI visibility:** реестр интроспектируемый, AI находит доступные вьюхи

package/src/mod/examples/ticker/service.ts

@@ -1,9 +1,8 @@
-import { getComp } from '#comp';
-import { type NodeData, register } from '#core';
+import { getComponent, type NodeData, register } from '#core';
 import { TickerConfig } from './types';
 
 register('ticker', 'service', async (node: NodeData, ctx) => {
-  const config = getComp(node, TickerConfig);
+  const config = getComponent(node, TickerConfig);
   const interval = (config?.intervalSec ?? 10) * 1000;
 
   const timer = setInterval(async () => {

package/src/mod/index.ts

@@ -3,7 +3,7 @@
 export { defineMod } from './types';
 export type { TreenityMod, ModManifest, ModState, LoadedMod } from './types';
 export { discoverMods } from './discover';
-export { sortByDependencies, loadMods, loadLocalMods, getLoadedMods, getMod, isModLoaded, clearModRegistry } from './loader';
+export { sortByDependencies, loadMods, loadLocalMods, loadAllMods, getLoadedMods, getMod, isModLoaded, clearModRegistry } from './loader';
 export type { LoadTarget, LoadResult } from './loader';
 export { OptimisticBuffer } from './optimistic';
 export type { PendingMutation } from './optimistic';

package/src/mod/loader.test.ts

@@ -1,6 +1,9 @@
 import assert from 'node:assert/strict';
 import { beforeEach, describe, it } from 'node:test';
-import { clearModRegistry, getLoadedMods, getMod, isModLoaded, loadMods, sortByDependencies } from './loader';
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { clearModRegistry, getLoadedMods, getMod, isModLoaded, loadLocalMods, loadMods, sortByDependencies } from './loader';
 import type { ModManifest } from './types';
 
 function m(name: string, deps?: string[]): ModManifest {
@@ -166,3 +169,52 @@ describe('loadMods', () => {
     assert.equal(isModLoaded('fail-mod'), false);
   });
 });
+
+describe('loadLocalMods', () => {
+  let tmpDir: string;
+
+  beforeEach(() => {
+    clearModRegistry();
+    tmpDir = mkdtempSync(join(tmpdir(), 'treenity-mods-'));
+  });
+
+  it('discovers mod with server.ts in a directory', async () => {
+    const modDir = join(tmpDir, 'my-mod');
+    mkdirSync(modDir);
+    writeFileSync(join(modDir, 'server.ts'), 'globalThis.__canary_server_loaded = true;');
+
+    const result = await loadLocalMods(tmpDir, 'server');
+    assert.deepEqual(result.loaded, ['my-mod']);
+    assert.equal(result.failed.length, 0);
+
+    rmSync(tmpDir, { recursive: true });
+  });
+
+  it('skips mod without matching entry file', async () => {
+    const modDir = join(tmpDir, 'server-only');
+    mkdirSync(modDir);
+    writeFileSync(join(modDir, 'server.ts'), '');
+
+    const result = await loadLocalMods(tmpDir, 'client');
+    assert.deepEqual(result.loaded, []);
+
+    rmSync(tmpDir, { recursive: true });
+  });
+
+  it('returns empty for nonexistent directory', async () => {
+    const result = await loadLocalMods('/tmp/no-such-dir-xyz-42', 'server');
+    assert.deepEqual(result.loaded, []);
+    assert.deepEqual(result.failed, []);
+  });
+
+  it('skips hidden directories', async () => {
+    const modDir = join(tmpDir, '.hidden-mod');
+    mkdirSync(modDir);
+    writeFileSync(join(modDir, 'server.ts'), '');
+
+    const result = await loadLocalMods(tmpDir, 'server');
+    assert.deepEqual(result.loaded, []);
+
+    rmSync(tmpDir, { recursive: true });
+  });
+});

package/src/mod/loader.ts

@@ -2,7 +2,7 @@
 
 import type { Tree } from '#tree';
 import { readdir, stat } from 'node:fs/promises';
-import { join } from 'node:path';
+import { join, resolve } from 'node:path';
 import { setCurrentMod } from './tracking';
 import type { LoadedMod, ModManifest, TreenityMod } from './types';
 
@@ -172,3 +172,36 @@ export async function loadLocalMods(modsDir: string, target: LoadTarget): Promis
 
   return result;
 }
+
+// ── Load all mods: internal + engine + project (CWD) ──
+
+export async function loadAllMods(target: LoadTarget, ...extraDirs: string[]): Promise<LoadResult> {
+  const internalDir = new URL('../mods', import.meta.url).pathname;
+  const engineDir = new URL('../../../mods', import.meta.url).pathname;
+
+  const dirs = [internalDir, engineDir];
+
+  // CWD/mods/ if different from engine mods
+  const projectDir = resolve('mods');
+  if (resolve(projectDir) !== resolve(engineDir)) dirs.push(projectDir);
+
+  dirs.push(...extraDirs);
+
+  const seen = new Set<string>();
+  const result: LoadResult = { loaded: [], failed: [] };
+
+  for (const dir of dirs) {
+    const abs = resolve(dir);
+    if (seen.has(abs)) continue;
+    seen.add(abs);
+
+    const r = await loadLocalMods(dir, target);
+    result.loaded.push(...r.loaded);
+    result.failed.push(...r.failed);
+  }
+
+  if (result.failed.length) console.error('failed mods:', result.failed.map(f => `${f.name}: ${f.error.message}`).join(', '));
+  console.log(`mods: ${result.loaded.join(', ')}`);
+
+  return result;
+}

package/src/mods/clients.ts

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

package/src/mods/llm/index.ts

@@ -32,7 +32,7 @@ export function exportSchemaForLLM(): SchemaExport {
 }
 
 export async function describeTree(ctx: ActionCtx, data: unknown): Promise<string> {
-  const { depth = 3 } = (data as { depth?: number }) ?? {};
+  const depth = Number((data as Record<string, unknown>)?.depth) || 3;
   const path = ctx.node.$path;
   const lines: string[] = [];
 

package/src/mods/servers.ts

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

package/src/mods/treenity/builtins.ts

@@ -0,0 +1,21 @@
+// Core built-in types — registered so validation (Write-Barrier) accepts them.
+// Convention: no dot = core built-in (see Type Naming Convention in CLAUDE.md)
+
+import { normalizeType, register } from '#core';
+
+const builtins = [
+  'dir', 'root', 'ref', 'user', 'type', 'mount-point', 'session',
+];
+
+export function registerBuiltins() {
+  for (const type of builtins) {
+    register(type, 'schema', () => ({
+      $id: normalizeType(type),
+      type: 'object' as const,
+      title: type,
+      properties: {},
+    }));
+  }
+}
+
+registerBuiltins();

package/src/mods/treenity/logs.ts

@@ -0,0 +1,26 @@
+// t.logs — unified log buffer, queryable via actions + MCP
+
+import { registerType } from '#comp';
+import { interceptConsole, logStats, queryLogs, type LogLevel } from '#log';
+
+interceptConsole();
+
+/** @description Server log buffer — query, grep, filter by level */
+export class Logs {
+  /** @description Query log buffer with grep, level filter, head/tail */
+  async query(data: {
+    /** Regex pattern to filter messages */ grep?: string;
+    /** Log level(s) to include */ level?: LogLevel | LogLevel[];
+    /** Return first N entries */ head?: number;
+    /** Return last N entries */ tail?: number;
+  }) {
+    return queryLogs(data);
+  }
+
+  /** @description Buffer stats: buffered count, total ever, max capacity */
+  async stats() {
+    return logStats();
+  }
+}
+
+registerType('t.logs', Logs);

package/src/mods/treenity/seed.ts

@@ -1,14 +1,9 @@
-import { type NodeData, R, S } from '@treenity/core/core';
+import { type NodeData, R, S } from '@treenity/core';
 import { registerPrefab } from '@treenity/core/mod';
 
+// Universal infra — works with any storage backend (FS, memory, Mongo)
 registerPrefab('core', 'seed', [
   { $path: 'sys', $type: 'treenity.system' },
-  { $path: 'auth', $type: 'dir' },
-  { $path: 'auth/users', $type: 'mount-point',
-    connection: { $type: 'connection', db: 'treenity', collection: 'users' },
-    mount: { $type: 't.mount.mongo' },
-    $acl: [{ g: 'authenticated', p: R | S }, { g: 'public', p: 0 }],
-  },
   { $path: 'sys/types', $type: 'mount-point',
     mount: { $type: 't.mount.types' },
     $acl: [{ g: 'public', p: R }],
@@ -17,40 +12,47 @@ registerPrefab('core', 'seed', [
     mount: { $type: 't.mount.mods' },
     $acl: [{ g: 'public', p: R }],
   },
-  { $path: 'auth/sessions', $type: 'mount-point',
-    connection: { $type: 'connection', db: 'treenity', collection: 'sessions' },
-    mount: { $type: 't.mount.mongo' },
-  },
-  { $path: 'mnt', $type: 'dir' },
-  { $path: 'mnt/orders', $type: 't.mount.mongo',
-    connection: { $type: 'connection', db: 'treenity', collection: 'orders' },
+  { $path: 'sys/mcp', $type: 'mcp.server', port: 0 },
+  { $path: 'sys/autostart', $type: 'autostart' },
+  { $path: '/sys/autostart/mcp', $type: 'ref', $ref: '/sys/mcp' },
+  { $path: 'proc', $type: 'mount-point',
+    mount: { $type: 't.mount.memory' },
+    $acl: [{ g: 'public', p: R }],
   },
-  { $path: 'entities', $type: 'dir' },
+  { $path: 'llm', $type: 't.llm' },
   { $path: 'demo', $type: 'dir',
     metadata: { $type: 'metadata', title: 'Demo Node', description: 'Try calling actions' },
     status: { $type: 'status', value: 'draft' },
     counter: { $type: 'counter', count: 0 },
   },
-  { $path: 'llm', $type: 't.llm' },
-  { $path: 'sys/mcp', $type: 'mcp.server', port: 0 },
   { $path: 'demo/sensors', $type: 'examples.demo.sensor',
     mount: { $type: 't.mount.memory' },
   },
+  { $path: '/sys/autostart/sensors', $type: 'ref', $ref: '/demo/sensors' },
   { $path: 'sys/claude-search', $type: 'claude-search' },
-  { $path: 'proc', $type: 'mount-point',
-    mount: { $type: 't.mount.memory' },
-    $acl: [{ g: 'public', p: R }],
-  },
-  { $path: 'sys/autostart', $type: 'autostart' },
-  { $path: '/sys/autostart/mcp', $type: 'ref', $ref: '/sys/mcp' },
   { $path: '/sys/autostart/claude-search', $type: 'ref', $ref: '/sys/claude-search' },
-  { $path: '/sys/autostart/sensors', $type: 'ref', $ref: '/demo/sensors' },
 ] as NodeData[], (nodes) => {
-  // MCP port from env
   const mcpPort = Number(process.env.MCP_PORT) || 3212;
-  let result = nodes.map(n =>
+  return nodes.map(n =>
     n.$path === 'sys/mcp' ? { ...n, port: mcpPort } : n,
   );
-
-  return result;
 }, { tier: 'core' });
+
+// Mongo-dependent infra — auth, orders, entities
+registerPrefab('mongo', 'seed', [
+  { $path: 'auth', $type: 'dir' },
+  { $path: 'auth/users', $type: 'mount-point',
+    connection: { $type: 'connection', db: 'treenity', collection: 'users' },
+    mount: { $type: 't.mount.mongo' },
+    $acl: [{ g: 'authenticated', p: R | S }, { g: 'public', p: 0 }],
+  },
+  { $path: 'auth/sessions', $type: 'mount-point',
+    connection: { $type: 'connection', db: 'treenity', collection: 'sessions' },
+    mount: { $type: 't.mount.mongo' },
+  },
+  { $path: 'mnt', $type: 'dir' },
+  { $path: 'mnt/orders', $type: 't.mount.mongo',
+    connection: { $type: 'connection', db: 'treenity', collection: 'orders' },
+  },
+  { $path: 'entities', $type: 'dir' },
+] as NodeData[]);

package/src/mods/treenity/server.ts

@@ -1,4 +1,6 @@
+import './builtins';
 import './system';
 import './mod-type';
 import './agent-port';
+import './logs';
 import './seed';

package/src/mods/uix/client.ts

@@ -5,7 +5,7 @@ import { onResolveMiss, register, unregister } from '#core';
 import { createInflight } from '#tree/inflight';
 import * as cache from '@treenity/react/cache';
 import { tree } from '@treenity/react/client';
-import { SystemFallbackView } from '@treenity/react/context';
+import { UixNoView } from '@treenity/react/context';
 import React from 'react';
 import { compileComponent, invalidateCache } from './compile';
 
@@ -55,7 +55,7 @@ register('uix.view', 'react', UixView);
 const dedup = createInflight<void>();
 
 // Watch a type node for future view creation (e.g. AI agent saves view.source via MCP).
-// When the node changes and gains view.source, swap SystemFallbackView for the real view.
+// When the node changes and gains view.source, swap UixNoView for the real view.
 const watched = new Set<string>();
 
 function watchTypeNode(type: string, typePath: string) {
@@ -86,7 +86,7 @@ function watchTypeNode(type: string, typePath: string) {
 onResolveMiss('react', (type) => {
   // Built-in types (no dot) never have UIX views — avoid contaminating tRPC batches
   if (!type.includes('.')) {
-    register(type, 'react', SystemFallbackView);
+    register(type, 'react', UixNoView);
     return;
   }
 
@@ -98,7 +98,7 @@ onResolveMiss('react', (type) => {
     const source = (typeNode as any)?.view?.source;
 
     if (!source || typeof source !== 'string') {
-      register(type, 'react', SystemFallbackView);
+      register(type, 'react', UixNoView);
       // Watch for future view creation (e.g. AI agent saves view.source later)
       watchTypeNode(type, typePath);
       return;

package/src/mods/uix/compile.ts

@@ -2,8 +2,8 @@
 // Turns raw JSX/TSX code string into a React component
 
 import { register } from '#core';
-import { Render, RenderContext, RenderField } from '@treenity/react/context';
-import { useChildren, usePath } from '@treenity/react/hooks';
+import { Render, RenderContext, RenderField, viewCtx } from '@treenity/react/context';
+import { execute, useChildren, usePath } from '@treenity/react/hooks';
 import React from 'react';
 import { compileJSX } from './jsx-parser';
 
@@ -22,6 +22,8 @@ const SCOPE: Record<string, unknown> = {
   RenderField,
   usePath,
   useChildren,
+  execute,
+  viewCtx,
 };
 
 const cache = new Map<string, React.FC<any>>();

package/src/schema/_test-fixture.ts

@@ -0,0 +1,12 @@
+// Test fixture for extract-schemas.test.ts — provides Autostart class after monorepo split.
+// The real Autostart moved to mods/autostart/ (outside core/src/), so tests use this stub.
+
+export class Autostart {
+  /** Start a service at given path */
+  start(data: {
+    /** service to start */
+    path: string;
+  }) {}
+
+  stop(data: { path: string }) {}
+}

package/src/schema/generated/ai.agent.json

@@ -0,0 +1,133 @@
+{
+  "$id": "ai.agent",
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "type": "object",
+  "title": "AI Agent — autonomous worker node at /agents/{name}\nLLM config (model, systemPrompt, sessionId) lives in named metatron.config component.\nWork creates metatron.task nodes under /agents/{name}/tasks/.",
+  "properties": {
+    "role": {
+      "type": "string",
+      "title": "Open-ended role string. Guardian policies keyed by role.",
+      "default": "qa"
+    },
+    "status": {
+      "type": "string",
+      "enum": [
+        "idle",
+        "working",
+        "blocked",
+        "error",
+        "offline"
+      ],
+      "default": "offline"
+    },
+    "currentTask": {
+      "type": "string",
+      "title": "Path to current board.task being worked on",
+      "default": ""
+    },
+    "taskRef": {
+      "type": "string",
+      "title": "Path to current metatron.task (live log)",
+      "default": ""
+    },
+    "lastRunAt": {
+      "type": "number",
+      "default": 0
+    },
+    "totalTokens": {
+      "type": "number",
+      "title": "Total tokens used across all tasks",
+      "default": 0
+    }
+  },
+  "required": [
+    "role",
+    "status",
+    "currentTask",
+    "taskRef",
+    "lastRunAt",
+    "totalTokens"
+  ],
+  "methods": {
+    "online": {
+      "description": "Bring agent online",
+      "arguments": []
+    },
+    "offline": {
+      "description": "Take agent offline",
+      "arguments": []
+    },
+    "assign": {
+      "description": "Assign a board task to this agent",
+      "arguments": [
+        {
+          "name": "data",
+          "type": "object",
+          "properties": {
+            "task": {
+              "type": "string",
+              "title": "Path to board.task"
+            }
+          },
+          "required": [
+            "task"
+          ]
+        }
+      ]
+    },
+    "complete": {
+      "description": "Agent finished current task",
+      "arguments": []
+    },
+    "block": {
+      "description": "Agent is blocked",
+      "arguments": [
+        {
+          "name": "data",
+          "anyOf": [
+            {},
+            {
+              "type": "object",
+              "properties": {
+                "reason": {
+                  "anyOf": [
+                    {},
+                    {
+                      "type": "string"
+                    }
+                  ],
+                  "title": "Reason"
+                }
+              }
+            }
+          ]
+        }
+      ]
+    },
+    "fail": {
+      "description": "Agent hit an error",
+      "arguments": [
+        {
+          "name": "data",
+          "anyOf": [
+            {},
+            {
+              "type": "object",
+              "properties": {
+                "error": {
+                  "anyOf": [
+                    {},
+                    {
+                      "type": "string"
+                    }
+                  ],
+                  "title": "Error message"
+                }
+              }
+            }
+          ]
+        }
+      ]
+    }
+  }
+}