@treenity/core 1.0.48 → 3.0.0

package/src/mods/uix/verify.ts

@@ -0,0 +1,68 @@
+// UIX View Verification — server-safe compile check (no React dependency)
+// Used by MCP to let LLMs verify that created views compile correctly
+
+import { compileJSX } from './jsx-parser';
+
+// Mirrors prepareCode from compile.ts but kept here to avoid React imports
+function prepareCode(code: string): { body: string; exportName: string | null } {
+  const lines = code.split('\n');
+  const body: string[] = [];
+  let exportName: string | null = null;
+
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (trimmed.startsWith('import ')) continue;
+
+    if (trimmed.startsWith('export default ')) {
+      const rest = trimmed.slice('export default '.length).trim();
+      const declMatch = rest.match(/^(function|class)\s+(\w+)/);
+      if (declMatch) {
+        exportName = declMatch[2];
+        body.push(line.replace('export default ', ''));
+      } else {
+        exportName = rest.replace(/;$/, '').trim();
+      }
+      continue;
+    }
+
+    if (trimmed.startsWith('export ')) {
+      body.push(line.replace('export ', ''));
+      continue;
+    }
+
+    body.push(line);
+  }
+
+  return { body: body.join('\n'), exportName };
+}
+
+// Scope parameter names that will be available at runtime
+const SCOPE_KEYS = [
+  'React', 'h', 'Fragment',
+  'useState', 'useEffect', 'useMemo', 'useCallback', 'useRef',
+  'Render', 'RenderContext', 'RenderField',
+  'usePath', 'useChildren',
+  'uix',
+];
+
+export function verifyViewSource(source: string): { ok: true } | { ok: false; error: string } {
+  try {
+    const { body, exportName } = prepareCode(source);
+    const jsCode = compileJSX(body);
+
+    const fnBody = exportName
+      ? `${jsCode}\nreturn ${exportName};`
+      : `${jsCode}\nreturn null;`;
+
+    // Syntax check only — new Function parses but we don't execute
+    new Function(...SCOPE_KEYS, fnBody);
+
+    if (!exportName) {
+      return { ok: false, error: 'No export default found. Use `export default function ViewName(...)` or `export default ViewName`.' };
+    }
+
+    return { ok: true };
+  } catch (err: any) {
+    return { ok: false, error: err.message };
+  }
+}

package/src/schema/CLAUDE.md

@@ -0,0 +1,13 @@
+## schema
+JSON Schema generation and loading for registerComp/defineComponent classes.
+
+### Файлы
+- extract-schemas.ts — CLI: AST walk via TypeScript compiler API → JSON Schema per class, writes to generated/
+- load.ts — loadSchemas(): reads generated/*.json, registers each as register($id, 'schema', () => schema)
+- types.ts — PropertySchema, TypeSchema — shared types for SchemaForm/NodeEditor
+- generated/ — auto-generated JSON schemas (git-ignored, run extract-schemas.ts to rebuild)
+
+### Конвенции
+- Run `tsx src/schema/extract-schemas.ts` to regenerate after component class changes
+- JSDoc on class → schema title; @format/@description on properties → schema annotations
+- load.ts auto-executes on import (call loadSchemas() or just import the file)

package/src/schema/catalog.ts

@@ -0,0 +1,101 @@
+// TypeCatalog — pure registry-based type discovery
+// No store deps, only core registry. Usable from MCP, services, LLM, tests.
+
+import { getRegisteredTypes, resolve } from '#core';
+
+export type CatalogEntry = {
+  name: string;
+  title?: string;
+  properties: string[];
+  actions: string[];
+};
+
+export type TypeDescription = {
+  name: string;
+  title?: string;
+  properties: Record<string, unknown>;
+  methods?: Record<string, unknown>;
+  references: string[];
+  referencedBy: string[];
+};
+
+export class TypeCatalog {
+  /** List all registered types with title, property names, action names */
+  list(): CatalogEntry[] {
+    return getRegisteredTypes('schema').map(name => {
+      const schema = (resolve(name, 'schema') as any)?.();
+      return {
+        name,
+        title: schema?.title,
+        properties: Object.keys(schema?.properties ?? {}),
+        actions: Object.keys(schema?.methods ?? {}),
+      };
+    });
+  }
+
+  /** Full schema + bidirectional cross-references */
+  describe(typeName: string): TypeDescription | null {
+    const schema = (resolve(typeName, 'schema') as any)?.();
+    if (!schema) return null;
+
+    const references: string[] = [];
+    const referencedBy: string[] = [];
+
+    for (const [, prop] of Object.entries(schema.properties ?? {}) as [string, any][]) {
+      if (prop.refType && !references.includes(prop.refType)) references.push(prop.refType);
+    }
+
+    for (const otherName of getRegisteredTypes('schema')) {
+      if (otherName === typeName) continue;
+      const other = (resolve(otherName, 'schema') as any)?.();
+      if (!other?.properties) continue;
+      for (const [, prop] of Object.entries(other.properties) as [string, any][]) {
+        if (prop.refType === typeName) { referencedBy.push(otherName); break; }
+      }
+    }
+
+    return {
+      name: typeName,
+      ...schema,
+      ...(references.length ? { references } : {}),
+      ...(referencedBy.length ? { referencedBy } : {}),
+    };
+  }
+
+  /** Search types by keyword across names, titles, props, actions, action args */
+  search(query: string): CatalogEntry[] {
+    const q = query.toLowerCase();
+    const matches: CatalogEntry[] = [];
+
+    for (const name of getRegisteredTypes('schema')) {
+      const schema = (resolve(name, 'schema') as any)?.();
+      const methods = Object.entries(schema?.methods ?? {}) as [string, any][];
+      const props = Object.entries(schema?.properties ?? {}) as [string, any][];
+      const haystack = [
+        name,
+        schema?.title ?? '',
+        schema?.description ?? '',
+        ...props.flatMap(([k, v]) => [k, v.title ?? '', v.description ?? '', v.format ?? '', v.refType ?? '']),
+        ...methods.flatMap(([k, m]) => [
+          k, m.title ?? '', m.description ?? '',
+          ...(m.arguments ?? []).flatMap((a: any) => [
+            a.name ?? '',
+            ...Object.keys(a.properties ?? {}),
+            ...Object.values(a.properties ?? {}).map((p: any) => p.description ?? ''),
+          ]),
+        ]),
+      ].join(' ').toLowerCase();
+
+      if (haystack.includes(q)) {
+        matches.push({
+          name,
+          title: schema?.title,
+          properties: Object.keys(schema?.properties ?? {}),
+          actions: Object.keys(schema?.methods ?? {}),
+        });
+      }
+    }
+
+    return matches;
+  }
+}

