@astrale-os/cli 1.0.0-beta.4 → 1.0.0-beta.6

package/studio/server/introspect/schema-refs.test.ts

@@ -1,100 +1,55 @@
-import { describe, expect, test } from 'bun:test'
+import { expect, test } from 'bun:test'
 
-import type { IrInterface, StudioSchemaBundle } from '../../shared/types'
+import type { StudioSchemaBundle } from '../../shared/types'
 
 import { schemaRefs } from './schema-refs'
 
-function importedInterface(
-  name: string,
-  origin: string,
-  properties: string[] = [],
-  methods: string[] = [],
-): IrInterface {
-  return {
-    type: 'interface',
-    name,
-    origin,
-    ref: { origin, kind: 'interface', name },
-    properties: Object.fromEntries(properties.map((property) => [property, { type: 'string' }])),
-    methods: Object.fromEntries(
-      methods.map((method) => [
-        method,
-        {
-          name: method,
-          params: {},
-          returns: {},
-          static: false,
-          inheritance: 'default',
-        },
-      ]),
-    ),
+test('enumerates local and exact imported Class anchors without collapsing homonyms', () => {
+  const method = {
+    name: 'rename',
+    params: {},
+    returns: {},
+    static: false,
+    inheritance: 'default' as const,
   }
-}
-
-function bundleWithImports(
-  exact: NonNullable<StudioSchemaBundle['ir']>['importedInterfacesByKey'],
-  legacy: Record<string, IrInterface>,
-): StudioSchemaBundle {
-  return {
+  const bundle = {
     ir: {
+      version: 'v1',
       domain: 'root.example.dev',
-      interfaces: {},
-      classes: {},
+      classes: {
+        Document: {
+          type: 'node',
+          name: 'Document',
+          properties: { title: { type: 'string' } },
+          methods: { rename: method },
+        },
+      },
       functions: {},
-      ...(exact === undefined ? {} : { importedInterfacesByKey: exact }),
-    },
-    importedInterfaces: legacy,
-  } as unknown as StudioSchemaBundle
-}
-
-describe('schema refs for imported interfaces', () => {
-  test('enumerates every exact homonym without selecting a name-keyed winner', () => {
-    const refs = schemaRefs(
-      bundleWithImports(
-        {
-          'directory.example.dev:interface.Named': importedInterface(
-            'Named',
-            'directory.example.dev',
-            ['directoryName'],
-          ),
-          'people.example.dev:interface.Named': importedInterface(
-            'Named',
-            'people.example.dev',
-            [],
-            ['rename'],
-          ),
+      importsByKey: {},
+      importedClassesByKey: {
+        'directory.example.dev:class.Named': {
+          type: 'node',
+          name: 'Named',
+          properties: { directoryName: { type: 'string' } },
+          methods: {},
         },
-        {
-          Named: importedInterface('Named', 'legacy.invalid', ['legacyOnly']),
+        'people.example.dev:class.Named': {
+          type: 'node',
+          name: 'Named',
+          properties: {},
+          methods: { rename: method },
         },
-      ),
-    )
-
-    expect(refs).toContain('interface.directory.example.dev:interface.Named')
-    expect(refs).toContain('interface.directory.example.dev:interface.Named.property.directoryName')
-    expect(refs).toContain('interface.people.example.dev:interface.Named.method.rename')
-    expect(refs).not.toContain('interface.Named')
-    expect(refs).not.toContain('interface.Named.property.legacyOnly')
-  })
-
-  test('uses the name-keyed imported interface only when the exact index is absent', () => {
-    expect(
-      schemaRefs(
-        bundleWithImports(undefined, {
-          Named: importedInterface('Named', 'legacy.example.dev', ['name']),
-        }),
-      ),
-    ).toEqual(['interface.Named', 'interface.Named.property.name'])
+      },
+    },
+  } as unknown as StudioSchemaBundle
 
-    expect(
-      schemaRefs(
-        bundleWithImports(
-          {},
-          {
-            Named: importedInterface('Named', 'legacy.example.dev', ['name']),
-          },
-        ),
-      ),
-    ).toEqual([])
-  })
+  expect(schemaRefs(bundle)).toEqual([
+    'class.Document',
+    'class.Document.property.title',
+    'class.Document.method.rename',
+    'class.directory.example.dev:class.Named',
+    'class.directory.example.dev:class.Named.property.directoryName',
+    'class.people.example.dev:class.Named',
+    'class.people.example.dev:class.Named.method.rename',
+  ])
 })

package/studio/server/introspect/schema-refs.ts

@@ -1,17 +1,6 @@
 import type { StudioSchemaBundle } from '../../shared/types'
 
-/**
- * schema-refs.ts — enumerate every SCHEMA anchor ref a bundle can target, derived
- * from the IR (the authority), NOT from `overlay.sourceSpans`.
- *
- * Source spans are a best-effort ts-morph source-location index: they cover only
- * locally-authored members and only the declaration helpers the parser recognises.
- * Using their keys as the set of "valid" targets falsely orphans real, commentable
- * targets — most notably INHERITED members surfaced in the detail pane's Inherited
- * section (kernel mixins / cross-domain interfaces, e.g. `interface.Named.property.name`),
- * which live in another package and so have no local span. This walks the IR
- * instead, mirroring exactly the refs the detail pane stamps.
- */
+/** Enumerate every schema anchor represented by the admitted render IR. */
 export function schemaRefs(bundle: StudioSchemaBundle): string[] {
   const ir = bundle.ir
   if (!ir) return []
@@ -22,46 +11,22 @@ export function schemaRefs(bundle: StudioSchemaBundle): string[] {
     methods: Record<string, unknown> | undefined,
   ) => {
     refs.add(base)
-    for (const p of Object.keys(properties ?? {})) refs.add(`${base}.property.${p}`)
-    for (const m of Object.keys(methods ?? {})) refs.add(`${base}.method.${m}`)
+    for (const property of Object.keys(properties ?? {})) refs.add(`${base}.property.${property}`)
+    for (const method of Object.keys(methods ?? {})) refs.add(`${base}.method.${method}`)
   }
 
-  for (const [name, iface] of Object.entries(ir.interfaces))
-    addMember(`interface.${name}`, iface.properties, iface.methods)
-
-  for (const [name, cls] of Object.entries(ir.classes)) {
-    const ns = cls.type === 'edge' ? 'edge' : 'class'
-    addMember(`${ns}.${name}`, cls.properties, cls.methods)
-    if (cls.type === 'edge')
-      for (const ep of cls.endpoints ?? [])
-        if (ep.name) refs.add(`edge.${name}.endpoint.${ep.name}`)
-  }
-
-  for (const name of Object.keys(ir.functions ?? {})) refs.add(`function.${name}`)
-
-  // Imported interfaces (kernel mixins + cross-domain) are rendered — and so are
-  // commentable — in the Inherited section, keyed under the `interface.` namespace.
-  // Canonical bundles retain every exact `(origin, kind, name)` identity. Iterate
-  // all of them: a short-name map must never pick one homonym by traversal order.
-  // The name-keyed bundle field remains a legacy-only fallback.
-  if (ir.importedInterfacesByKey !== undefined) {
-    for (const [key, iface] of Object.entries(ir.importedInterfacesByKey)) {
-      const anchor = importedInterfaceAnchor(key)
-      if (anchor) addMember(anchor, iface.properties, iface.methods)
+  for (const [name, definition] of Object.entries(ir.classes)) {
+    const namespace = definition.type === 'edge' ? 'edge' : 'class'
+    addMember(`${namespace}.${name}`, definition.properties, definition.methods)
+    if (definition.type === 'edge') {
+      for (const endpoint of definition.endpoints ?? []) {
+        if (endpoint.name) refs.add(`edge.${name}.endpoint.${endpoint.name}`)
+      }
     }
-  } else {
-    for (const [name, iface] of Object.entries(bundle.importedInterfaces ?? {}))
-      addMember(`interface.${name}`, iface.properties, iface.methods)
   }
-
+  for (const name of Object.keys(ir.functions)) refs.add(`function.${name}`)
+  for (const [key, definition] of Object.entries(ir.importedClassesByKey)) {
+    addMember(`class.${key}`, definition.properties, definition.methods)
+  }
   return [...refs]
 }
-
-function importedInterfaceAnchor(key: string): string | null {
-  const separator = key.lastIndexOf(':')
-  if (separator <= 0) return null
-  const ref = key.slice(separator + 1)
-  if (!ref.startsWith('interface.')) return null
-  const name = ref.slice('interface.'.length)
-  return /^[A-Za-z_$][\w$]*$/.test(name) ? `interface.${key}` : null
-}