@astrale-os/cli 1.0.0-beta.2 → 1.0.0-beta.20

package/studio/server/introspect/core-extractor.ts

@@ -1,139 +1,30 @@
-/**
- * core-extractor.ts — the Bun-executed island for a domain's CORE (genesis) data.
- * Spawned as a short-lived subprocess by runtime.ts (cwd = domain dir, so the
- * domain's own node_modules resolve @astrale-os/*). It imports the pure schema
- * entry and reads canonical V1 `schema.core` directly. Importing the composition
- * entry and discovering legacy `defineCore(...)` output is retained only as a
- * fallback.
- *
- *   bun core-extractor.ts <schemaIndexPath> <domainFile> <domainDir>
- *
- * Contract mirrors extractor.ts exactly: NEVER crash. A thrown error prints
- * { ok:false } and exits 0 — the driver treats it as a render state. A domain
- * with no core prints { ok:true, core:null }.
- *
- * NOTE: the `export {}` below marks this as a module so its top-level `domainDir`/
- * `main` are module-scoped (extractor.ts is a sibling script with the same names).
- *
- * className resolution: a core node's `def` is the runtime class-definition
- * object (shape `{ __kind, config }` — it carries NO name field). We resolve the
- * name by identity-matching `def` against the core's own `schema.classes` /
- * `schema.interfaces`, AND every `schema.imports[*]` group — imported kernel
- * classes like `Folder` ONLY resolve via the imports walk. `data` is passed
- * through as the author wrote it in `node(Class, {...})` (most readable form).
- */
-export {} // module marker — see header note
+/** Bun subprocess that projects canonical Core directly from the pure Schema entry. */
 import { isAbsolute, resolve } from 'node:path'
 
 import { findCanonicalDomainSchemaExport, projectCanonicalCore } from './canonical-schema'
 
-const domainDir = process.argv[4] ?? process.cwd()
-const resolveInput = (file: string | undefined): string | undefined =>
-  file && !isAbsolute(file) ? resolve(domainDir, file) : file
-const schemaFile = resolveInput(process.argv[2])
-const domainFile = resolveInput(process.argv[3])
+const projectRoot = process.argv[3] ?? process.cwd()
+const input = process.argv[2]
+const schemaFile = input && !isAbsolute(input) ? resolve(projectRoot, input) : input
 