package/src/schema/extract-schemas.test.ts

@@ -0,0 +1,84 @@
+import assert from 'node:assert/strict';
+import { createRequire } from 'node:module';
+import * as path from 'node:path';
+import { describe, it } from 'node:test';
+import * as ts from 'typescript';
+import { collectJSDoc } from './extract-schemas';
+
+const require = createRequire(import.meta.url);
+
+function createProgram() {
+  const tsconfigPath = path.resolve(import.meta.dirname, '../../tsconfig.json');
+  const configFile = ts.readConfigFile(tsconfigPath, ts.sys.readFile);
+  if (configFile.error)
+    throw new Error(ts.flattenDiagnosticMessageText(configFile.error.messageText, '\n'));
+  const parsed = ts.parseJsonConfigFileContent(
+    configFile.config,
+    ts.sys,
+    path.dirname(tsconfigPath),
+  );
+  return ts.createProgram(parsed.fileNames, parsed.options);
+}
+
+describe('extract-schemas: JSDoc on method data-argument properties', () => {
+  let program: ts.Program;
+  let checker: ts.TypeChecker;
+
+  function findClass(name: string): ts.ClassDeclaration | undefined {
+    for (const sf of program.getSourceFiles()) {
+      if (sf.isDeclarationFile) continue;
+      let found: ts.ClassDeclaration | undefined;
+      sf.forEachChild(function visit(node) {
+        if (ts.isClassDeclaration(node) && node.name?.text === name) found = node;
+        node.forEachChild(visit);
+      });
+      if (found) return found;
+    }
+  }
+
+  function getMethodDataProperties(cls: ts.ClassDeclaration, methodName: string) {
+    for (const member of cls.members) {
+      if (!ts.isMethodDeclaration(member) || !ts.isIdentifier(member.name!) || member.name.text !== methodName) continue;
+      const sig = checker.getSignatureFromDeclaration(member);
+      if (!sig) continue;
+      const dataParam = sig.parameters[0];
+      if (!dataParam) continue;
+      return checker.getTypeOfSymbol(dataParam).getProperties();
+    }
+    return [];
+  }
+
+  it('collectJSDoc extracts inline JSDoc from type literal properties', () => {
+    program = createProgram();
+    checker = program.getTypeChecker();
+
+    const cls = findClass('Autostart');
+    assert.ok(cls, 'Autostart class not found');
+
+    const props = getMethodDataProperties(cls, 'start');
+    assert.ok(props.length > 0, 'start method should have data properties');
+
+    const pathProp = props.find(p => p.name === 'path');
+    assert.ok(pathProp, 'path property not found in start data');
+
+    const decl = pathProp.valueDeclaration;
+    assert.ok(decl, 'path property has no valueDeclaration');
+
+    const doc = collectJSDoc(decl);
+    assert.ok(
+      doc.title || doc.description,
+      `JSDoc not collected from inline property. Got: ${JSON.stringify(doc)}. ` +
+      `Node kind: ${ts.SyntaxKind[decl.kind]}`,
+    );
+  });
+
+  it('generated autostart schema has description on start.path argument', () => {
+    const schema = require('./generated/autostart.json');
+    const pathProp = schema.methods?.start?.arguments?.[0]?.properties?.path;
+    assert.ok(pathProp, 'path property missing from start method data argument');
+    assert.ok(
+      pathProp.title || pathProp.description,
+      `path should have title or description from JSDoc. Got: ${JSON.stringify(pathProp)}`,
+    );
+  });
+});