@treenity/core 1.0.48 → 3.0.0

package/src/server/mod-catalog.ts

@@ -0,0 +1,59 @@
+// Mod Catalog — synthesizes rich mod info from loader + tracking + TypeCatalog + prefabs
+// Pure functions, no store deps.
+
+import { getLoadedMods } from '#mod/loader';
+import { getModPrefabs, getRegisteredMods } from '#mod/prefab';
+import { getTypesForMod, inferModFromType } from '#mod/tracking';
+import type { ModState } from '#mod/types';
+import type { CatalogEntry } from '#schema/catalog';
+import { TypeCatalog } from '#schema/catalog';
+
+export type ModInfo = {
+  name: string;
+  state: ModState;
+  error?: string;
+  types: CatalogEntry[];
+  prefabs: string[];
+};
+
+const catalog = new TypeCatalog();
+
+/** Get rich info for a single mod (works for loader AND prefab-only mods) */
+export function getModInfo(name: string): ModInfo {
+  const loaded = getLoadedMods().find(m => m.name === name);
+  return buildModInfo(name, loaded?.state ?? 'loaded', loaded?.error);
+}
+
+/** Get info for all known mods (loader + prefab registry) */
+export function getAllMods(): ModInfo[] {
+  const names = new Set(getLoadedMods().map(m => m.name));
+  for (const n of getRegisteredMods()) names.add(n);
+  return [...names].map(n => getModInfo(n));
+}
+
+function buildModInfo(name: string, state: ModState, error?: Error): ModInfo {
+  // Tracked types first
+  const tracked = getTypesForMod(name);
+  const trackedSet = new Set(tracked);
+
+  // Convention fallback: catalog types whose inferred mod matches
+  const allTypes = catalog.list();
+  const conventionTypes = allTypes.filter(
+    e => !trackedSet.has(e.name) && inferModFromType(e.name) === name,
+  );
+
+  const types = [
+    ...allTypes.filter(e => trackedSet.has(e.name)),
+    ...conventionTypes,
+  ];
+
+  const prefabs = getModPrefabs(name).map(([n]) => n);
+
+  return {
+    name,
+    state,
+    ...(error ? { error: error.message } : {}),
+    types,
+    prefabs,
+  };
+}

package/src/server/mods-mount.ts

