@astrale-os/cli 1.0.0-beta.3 → 1.0.0-beta.31

package/studio/server/introspect/overlay-tsmorph.test.ts

@@ -1,267 +1,142 @@
-import { expect, test } from 'bun:test'
+import { afterEach, describe, expect, test } from 'bun:test'
 import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs'
 import { tmpdir } from 'node:os'
 import { join } from 'node:path'
 
-import { buildHandlerLinks, buildSchemaAnnotations, buildSourceSpans } from './overlay-tsmorph'
+import type { SchemaIR } from '../../shared/types'
 
-test('resolves authorization hooks from imported remote method definitions', () => {
-  const root = mkdtempSync(join(tmpdir(), 'astrale-studio-handler-links-'))
-  const runtime = join(root, 'runtime')
-  mkdirSync(runtime)
+import { buildHandlerLinks, buildSourceSpans } from './overlay-tsmorph'
 
-  writeFileSync(
-    join(runtime, 'index.ts'),
-    `
-      import { remoteClassMethods } from '@astrale-os/sdk'
-      import {
-        absentMethod,
-        guardedMethod,
-        noopMethod,
-      } from './methods.js'
-
-      const classMethods = remoteClassMethods()
+const roots: string[] = []
+afterEach(() => {
+  while (roots.length) rmSync(roots.pop()!, { recursive: true, force: true })
+})
 
-      export const methods = {
-        class: {
-          Issue: classMethods(schema, 'Issue', {
-            absent: absentMethod,
-            guarded: guardedMethod,
-            noop: noopMethod,
-          }),
+const ir: SchemaIR = {
+  version: 'v1',
+  format: 'astrale.dsl',
+  domain: 'issues.example',
+  importsByKey: {},
+  importedClassesByKey: {},
+  classes: {
+    Issue: {
+      type: 'node',
+      name: 'Issue',
+      origin: 'issues.example',
+      ref: { origin: 'issues.example', kind: 'class', name: 'Issue' },
+      properties: {},
+      methods: {
+        rename: {
+          name: 'rename',
+          input: {},
+          output: { mode: 'value', schema: {} },
+          static: false,
+          inheritance: 'default',
+          auth: 'authorized',
         },
-      }
-    `,
-  )
-  writeFileSync(
-    join(runtime, 'methods.ts'),
-    `
-      import { remoteMethod } from '@astrale-os/sdk'
-
-      const method = remoteMethod()
-      const run = () => 'ok'
-
-      export const guardedMethod = method(schema, 'Issue', 'guarded', {
-        authorize: ({ auth, kernel, self }) =>
-          kernel.auth.require({ who: auth.principal, on: self.path, perms: 1 }),
-        execute: () => run(),
-      })
-
-      export const noopMethod = method(schema, 'Issue', 'noop', {
-        authorize: async () => undefined,
-        execute: () => run(),
-      })
+      },
+    },
+  },
+  functions: {
+    createIssue: {
+      name: 'createIssue',
+      input: {},
+      output: { mode: 'value', schema: {} },
+      auth: 'anonymous',
+    },
+  },
+  views: {},
+  policies: {},
+  dependencies: [],
+  core: {},
+}
 
-      export const absentMethod = method(schema, 'Issue', 'absent', {
-        execute: () => run(),
-      })
-    `,
-  )
+describe('source overlay', () => {
+  test('links modular Action and Workflow declarations to exact callables', () => {
+    const root = mkdtempSync(join(tmpdir(), 'studio-runtime-overlay-'))
+    roots.push(root)
+    mkdirSync(join(root, 'actions'))
+    mkdirSync(join(root, 'workflows'))
+    writeFileSync(
+      join(root, 'actions/rename.ts'),
+      `
+        import { defineAction } from '@astrale-os/sdk/action'
+        export const rename = defineAction()('Issue.rename', async ({ input }) => graph.update(input))
+      `,
+    )
+    writeFileSync(
+      join(root, 'workflows/create.ts'),
+      `
+        import { defineWorkflow } from '@astrale-os/sdk/workflow'
+        export const create = defineWorkflow()('createIssue', async ({ input }) => graph.create(input))
+      `,
+    )
 
-  try {
-    const links = buildHandlerLinks({ ir: null, domainRoot: root })
     expect(
-      links.map(({ method, authorize, auth, implemented, unlinked, handlerFile }) => ({
-        method,
-        authorize,
-        auth,
-        implemented,
-        unlinked: unlinked ?? false,
-        handlerFile,
+      buildHandlerLinks({ ir, domainRoot: root }).map((link) => ({
+        owner: link.owner,
+        ownerKind: link.ownerKind,
+        kind: link.kind,
+        method: link.method,
+        handlerFile: link.handlerFile,
+        kernelCalls: link.kernelCalls,
       })),
     ).toEqual([
       {
-        method: 'absent',
-        authorize: 'absent',
-        auth: 'required',
-        implemented: true,
-        unlinked: false,
-        handlerFile: 'runtime/methods.ts',
-      },
-      {
-        method: 'guarded',
-        authorize: 'custom',
-        auth: 'required',
-        implemented: true,
-        unlinked: false,
-        handlerFile: 'runtime/methods.ts',
+        owner: 'Issue',
+        ownerKind: 'class',
+        kind: 'action',
+        method: 'rename',
+        handlerFile: 'actions/rename.ts',
+        kernelCalls: ['graph.update'],
       },
       {
-        method: 'noop',
-        authorize: 'noop',
-        auth: 'required',
-        implemented: true,
-        unlinked: false,
-        handlerFile: 'runtime/methods.ts',
+        owner: 'issues.example',
+        ownerKind: 'function',
+        kind: 'workflow',
+        method: 'createIssue',
+        handlerFile: 'workflows/create.ts',
+        kernelCalls: ['graph.create'],
       },
     ])
-    expect(links.find((link) => link.method === 'guarded')?.authorizeSnippet).toContain(
-      'kernel.auth.require',
-    )
-  } finally {
-    rmSync(root, { recursive: true, force: true })
-  }
-})
+  })
 
-test('links current implementation handlers and current edge source spans', () => {
-  const root = mkdtempSync(join(tmpdir(), 'astrale-studio-current-overlay-'))
-  const schemaDir = join(root, 'schema')
-  const actionsDir = join(root, 'actions')
-  mkdirSync(schemaDir)
-  mkdirSync(actionsDir)
-  writeFileSync(
-    join(root, 'package.json'),
-    JSON.stringify({ imports: { '#actions/*': './actions/*.ts' } }),
-  )
-
-  writeFileSync(
-    join(root, 'implementation.ts'),
-    `
-      import { rename } from '#actions/rename'
-      import { createIssue } from '#actions/create-issue'
-      export const domain = defineDomain.public({
-        schema,
-        handlers: {
+  test('indexes Class, Property, Method, Edge endpoint, and Function declarations', () => {
+    const root = mkdtempSync(join(tmpdir(), 'studio-schema-spans-'))
+    roots.push(root)
+    const schemaDir = join(root, 'schema')
+    mkdirSync(schemaDir)
+    writeFileSync(
+      join(schemaDir, 'members.ts'),
+      `
+        export const Issue = nodeClass({
+          properties: { title: property(z.string()) },
+          methods: { rename },
+        })
+        export const assigned_to = edgeClass.directed({
+          source: { as: 'issue', accepts: [Issue] },
+          target: { as: 'owner', accepts: [Issue] },
+          properties: { note: property(z.string()) },
+        })
+        export const createIssue = fn({ input, output })
+      `,
+    )
+    writeFileSync(
+      join(schemaDir, 'index.ts'),
+      `
+        import { Issue, assigned_to, createIssue } from './members.js'
+        export const Schema = defineSchema('issues.example', {
+          classes: { Issue, assigned_to },
           functions: { createIssue },
-          classes: { Issue: { rename } },
-          interfaces: {},
-        },
-      })
-    `,
-  )
-  writeFileSync(
-    join(actionsDir, 'rename.ts'),
-    `
-      export function rename({ input }) {
-        return graph.update(input)
-      }
-    `,
-  )
-  writeFileSync(
-    join(actionsDir, 'create-issue.ts'),
-    `export const createIssue = ({ input }) => graph.create(input)`,
-  )
-  writeFileSync(
-    join(schemaDir, 'members.ts'),
-    `
-      export const iIssue = nodeInterface({
-        properties: { title: property({ type: 'string' }) },
-      })
-      export const Issue = nodeClass({
-        properties: { title: property({ type: 'string' }) },
-        methods: { rename },
-      })
-      export const assigned_to = edgeClass.directed({
-        source: { as: 'issue', accepts: [Issue], outgoing: '0..*' },
-        target: { as: 'owner', accepts: [Issue], incoming: '0..1' },
-        properties: { note: property({ type: 'string' }) },
-      })
-      export const createIssue = fn({ auth: 'anonymous', input, output })
-    `,
-  )
-  writeFileSync(
-    join(schemaDir, 'index.ts'),
-    `
-      import { Issue, assigned_to, createIssue, iIssue as issueInterface } from './members.js'
-      const schemaInput = {
-        interfaces: { Issue: issueInterface },
-        classes: { Issue, assigned_to },
-        functions: { createIssue },
-      } as const
-      export const schema = defineSchema('issues.example', schemaInput)
-    `,
-  )
-
-  try {
-    const links = buildHandlerLinks({
-      ir: {
-        version: 'v1',
-        domain: 'issues.example',
-        types: {},
-        interfaces: {},
-        classes: {
-          Issue: {
-            type: 'node',
-            name: 'Issue',
-            properties: {},
-            methods: {
-              rename: {
-                name: 'rename',
-                params: {},
-                returns: {},
-                static: false,
-                inheritance: 'default',
-                auth: 'authorized',
-              } as any,
-            },
-          },
-        },
-        imports: {},
-        functions: {
-          createIssue: {
-            name: 'createIssue',
-            input: {},
-            params: {},
-            output: { mode: 'value', schema: {} },
-            returns: {},
-            static: true,
-            inheritance: 'default',
-            auth: 'anonymous',
-          },
-        },
-      },
-      domainRoot: root,
-    })
-    expect(links).toHaveLength(2)
-    expect(links.find((link) => link.ownerKind === 'class')).toMatchObject({
-      owner: 'Issue',
-      ownerKind: 'class',
-      method: 'rename',
-      wiringFile: 'implementation.ts',
-      handlerFile: 'actions/rename.ts',
-      implemented: true,
-      auth: 'required',
-      callableAuth: 'authorized',
-      authorize: 'custom',
-      kernelCalls: ['graph.update'],
-    })
-    expect(links.find((link) => link.ownerKind === 'function')).toMatchObject({
-      owner: 'issues.example',
-      method: 'createIssue',
-      wiringFile: 'implementation.ts',
-      handlerFile: 'actions/create-issue.ts',
-      implemented: true,
-      static: true,
-      auth: 'public',
-      callableAuth: 'anonymous',
-      kernelCalls: ['graph.create'],
-    })
-
-    const spans = buildSourceSpans({ ir: null, schemaDir })
-    expect(spans['interface.Issue.property.title']?.file).toBe('schema/members.ts')
+        })
+      `,
+    )
+    const spans = buildSourceSpans({ ir, schemaDir })
     expect(spans['class.Issue.property.title']?.file).toBe('schema/members.ts')
+    expect(spans['class.Issue.method.rename']?.file).toBe('schema/members.ts')
     expect(spans['edge.assigned_to.endpoint.issue']?.file).toBe('schema/members.ts')
     expect(spans['edge.assigned_to.endpoint.owner']?.file).toBe('schema/members.ts')
     expect(spans['edge.assigned_to.property.note']?.file).toBe('schema/members.ts')
     expect(spans['function.createIssue']?.file).toBe('schema/members.ts')
-  } finally {
-    rmSync(root, { recursive: true, force: true })
-  }
-})
-
-test('does not emit the obsolete enum update warning', () => {
-  expect(
-    buildSchemaAnnotations({
-      ir: {
-        classes: {
-          Issue: {
-            type: 'node',
-            name: 'Issue',
-            properties: { status: { type: 'string', enum: ['open', 'closed'] } },
-            methods: {},
-          },
-        },
-      } as any,
-    }),
-  ).toEqual([])
+  })
 })

package/studio/server/introspect/overlay-tsmorph.ts

@@ -4,6 +4,5 @@
  * Keep this path stable for the overlay composer and focused tests. The
  * implementation lives under source-overlay, split by responsibility.
  */
-export { buildSchemaAnnotations } from './source-overlay/annotations'
 export { buildHandlerLinks } from './source-overlay/handlers'
 export { buildSourceSpans } from './source-overlay/spans'

package/studio/server/introspect/overlay.ts

@@ -1,16 +1,9 @@
 /**
- * overlay.ts — the Studio overlay over the DSL IR. Computes what the IR cannot
- * carry. The imports split + requires/postInstall are done here (pure / light
- * static parse). handlerLinks, sourceSpans (+JSDoc) and annotations are filled
- * by a ts-morph pass over the current implementation/schema files, with legacy
- * domain.ts and runtime/index.ts support retained.
+ * Source-only metadata that the admitted DSL Schema cannot carry.
  */
-import { existsSync, readFileSync } from 'node:fs'
-import { join } from 'node:path'
+import type { SchemaIR, SchemaOverlay } from '../../shared/types'
 
-import type { CrossDomainImport, SchemaIR, SchemaOverlay } from '../../shared/types'
-
-import { buildHandlerLinks, buildSchemaAnnotations, buildSourceSpans } from './overlay-tsmorph'
+import { buildHandlerLinks, buildSourceSpans } from './overlay-tsmorph'
 
 export interface OverlayArgs {
   ir: SchemaIR | null
@@ -19,49 +12,8 @@ export interface OverlayArgs {
 }
 
 export function buildOverlay({ ir, domainRoot, schemaDir }: OverlayArgs): SchemaOverlay {
-  const origin = ir?.domain ?? ''
-  const mixins: CrossDomainImport[] = []
-  const crossDomainImports: CrossDomainImport[] = []
-  const imports =
-    ir?.importsByKey !== undefined
-      ? Object.values(ir.importsByKey).flatMap((descriptor) =>
-          descriptor.ref ? [[descriptor.ref.name, descriptor] as const] : [],
-        )
-      : Object.entries(ir?.imports ?? {})
-  for (const [name, d] of imports) {
-    const entry: CrossDomainImport = { name, origin: d.origin, definition: d.definition }
-    if (d.origin === 'kernel.astrale.ai') mixins.push(entry)
-    else crossDomainImports.push(entry)
-  }
-
-  const { requires, postInstall } = parseCompositionEntry(domainRoot, origin)
-
   return {
-    origin,
-    requires,
-    crossDomainImports,
-    mixins,
-    postInstall,
     handlerLinks: buildHandlerLinks({ ir, domainRoot }),
     sourceSpans: buildSourceSpans({ ir, schemaDir }),
-    annotations: buildSchemaAnnotations({ ir }),
-  }
-}
-
-function parseCompositionEntry(
-  root: string,
-  origin: string,
-): { requires: string[]; postInstall?: string } {
-  const f = ['implementation.ts', 'domain.ts'].map((file) => join(root, file)).find(existsSync)
-  let requires: string[] = []
-  let postInstall: string | undefined
-  if (f) {
-    const src = readFileSync(f, 'utf8')
-    const rm = src.match(/requires\s*:\s*\[([^\]]*)\]/)
-    if (rm) requires = [...rm[1].matchAll(/['"`]([^'"`]+)['"`]/g)].map((x) => x[1])
-    const pm = src.match(/postInstall\s*:\s*[`'"]([^`'"]+)[`'"]/)
-    if (pm)
-      postInstall = pm[1].replace(/\$\{schema\.domain\}/g, origin).replace(/\$\{[^}]+\}/g, origin)
   }
-  return { requires, postInstall }
 }

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

@@ -1,53 +1,49 @@
+import * as sdk from '@astrale-os/sdk/schema'
+import { defineSchema } from '@astrale-os/sdk/schema'
 import { describe, expect, test } from 'bun:test'
 
 import { admittedBundleRevisionFromSdk } from './revision'
 
-const REVISION = `sha256:${'a'.repeat(64)}` as const
+const schema = defineSchema('notes.example.dev', {})
+const wire = JSON.parse(JSON.stringify(sdk.bundle.create(schema)))
 
 describe('installed Bundle revision', () => {
-  test('uses bundle admission before asking the cohort schema owner for its revision', () => {
+  test('uses Bundle admission and the resolved Domain identity', () => {
     const calls: string[] = []
-    const root = { format: 'astrale.dsl', version: 'v1', origin: 'notes.example.dev' }
-    const input = { wire: true }
-    const sdk = {
+    const wrapped = {
+      ...sdk,
       bundle: {
+        ...sdk.bundle,
         accept(value: unknown) {
           calls.push('bundle.accept')
-          expect(value).toBe(input)
-          return { root, closure: [] }
+          return sdk.bundle.accept(value)
         },
       },
       schema: {
-        revision(value: unknown) {
-          calls.push('schema.revision')
-          expect(value).toBe(root)
-          return REVISION
+        ...sdk.schema,
+        resolve(value: typeof schema) {
+          calls.push('schema.resolve')
+          return sdk.schema.resolve(value)
         },
       },
-    }
+    } as unknown as typeof sdk
 
-    expect(admittedBundleRevisionFromSdk(sdk, input)).toBe(REVISION)
-    expect(calls).toEqual(['bundle.accept', 'schema.revision'])
+    expect(admittedBundleRevisionFromSdk(wrapped, wire)).toBe(sdk.schema.revision(schema))
+    expect(calls).toEqual(['bundle.accept', 'schema.resolve'])
   })
 
-  test('fails closed when bundle admission or the returned revision is invalid', () => {
-    expect(
-      admittedBundleRevisionFromSdk(
-        { bundle: { accept: () => ({ root: {} }) }, schema: { revision: () => 'sha-short' } },
-        {},
-      ),
-    ).toBeNull()
+  test('fails closed when Bundle admission or the resolved identity is invalid', () => {
+    expect(admittedBundleRevisionFromSdk({} as typeof sdk, {})).toBeNull()
     expect(
       admittedBundleRevisionFromSdk(
         {
-          bundle: {
-            accept: () => {
-              throw new Error('invalid bundle')
-            },
+          ...sdk,
+          schema: {
+            ...sdk.schema,
+            resolve: () => ({ source: schema, revision: 'sha-short' }),
           },
-          schema: { revision: () => REVISION },
-        },
-        {},
+        } as unknown as typeof sdk,
+        wire,
       ),
     ).toBeNull()
   })

package/studio/server/introspect/revision.ts

@@ -1,28 +1,23 @@
 import type { SchemaRevision } from '../../shared/types'
+import type { SchemaAdmissionSdk } from './canonical-schema'
 
 import { isSchemaRevision } from '../../shared/types'
 
-type AnyRecord = Record<string, unknown>
-
 /**
- * Cross the installed-bundle JSON boundary through one exact SDK cohort, then
+ * Cross the installed-bundle JSON boundary through the Domain's installed SDK, then
  * ask the DSL owner for the root revision. Invalid/unavailable bundles return
  * null so Studio reports unknown drift instead of inventing an identity.
  */
 export function admittedBundleRevisionFromSdk(
-  sdkModule: Record<string, unknown>,
+  sdk: SchemaAdmissionSdk,
   input: unknown,
 ): SchemaRevision | null {
-  const bundleApi = asRecord(sdkModule.bundle)
-  const schemaApi = asRecord(sdkModule.schema)
-  if (typeof bundleApi?.accept !== 'function' || typeof schemaApi?.revision !== 'function') {
-    return null
-  }
   try {
-    const accepted = asRecord(Reflect.apply(bundleApi.accept, bundleApi, [input]))
-    if (!accepted || !Object.prototype.hasOwnProperty.call(accepted, 'root')) return null
-    const revision = Reflect.apply(schemaApi.revision, schemaApi, [accepted.root])
-    return isSchemaRevision(revision) ? revision : null
+    const accepted = sdk.bundle.accept(input)
+    const domain = sdk.schema.resolve(accepted.root)
+    return domain.source === accepted.root && isSchemaRevision(domain.revision)
+      ? domain.revision
+      : null
   } catch {
     return null
   }
@@ -33,17 +28,11 @@ export async function admittedBundleRevision(
   input: unknown,
 ): Promise<SchemaRevision | null> {
   try {
-    const sdkModule: Record<string, unknown> = await import(
+    const sdk = (await import(
       Bun.resolveSync('@astrale-os/sdk/schema', domainRoot)
-    )
-    return admittedBundleRevisionFromSdk(sdkModule, input)
+    )) as unknown as SchemaAdmissionSdk
+    return admittedBundleRevisionFromSdk(sdk, input)
   } catch {
     return null
   }
 }
-
-function asRecord(value: unknown): AnyRecord | null {
-  return value !== null && typeof value === 'object' && !Array.isArray(value)
-    ? (value as AnyRecord)
-    : null
-}