-type AnyRec = Record<string, any>
-
-/** A defineCore() result: flat __nodes/__edges arrays + its schema + domain. */
-function looksLikeCore(v: any): boolean {
-  return (
-    !!v &&
-    typeof v === 'object' &&
-    Array.isArray(v.__nodes) &&
-    Array.isArray(v.__edges) &&
-    !!v.schema &&
-    typeof v.domain === 'string'
+async function main(): Promise<void> {
+  if (!schemaFile) throw new Error('core-extractor: missing <schemaPath>')
+  const exports = (await import(schemaFile)) as Record<string, unknown>
+  const schema = findCanonicalDomainSchemaExport(exports)
+  if (schema === null) throw new Error('Schema entry exports no canonical V1 DomainSchema.')
+  const core = projectCanonicalCore(schema)
+  process.stdout.write(
+    JSON.stringify({
+      ok: true,
+      core: core.nodes.length === 0 && core.edges.length === 0 ? null : core,
+    }),
   )
 }
 
-/** Find the Core object — wired as `domain.core`, exported directly, or by shape. */
-function findCore(mod: AnyRec): any {
-  const wired = mod?.domain?.core ?? mod?.default?.core ?? mod?.core
-  if (looksLikeCore(wired)) return wired
-  // export name varies per domain (GatewayCore / IntegrationCore / …) — scan by shape
-  for (const v of Object.values(mod ?? {})) {
-    if (looksLikeCore(v)) return v
-    if (v && typeof v === 'object' && looksLikeCore((v as AnyRec).core)) return (v as AnyRec).core
-  }
-  return null
-}
-
-/** Build def→className from the schema's own classes/interfaces + imported schemas. */
-function classNameMap(schema: AnyRec): Map<any, string> {
-  const m = new Map<any, string>()
-  const add = (group?: AnyRec) => {
-    for (const [name, def] of Object.entries(group ?? {})) if (def && !m.has(def)) m.set(def, name)
-  }
-  add(schema?.interfaces)
-  add(schema?.classes)
-  for (const imp of schema?.imports ?? []) {
-    add(imp?.interfaces)
-    add(imp?.classes)
-  }
-  return m
-}
-
-async function main() {
-  if (!schemaFile) throw new Error('core-extractor: missing <schemaIndexPath>')
-
-  // Current SDK roots embed genesis data in the canonical, portable schema.
-  // Do not import implementation.ts/domain.ts when that source of truth exists.
-  try {
-    const schemaModule: AnyRec = await import(schemaFile)
-    const canonical = findCanonicalDomainSchemaExport(schemaModule)
-    if (canonical) {
-      const core = projectCanonicalCore(canonical)
-      const empty = core.nodes.length === 0 && core.edges.length === 0
-      process.stdout.write(JSON.stringify({ ok: true, core: empty ? null : core }))
-      return
-    }
-  } catch {
-    // A legacy composition entry may still expose a valid defineCore result.
-  }
-
-  if (!domainFile) throw new Error('core-extractor: missing <domainFile> legacy fallback')
-  const mod: AnyRec = await import(domainFile)
-  const core = findCore(mod)
-  if (!core) {
-    process.stdout.write(JSON.stringify({ ok: true, core: null }))
-    return
-  }
-
-  const names = classNameMap(core.schema)
-  const nameOf = (def: any): string => names.get(def) ?? def?.config?.name ?? def?.name ?? '?'
-  // CorePath is a branded string; nested parents are objects with toString/valueOf,
-  // so String() is the correct universal coercion (never JSON.stringify a path).
-  const pathStr = (p: any): string => (p == null ? '' : String(p))
-  // An edge endpoint is a CorePath OR a SelfMarker ({ type:'core-self', __def }).
-  const endpoint = (e: any): string =>
-    e && typeof e === 'object' && (e.type === 'core-self' || e.__def)
-      ? `self(${nameOf(e.__def)})`
-      : pathStr(e)
-
-  const nodes = (core.__nodes ?? []).map((n: AnyRec) => ({
-    path: pathStr(n.path),
-    className: nameOf(n.def),
-    data: n.data ?? {},
-    ...(n.parent != null ? { parent: pathStr(n.parent) } : {}),
-  }))
-
-  const edges = (core.__edges ?? []).map((e: AnyRec) => ({
-    from: endpoint(e.from),
-    to: endpoint(e.to),
-    edgeName: nameOf(e.edge),
-    ...(e.data != null ? { data: e.data } : {}),
-  }))
-
-  process.stdout.write(JSON.stringify({ ok: true, core: { domain: core.domain, nodes, edges } }))
-}
-
-main().catch((err: any) => {
+main().catch((cause: unknown) => {
+  const error = cause instanceof Error ? cause : new Error(String(cause))
   process.stdout.write(
-    JSON.stringify({
-      ok: false,
-      error: { message: String(err?.message ?? err), stack: String(err?.stack ?? '') },
-    }),
+    JSON.stringify({ ok: false, error: { message: error.message, stack: error.stack ?? '' } }),
   )
   process.exit(0)
 })

package/studio/server/introspect/core.ts

@@ -1,6 +1,6 @@
 /**
  * core.ts — assembles a domain's StudioCore: the genesis node/edge graph
- * extracted from canonical `schema.core` (or legacy `defineCore` fallback), gated
+ * extracted from canonical `schema.core`, gated
  * on installed deps. Never throws; a failed import or a domain with no core both
  * become a well-formed (empty) render state.
  */
@@ -28,7 +28,6 @@ export async function buildCore(handle: DomainHandle): Promise<StudioCore> {
 
   const r = await coreExtract(
     handle.schemaIndex,
-    handle.domainFile,
     handle.root,
     readSettings(handle.root).introspectTimeoutMs,
   )

package/studio/server/introspect/diff.test.ts

@@ -7,22 +7,22 @@ import { diffSchemas, structuralStatusOf } from './diff'
 const callable = (returnsType = 'string'): IrFunction => ({
   name: 'inspect',
   input: { type: 'object', properties: {}, additionalProperties: false },
-  params: {},
   output: { mode: 'value', schema: { type: returnsType } },
-  returns: { type: returnsType },
-  static: true,
-  inheritance: 'default',
   auth: 'authenticated',
 })
 
 const schema = (functions: SchemaIR['functions']): SchemaIR => ({
   version: 'v1',
+  format: 'astrale.dsl',
   domain: 'example.test',
-  types: {},
-  interfaces: {},
   classes: {},
-  imports: {},
+  importsByKey: {},
+  importedClassesByKey: {},
   functions,
+  views: {},
+  policies: {},
+  dependencies: [],
+  core: {},
 })
 
 const withClass = (member: IrClass): SchemaIR => ({
@@ -63,6 +63,8 @@ describe('canonical standalone Function diffs', () => {
     const member = (required: string[], minLength: number): IrClass => ({
       type: 'node',
       name: 'Person',
+      origin: 'example.test',
+      ref: { origin: 'example.test', kind: 'class', name: 'Person' },
       properties: { name: { type: 'string', minLength } },
       required,
       methods: {},
@@ -87,6 +89,8 @@ describe('canonical standalone Function diffs', () => {
       ...withClass({
         type: 'edge',
         name: 'owns',
+        origin: 'example.test',
+        ref: { origin: 'example.test', kind: 'class', name: 'owns' },
         properties: {},
         required: [],
         methods: {},

package/studio/server/introspect/diff.ts

@@ -2,14 +2,12 @@
  * diff.ts — indicative structural diff of two Studio render IRs. Pure.
  *
  * Canonical V1 keeps optionality in the owning `required` arrays and nullability
- * in each value schema. Legacy nullable projections remain supported. This
- * inventory deliberately makes no installation or data-migration claim;
+ * in each value schema. This inventory makes no installation or data-migration claim;
  * only the Kernel Runtime can assess those transitions against installed data.
  */
 import type {
   IrClass,
   IrFunction,
-  IrInterface,
   IrMethod,
   JsonSchema,
   SchemaChange,
@@ -32,28 +30,11 @@ export function baseType(s: JsonSchema | undefined): string {
   return s.enum ? `enum(${s.enum.join(',')})` : 'unknown'
 }
 
-function requiredParams(m: IrMethod | IrFunction): string[] {
-  return (
-    m.requiredParams ??
-    Object.entries(m.params ?? {}).flatMap(([name, schema]) => (isOptional(schema) ? [] : [name]))
-  )
-}
-
 function callableContract(m: IrMethod | IrFunction): unknown {
-  const required = requiredParams(m)
   return {
-    input:
-      m.input ??
-      ({
-        type: 'object',
-        properties: m.params ?? {},
-        required,
-        additionalProperties: false,
-      } satisfies JsonSchema),
-    required,
-    output: m.output ?? { mode: 'value', schema: m.returns },
-    static: m.static,
-    inheritance: m.inheritance,
+    input: m.input,
+    output: m.output,
+    ...('static' in m ? { static: m.static, inheritance: m.inheritance } : {}),
     auth: m.auth,
     policy: m.policy,
   }
@@ -76,15 +57,8 @@ export function diffSchemas(prev: SchemaIR | null, next: SchemaIR | null): Schem
     changes.push({ kind: 'schema-metadata-changed', target: next.domain })
   }
 
-  diffValueRecord(prev.types ?? {}, next.types ?? {}, 'type', changes)
-  diffValueRecord(
-    prev.importsByKey ?? prev.imports ?? {},
-    next.importsByKey ?? next.imports ?? {},
-    'import',
-    changes,
-  )
-  diffMembers(prev.interfaces ?? {}, next.interfaces ?? {}, 'interface', changes)
-  diffMembers(prev.classes ?? {}, next.classes ?? {}, 'class', changes)
+  diffValueRecord(prev.importsByKey, next.importsByKey, 'import', changes)
+  diffMembers(prev.classes, next.classes, changes)
   diffFunctions(prev.functions ?? {}, next.functions ?? {}, changes)
   diffViews(prev.views ?? {}, next.views ?? {}, changes)
   diffValueRecord(prev.policies ?? {}, next.policies ?? {}, 'policy', changes)
@@ -98,7 +72,7 @@ export function diffSchemas(prev: SchemaIR | null, next: SchemaIR | null): Schem
 function diffValueRecord(
   prev: Record<string, unknown>,
   next: Record<string, unknown>,
-  scope: 'type' | 'import' | 'policy',
+  scope: 'import' | 'policy',
   out: SchemaChange[],
 ): void {
   for (const name of sortedKeys(next)) {
@@ -196,15 +170,13 @@ function diffDependencies(
   }
 }
 
-function memberKind(m: IrClass | IrInterface): 'class' | 'edge' | 'interface' {
-  if ((m as IrInterface).type === 'interface') return 'interface'
-  return (m as IrClass).type === 'edge' ? 'edge' : 'class'
+function memberKind(member: IrClass): 'class' | 'edge' {
+  return member.type === 'edge' ? 'edge' : 'class'
 }
 
 function diffMembers(
-  prev: Record<string, IrClass | IrInterface>,
-  next: Record<string, IrClass | IrInterface>,
-  _scope: 'class' | 'interface',
+  prev: Record<string, IrClass>,
+  next: Record<string, IrClass>,
   out: SchemaChange[],
 ): void {
   for (const name of sortedKeys(next)) {
@@ -223,12 +195,7 @@ function diffMembers(
   }
 }
 
-function diffMemberBody(
-  name: string,
-  a: IrClass | IrInterface,
-  b: IrClass | IrInterface,
-  out: SchemaChange[],
-): void {
+function diffMemberBody(name: string, a: IrClass, b: IrClass, out: SchemaChange[]): void {
   const pa = a.properties ?? {}
   const pb = b.properties ?? {}
   for (const p of sortedKeys(pb)) {
@@ -302,31 +269,27 @@ function diffMemberBody(
   }
 }
 
-function propertyRequired(member: IrClass | IrInterface, name: string): boolean {
+function propertyRequired(member: IrClass, name: string): boolean {
   return member.required ? member.required.includes(name) : !isOptional(member.properties?.[name])
 }
 
-function memberContract(member: IrClass | IrInterface): unknown {
-  const cls = member as IrClass
-  const iface = member as IrInterface
+function memberContract(member: IrClass): unknown {
   return {
     type: member.type,
     origin: member.origin,
     ref: member.ref,
-    family: iface.family,
-    extends: iface.extendsRefs ?? iface.extends,
-    implements: cls.implementsRefs ?? cls.implements,
+    extends: member.extendsRefs ?? member.extends,
     endpoints: member.endpoints,
     orientation: member.orientation,
     constraints: member.constraints,
     propertyMetadata: member.propertyMetadata,
     data: member.data,
-    policies: cls.policies,
+    policies: member.policies,
   }
 }
 
-function memberMetadata(member: IrClass | IrInterface): unknown {
-  return { description: member.description, icon: (member as IrClass).icon }
+function memberMetadata(member: IrClass): unknown {
+  return { description: member.description, icon: member.icon }
 }
 
 function sortedKeys(value: Record<string, unknown>): string[] {

package/studio/server/introspect/extractor.ts

@@ -1,136 +1,41 @@
-/**
- * extractor.ts — the Bun-executed island. Spawned as a short-lived subprocess by
- * runtime.ts. It imports ONLY the domain's pure `schema/index.ts` module graph
- * (never astrale.config.ts or the composition entry → integrations). Canonical
- * DomainSchema V1 roots are projected directly; legacy `D.$.ir` / serialize
- * domains retain their existing fallback.
- *
- *   bun extractor.ts <schemaIndexPath> <domainDir>
- *
- * A thrown error prints { ok:false } and exits 0 — the driver treats it as a
- * render state, never a crash.
- */
+/** Bun subprocess that imports only the authored Schema entry and its installed SDK. */
 import {
   admitCanonicalSchemaFromSdk,
   findCanonicalDomainSchemaExport,
-  normalizeLegacySchemaIR,
   projectCanonicalSchema,
 } from './canonical-schema'
 
 const schemaPath = process.argv[2]
-const domainDir = process.argv[3] ?? process.cwd()
-
-async function main() {
-  if (!schemaPath) throw new Error('extractor: missing <schemaIndexPath>')
-  const mod: Record<string, any> = await import(schemaPath)
-
-  // Resolve through the DOMAIN's dependency graph. This prevents Studio's own
-  // SDK version from accepting or resolving a root authored by another cohort.
-  let sdk: Record<string, any> | null = null
-  const loadSdkSchema = async (): Promise<Record<string, any>> => {
-    if (sdk) return sdk
-    const loaded: Record<string, any> = await import(
-      Bun.resolveSync('@astrale-os/sdk/schema', domainDir)
-    )
-    sdk = loaded
-    return loaded
-  }
-
-  const canonicalRoot = findCanonicalDomainSchemaExport(mod)
-  if (canonicalRoot) {
-    const domainSdk = await loadSdkSchema()
-    const admission = admitCanonicalSchemaFromSdk(domainSdk, canonicalRoot)
-    const projected = projectCanonicalSchema(admission.root, admission.closure)
-    process.stdout.write(
-      JSON.stringify({
-        ok: true,
-        ir: projected.ir,
-        root: admission.root,
-        schemaMode: admission.status === 'admitted' ? 'canonical-admitted' : 'canonical-preview',
-        revision: admission.revision,
-        importedInterfaces: projected.importedInterfaces,
-      }),
-    )
-    return
-  }
-
-  // Prefer the conventional `D` (compiled), but accept a compiled domain exported
-  // under ANY name — e.g. ai-gateway exports its `compileDomain(...)` result as
-  // `Gateway`, not `D`. A compiled domain is recognized by shape (`.$.ir`).
-  let ir: unknown = mod?.D?.$?.ir
-  if (!ir) {
-    for (const v of Object.values(mod)) {
-      const candidate = (v as any)?.$?.ir
-      if (candidate) {
-        ir = candidate
-        break
-      }
-    }
+const projectRoot = process.argv[3] ?? process.cwd()
+
+async function main(): Promise<void> {
+  if (!schemaPath) throw new Error('extractor: missing <schemaPath>')
+  const exports = (await import(schemaPath)) as Record<string, unknown>
+  const candidate = findCanonicalDomainSchemaExport(exports)
+  if (candidate === null) {
+    throw new Error('Schema entry exports no canonical V1 DomainSchema.')
   }
-  if (!ir) {
-    // Fallback: serialize a raw schema — the conventional `schema`, else any
-    // exported `defineSchema(...)` result (recognized by its `kind === 'schema'`).
-    const schema =
-      mod?.schema ??
-      Object.values(mod).find(
-        (v) =>
-          typeof (v as any)?.domain === 'string' && !!(v as any)?.classes && !!(v as any)?.imports,
-      )
-    if (!schema) {
-      throw new Error(
-        'schema entry exports no compiled domain (a `compileDomain(...)` value with `.$.ir`, e.g. `D`) nor a raw `schema`',
-      )
-    }
-    const d = await loadSdkSchema()
-    if (typeof d.serialize !== 'function') throw new Error('kernel-dsl.serialize unavailable')
-    ir = d.serialize(schema)
-  }
-
-  // Recover member bodies of IMPORTED interfaces (kernel mixins + cross-domain
-  // interfaces). `serialize()` emits them in `ir.imports` as name-only
-  // descriptors, so re-serialize each imported schema (KernelSchema, other
-  // domains) and collect its interface definitions. Best-effort: a single import
-  // failing to serialize must never break extraction of the primary IR.
-  const importedInterfaces: Record<string, unknown> = {}
-  const importSchemas: any[] = Array.isArray(mod?.schema?.imports) ? mod.schema.imports : []
-  if (importSchemas.length > 0) {
-    try {
-      const d = await loadSdkSchema()
-      if (typeof d.serialize === 'function') {
-        for (const imp of importSchemas) {
-          try {
-            const sub = d.serialize(imp)
-            for (const [name, def] of Object.entries(sub?.interfaces ?? {})) {
-              if (!(name in importedInterfaces)) importedInterfaces[name] = def
-            }
-          } catch {
-            /* skip this import — keep going */
-          }
-        }
-      }
-    } catch {
-      /* dsl unavailable — degrade gracefully (no imported-interface bodies) */
-    }
-  }
-
+  const sdk = (await import(Bun.resolveSync('@astrale-os/sdk/schema', projectRoot))) as Record<
+    string,
+    unknown
+  >
+  const admission = admitCanonicalSchemaFromSdk(sdk, candidate)
+  const projected = projectCanonicalSchema(admission.root, admission.closure)
   process.stdout.write(
     JSON.stringify({
       ok: true,
-      ir: normalizeLegacySchemaIR(ir),
-      root: null,
-      schemaMode: 'legacy',
-      revision: null,
-      importedInterfaces,
+      ir: projected.ir,
+      root: admission.root,
+      schemaMode: admission.status === 'admitted' ? 'canonical-admitted' : 'canonical-preview',
+      revision: admission.revision,
     }),
   )
 }
 
-main().catch((err: any) => {
+main().catch((cause: unknown) => {
+  const error = cause instanceof Error ? cause : new Error(String(cause))
   process.stdout.write(
-    JSON.stringify({
-      ok: false,
-      error: { message: String(err?.message ?? err), stack: String(err?.stack ?? '') },
-    }),
+    JSON.stringify({ ok: false, error: { message: error.message, stack: error.stack ?? '' } }),
   )
   process.exit(0)
 })