@@ -0,0 +1,179 @@
+// Treenity Mods Mount — Layer 4
+// Virtual read-only store exposing loaded mods as rich catalog nodes.
+// Sources: mod loader (all loaded mods) + tracking + TypeCatalog + prefab registry.
+//
+// Tree structure:
+//   /sys/mods/                           → dir (list all loaded mods)
+//   /sys/mods/{mod}                      → t.mod node (name, state, types, prefabs)
+//   /sys/mods/{mod}/types/               → dir (list type CatalogEntries)
+//   /sys/mods/{mod}/types/{typeName}     → CatalogEntry node
+//   /sys/mods/{mod}/prefabs/             → dir (list prefabs)
+//   /sys/mods/{mod}/prefabs/{name}/      → prefab root (dir)
+//   /sys/mods/{mod}/prefabs/{name}/{...} → prefab nodes
+
+import '#mods/treenity/mod-type';
+
+import { createNode, type NodeData } from '#core';
+import { getLoadedMods } from '#mod/loader';
+import { getModPrefabs, getPrefab, getRegisteredMods } from '#mod/prefab';
+import { paginate, type Tree } from '#tree';
+import { getModInfo } from './mod-catalog';
+
+type ParsedPath = {
+  mod?: string;
+  sub?: 'types' | 'prefabs';
+  name?: string;   // type name or prefab name
+  rest?: string;    // prefab sub-path
+};
+
+export function createModsStore(_backingStore: Tree, modsPath = '/sys/mods'): Tree {
+  // Union: loader registry + prefab registry (some mods have prefabs but aren't in loader, e.g. tests)
+  function allModNames(): Set<string> {
+    const names = new Set(getLoadedMods().map(m => m.name));
+    for (const n of getRegisteredMods()) names.add(n);
+    return names;
+  }
+
+  function parsePath(path: string): ParsedPath {
+    const rel = path.slice(modsPath.length);
+    if (!rel || rel === '/') return {};
+    const parts = rel.slice(1).split('/');
+
+    if (parts.length === 1) return { mod: parts[0] };
+
+    const sub = parts[1] as 'types' | 'prefabs';
+    if (sub !== 'types' && sub !== 'prefabs') return { mod: parts[0] };
+
+    if (parts.length === 2) return { mod: parts[0], sub };
+    const name = parts[2];
+
+    if (sub === 'types') return { mod: parts[0], sub, name };
+
+    // prefabs: may have deeper paths
+    const rest = parts.length > 3 ? parts.slice(3).join('/') : undefined;
+    return { mod: parts[0], sub: 'prefabs', name, rest };
+  }
+
+  return {
+    async get(path) {
+      const p = parsePath(path);
+
+      // /sys/mods
+      if (!p.mod) return createNode(path, 'dir');
+
+      if (!allModNames().has(p.mod)) return undefined;
+
+      // /sys/mods/{mod} → t.mod node
+      if (!p.sub) {
+        const info = getModInfo(p.mod);
+        return {
+          $path: path,
+          $type: 't.mod',
+          name: info.name,
+          state: info.state,
+          ...(info.error ? { error: info.error } : {}),
+          types: info.types.map(t => t.name),
+          prefabs: info.prefabs,
+        } as unknown as NodeData;
+      }
+
+      // /sys/mods/{mod}/types
+      if (p.sub === 'types' && !p.name) return createNode(path, 'dir');
+
+      // /sys/mods/{mod}/types/{typeName}
+      if (p.sub === 'types' && p.name) {
+        const info = getModInfo(p.mod);
+        const entry = info?.types.find(t => t.name === p.name);
+        if (!entry) return undefined;
+        return {
+          $path: path,
+          $type: 'type',
+          name: entry.name,
+          ...(entry.title ? { title: entry.title } : {}),
+          properties: entry.properties,
+          actions: entry.actions,
+        } as unknown as NodeData;
+      }
+
+      // /sys/mods/{mod}/prefabs
+      if (p.sub === 'prefabs' && !p.name) return createNode(path, 'dir');
+
+      // /sys/mods/{mod}/prefabs/{name}
+      const prefab = getPrefab(p.mod, p.name!);
+      if (!prefab) return undefined;
+
+      if (!p.rest) return createNode(path, 'dir');
+
+      // /sys/mods/{mod}/prefabs/{name}/{rest}
+      const found = prefab.nodes.find(n => {
+        const np = n.$path.startsWith('.') ? n.$path.slice(1) : n.$path;
+        const clean = np.startsWith('/') ? np.slice(1) : np;
+        return clean === p.rest;
+      });
+      return found ? { ...found, $path: path } : undefined;
+    },
+
+    async getChildren(path, opts) {
+      const p = parsePath(path);
+      const items: NodeData[] = [];
+
+      if (!p.mod) {
+        // List all known mods (loader + prefab registry)
+        for (const name of allModNames()) {
+          items.push(createNode(`${modsPath}/${name}`, 't.mod'));
+        }
+      } else if (!p.sub) {
+        // Mod children: /types + /prefabs (if non-empty)
+        const info = getModInfo(p.mod);
+        if (info) {
+          if (info.types.length > 0) items.push(createNode(`${path}/types`, 'dir'));
+          if (info.prefabs.length > 0) items.push(createNode(`${path}/prefabs`, 'dir'));
+        }
+      } else if (p.sub === 'types' && !p.name) {
+        // List types for mod
+        const info = getModInfo(p.mod);
+        if (info) {
+          for (const t of info.types) {
+            items.push({
+              $path: `${path}/${t.name}`,
+              $type: 'type',
+              name: t.name,
+              ...(t.title ? { title: t.title } : {}),
+              properties: t.properties,
+              actions: t.actions,
+            } as unknown as NodeData);
+          }
+        }
+      } else if (p.sub === 'prefabs' && !p.name) {
+        // List prefabs for mod
+        for (const [name] of getModPrefabs(p.mod)) {
+          items.push(createNode(`${path}/${name}`, 'dir'));
+        }
+      } else if (p.sub === 'prefabs' && p.name) {
+        // List prefab nodes (direct children only)
+        const prefab = getPrefab(p.mod, p.name);
+        if (prefab) {
+          for (const node of prefab.nodes) {
+            if (node.$path === '.' || node.$path.startsWith('/')) continue;
+            if (node.$path.includes('/')) continue;
+            items.push({ ...node, $path: `${path}/${node.$path}` });
+          }
+        }
+      }
+
+      return paginate(items, opts);
+    },
+
+    async set() {
+      throw new Error('Mods mount is read-only');
+    },
+
+    async remove() {
+      throw new Error('Mods mount is read-only');
+    },
+
+    async patch() {
+      throw new Error('Mods mount is read-only');
+    },
+  };
+}

package/src/server/mount-adapters.ts

@@ -0,0 +1,82 @@
+// Mount adapter registrations — type "mount" context handlers
+// Naming: t.mount.{name} — system infrastructure adapters
+
+import { createTrpcTransport } from '#client';
+import { getComponent, isComponent, type NodeData, register, resolve } from '#core';
+import { createMemoryTree, createOverlayTree, type Tree } from '#tree';
+import { createFsTree } from '#tree/fs';
+import { createRawFsStore } from '#tree/mimefs';
+import { createMongoTree } from '#tree/mongo';
+import { createQueryTree } from '#tree/query';
+import { createRepathTree } from '#tree/repath';
+import { createModsStore } from './mods-mount';
+import { createTypesStore } from './types-mount';
+
+export type MountAdapter = (config: NodeData, parentStore: Tree, ctx?: any, globalStore?: Tree) => Tree | Promise<Tree>;
+
+declare module '#core/context' {
+  interface ContextHandlers {
+    mount: MountAdapter;
+  }
+}
+
+register('t.mount.mongo', 'mount', async (config: NodeData) => {
+  const conn = getComponent<{ uri?: string; db?: string; collection?: string }>(config, 'connection');
+  if (!conn) throw new Error("t.mount.mongo requires 'connection' component");
+  const uri = conn.uri ?? process.env.MONGO_URI;
+  if (!uri) throw new Error('t.mount.mongo: no uri and MONGO_URI not set');
+  return createMongoTree(uri, conn.db ?? 'treenity', conn.collection ?? 'nodes');
+});
+
+// deps = parent store (used as backing for registry types)
+register('t.mount.types', 'mount', (_node, deps) => createTypesStore(deps));
+
+register('t.mount.mods', 'mount', (_node, deps) => createModsStore(deps));
+
+register('t.mount.memory', 'mount', () => createMemoryTree());
+
+register('t.mount.query', 'mount', (config: NodeData, parentStore, ctx, globalStore) => {
+  const query = getComponent<{ source: string; match: Record<string, unknown> }>(config, 'query');
+  if (!query?.source || !query?.match) throw new Error("t.mount.query requires 'query' component with source and match");
+  return createQueryTree({ source: query.source, match: query.match }, globalStore || parentStore);
+});
+
+register('t.mount.fs', 'mount', async (config: NodeData) => {
+  const root = config['root'] as string | undefined;
+  if (!root) throw new Error('t.mount.fs: root required');
+  return createFsTree(root);
+});
+
+register('t.mount.rawfs', 'mount', async (config: NodeData) => {
+  const root = config['root'] as string | undefined;
+  if (!root) throw new Error('t.mount.rawfs: root required');
+  return createRawFsStore(root);
+});
+
+// Federation: mount a remote Treenity instance's tree via tRPC.
+// connection.url = remote server, connection.path = remote subtree root (default '/'),
+// connection.token = auth token. Path translation handled by createRepathTree.
+register('t.mount.tree.trpc', 'mount', async (config: NodeData) => {
+  const conn = getComponent<{ url?: string; path?: string; token?: string }>(config, 'connection');
+  if (!conn?.url) throw new Error('t.mount.trpc: connection.url required');
+  const { tree } = createTrpcTransport({ url: conn.url, token: conn.token });
+  return createRepathTree(tree, config.$path, conn.path ?? '/');
+});
+
+register('t.mount.overlay', 'mount', async (config: NodeData, parentStore, ctx, globalStore) => {
+  const mount = getComponent<{ layers?: string[] }>(config, 't.mount.overlay', 'mount');
+  if (!mount?.layers?.length) throw new Error('t.mount.overlay: layers required');
+  const stores: Tree[] = [];
+  for (const name of mount.layers) {
+    const comp = config[name];
+    if (!isComponent(comp)) throw new Error(`t.mount.overlay: component "${name}" not found`);
+    const adapter = resolve(comp.$type, 'mount');
+    if (!adapter) throw new Error(`No mount adapter for "${comp.$type}"`);
+    // Overlay sub-adapters receive a component, not full node — they don't need $path
+    stores.push(await adapter(comp as NodeData, stores[0] ?? ({} as Tree), ctx, globalStore));
+  }
+  // First = lower (base), last = upper (writes go here)
+  let result = stores[0];
+  for (let i = 1; i < stores.length; i++) result = createOverlayTree(stores[i], result);
+  return result;
+});

package/src/server/mount.parametrized.test.ts

@@ -0,0 +1,52 @@
+import { createNode, register } from '#core';
+import { clearRegistry } from '#core/index.test';
+import { createMemoryTree, type Tree } from '#tree';
+import { createQueryTree } from '#tree/query';
+import assert from 'node:assert/strict';
+import { beforeEach, describe, it } from 'node:test';
+import { withMounts } from './mount';
+import './mount-adapters'; // ensure registrations
+
+describe('Parametrized Mounts', () => {
+  let rootStore: Tree;
+  let store: Tree;
+
+  beforeEach(() => {
+    clearRegistry();
+    // Direct registration for tests due to module caching issues
+    register('t.mount.query', 'mount', (config, parentStore) => {
+      const n = config as any;
+      const query = n['query'] as { source: string; match: Record<string, unknown> } | undefined;
+      return createQueryTree({ source: query!.source, match: query!.match }, parentStore);
+    });
+    rootStore = createMemoryTree();
+    store = withMounts(rootStore);
+  });
+
+  it('resolves parametrized mount correctly', async () => {
+    await store.set({ ...createNode('/', 'root') });
+    await store.set({ ...createNode('/users', 'folder') });
+    
+    // Flat data
+    await store.set({ ...createNode('/data/orders/1', 'order', { ownerId: 'alice' }) });
+    await store.set({ ...createNode('/data/orders/2', 'order', { ownerId: 'bob' }) });
+
+    // Parametrized mount point
+    await store.set({
+      ...createNode('/users/:userId/orders', 'folder', {}, {
+        mount: { $type: 't.mount.query' },
+        query: { $type: 'query', source: '/data/orders', match: { ownerId: ':userId' } } // the :userId should be bound
+      })
+    });
+
+    // Check virtual folder for alice
+    const aliceOrders = await store.getChildren('/users/alice/orders', { depth: 1 });
+    assert.equal(aliceOrders.items.length, 1);
+    assert.equal(aliceOrders.items[0].$path, '/data/orders/1');
+
+    // Check virtual folder for bob
+    const bobOrders = await store.getChildren('/users/bob/orders', { depth: 1 });
+    assert.equal(bobOrders.items.length, 1);
+    assert.equal(bobOrders.items[0].$path, '/data/orders/2');
+  });
+});

package/src/server/mount.query.test.ts

@@ -0,0 +1,127 @@
+import { createNode, register } from '#core';
+import { clearRegistry } from '#core/index.test';
+import { createMemoryTree, type Tree } from '#tree';
+import { createQueryTree } from '#tree/query';
+import assert from 'node:assert/strict';
+import { beforeEach, describe, it } from 'node:test';
+import { withMounts } from './mount';
+
+describe('Query Mount', () => {
+  let rootStore: Tree;
+
+  beforeEach(() => {
+    clearRegistry();
+    register('t.mount.query', 'mount', (config, parentStore) => {
+            const n = config as any;
+      const query = n['query'] as { source: string; match: Record<string, unknown> } | undefined;
+      return createQueryTree({ source: query!.source, match: query!.match }, parentStore);
+    });
+    rootStore = createMemoryTree();
+  });
+
+  it('filters children from source path', async () => {
+    await rootStore.set(createNode('/entities/orders/1', 'order', { status: 'new' }));
+    await rootStore.set(createNode('/entities/orders/2', 'order', { status: 'kitchen' }));
+    await rootStore.set(createNode('/entities/orders/3', 'order', { status: 'new' }));
+
+    await rootStore.set(
+      createNode('/workflows/new', 'folder', {}, {
+        mount: { $type: 't.mount.query' },
+        query: { $type: 'query', source: '/entities/orders', match: { status: 'new' } }
+      })
+    );
+
+    const ms = withMounts(rootStore);
+    
+    const children = await ms.getChildren('/workflows/new');
+    assert.equal(children.items.length, 2);
+    // They should have their original paths!
+    assert.deepEqual(children.items.map(n => n.$path).sort(), ['/entities/orders/1', '/entities/orders/3']);
+  });
+
+  it('get delegates to parent store (real paths)', async () => {
+    await rootStore.set(createNode('/entities/orders/1', 'order', { status: 'new' }));
+    await rootStore.set(
+      createNode('/workflows/new', 'folder', {}, {
+        mount: { $type: 't.mount.query' },
+        query: { $type: 'query', source: '/entities/orders', match: { status: 'new' } },
+      }),
+    );
+    const ms = withMounts(rootStore);
+
+    // Query mount delegates get to parent — real path works
+    const node = await ms.get('/entities/orders/1');
+    assert.equal(node?.$path, '/entities/orders/1');
+  });
+
+  it('mount config accessible via get', async () => {
+    await rootStore.set(
+      createNode('/workflows/new', 'folder', {}, {
+        mount: { $type: 't.mount.query' },
+        query: { $type: 'query', source: '/entities/orders', match: { status: 'new' } },
+      }),
+    );
+    const ms = withMounts(rootStore);
+
+    const node = await ms.get('/workflows/new');
+    assert.equal(node?.$type, 't.folder');
+  });
+
+  it('query mount with separate source dir excludes sibling mounts', async () => {
+    // Agent pattern: /agent/tasks holds real tasks,
+    // /agent/inbox and /agent/done are query mounts on /agent/tasks
+    await rootStore.set(createNode('/agent', 'config'));
+    await rootStore.set(createNode('/agent/tasks', 'dir'));
+    await rootStore.set(createNode('/agent/tasks/t1', 'task', { status: 'pending' }));
+    await rootStore.set(createNode('/agent/tasks/t2', 'task', { status: 'done' }));
+    await rootStore.set(createNode('/agent/tasks/t3', 'task', { status: 'pending' }));
+
+    await rootStore.set(createNode('/agent/inbox', 'mount-point', {}, {
+      mount: { $type: 't.mount.query' },
+      query: { $type: 'query', source: '/agent/tasks', match: { $type: 't.task', status: 'pending' } },
+    }));
+    await rootStore.set(createNode('/agent/done', 'mount-point', {}, {
+      mount: { $type: 't.mount.query' },
+      query: { $type: 'query', source: '/agent/tasks', match: { $type: 't.task', status: 'done' } },
+    }));
+
+    const ms = withMounts(rootStore);
+
+    const inbox = await ms.getChildren('/agent/inbox');
+    assert.equal(inbox.items.length, 2);
+    assert.ok(inbox.items.every(n => n.$type === 't.task' && n.status === 'pending'));
+
+    const done = await ms.getChildren('/agent/done');
+    assert.equal(done.items.length, 1);
+    assert.equal(done.items[0].$path, '/agent/tasks/t2');
+  });
+
+  it('circular source: mount-points excluded by sift filter', async () => {
+    // Regression: source=/parent where mount-points are children of /parent.
+    // Sift filter must exclude non-matching $type even with circular source.
+    await rootStore.set(createNode('/parent', 'config'));
+    await rootStore.set(createNode('/parent/t1', 'task', { status: 'pending' }));
+    await rootStore.set(createNode('/parent/t2', 'task', { status: 'done' }));
+
+    await rootStore.set(createNode('/parent/inbox', 'mount-point', {}, {
+      mount: { $type: 't.mount.query' },
+      query: { $type: 'query', source: '/parent', match: { $type: 't.task', status: 'pending' } },
+    }));
+    await rootStore.set(createNode('/parent/done', 'mount-point', {}, {
+      mount: { $type: 't.mount.query' },
+      query: { $type: 'query', source: '/parent', match: { $type: 't.task', status: 'done' } },
+    }));
+
+    const ms = withMounts(rootStore);
+
+    // inbox should only see pending tasks, not mount-points or done tasks
+    const inbox = await ms.getChildren('/parent/inbox');
+    assert.equal(inbox.items.length, 1);
+    assert.equal(inbox.items[0].$path, '/parent/t1');
+
+    // done should only see done tasks
+    const done = await ms.getChildren('/parent/done');
+    assert.equal(done.items.length, 1);
+    assert.equal(done.items[0].$path, '/parent/t2');
+  });
+});