@astrale-os/cli 1.0.0-beta.5 → 1.0.0-beta.7

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

@@ -1,267 +1,146 @@
-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'
-
-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 type { SchemaIR } from '../../shared/types'
 
-  writeFileSync(
-    join(runtime, 'index.ts'),
-    `
-      import { remoteClassMethods } from '@astrale-os/sdk'
-      import {
-        absentMethod,
-        guardedMethod,
-        noopMethod,
-      } from './methods.js'
+import { buildHandlerLinks, buildSchemaAnnotations, buildSourceSpans } from './overlay-tsmorph'
 
-      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',
+        owner: 'Issue',
+        ownerKind: 'class',
+        kind: 'action',
+        method: 'rename',
+        handlerFile: 'actions/rename.ts',
+        kernelCalls: ['graph.update'],
       },
       {
-        method: 'guarded',
-        authorize: 'custom',
-        auth: 'required',
-        implemented: true,
-        unlinked: false,
-        handlerFile: 'runtime/methods.ts',
-      },
-      {
-        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([])
+  test('does not invent warnings for admitted enum values', () => {
+    expect(buildSchemaAnnotations({ ir })).toEqual([])
+  })
 })

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

@@ -1,72 +1,44 @@
 import { expect, test } from 'bun:test'
 
-import type { SchemaIR } from '../../shared/types'
+import type { IrClassKey, SchemaIR } from '../../shared/types'
 
 import { buildOverlay } from './overlay'
 
-test('preserves homonymous and cross-kind imports from the exact index', () => {
+function descriptor(origin: string, name: string) {
+  const key = `${origin}:class.${name}` as IrClassKey
+  return { origin, ref: { origin, kind: 'class' as const, name }, key }
+}
+
+test('preserves homonymous Classes through exact import identity', () => {
+  const first = descriptor('a.example', 'Shared')
+  const second = descriptor('b.example', 'Shared')
+  const kernel = descriptor('kernel.astrale.ai', 'Identity')
   const ir = {
     version: 'v1',
+    format: 'astrale.dsl',
     domain: 'app.example',
-    types: {},
-    interfaces: {},
     classes: {},
     functions: {},
-    imports: {},
     importsByKey: {
-      'a.example:interface.Shared': {
-        origin: 'a.example',
-        definition: 'interface',
-        ref: { origin: 'a.example', kind: 'interface', name: 'Shared' },
-        key: 'a.example:interface.Shared',
-      },
-      'b.example:interface.Shared': {
-        origin: 'b.example',
-        definition: 'interface',
-        ref: { origin: 'b.example', kind: 'interface', name: 'Shared' },
-        key: 'b.example:interface.Shared',
-      },
-      'a.example:class.Shared': {
-        origin: 'a.example',
-        definition: 'class',
-        ref: { origin: 'a.example', kind: 'class', name: 'Shared' },
-        key: 'a.example:class.Shared',
-      },
-      'kernel.astrale.ai:interface.Identity': {
-        origin: 'kernel.astrale.ai',
-        definition: 'interface',
-        ref: { origin: 'kernel.astrale.ai', kind: 'interface', name: 'Identity' },
-        key: 'kernel.astrale.ai:interface.Identity',
-      },
+      [first.key]: first,
+      [second.key]: second,
+      [kernel.key]: kernel,
     },
+    importedClassesByKey: {},
+    views: {},
+    policies: {},
+    dependencies: [
+      { origin: first.origin, revision: `sha256:${'a'.repeat(64)}` },
+      { origin: second.origin, revision: `sha256:${'b'.repeat(64)}` },
+    ],
+    core: {},
   } satisfies SchemaIR
 
   const overlay = buildOverlay({ ir, domainRoot: '', schemaDir: '' })
-
   expect(overlay.crossDomainImports).toEqual([
-    { name: 'Shared', origin: 'a.example', definition: 'interface' },
-    { name: 'Shared', origin: 'b.example', definition: 'interface' },
-    { name: 'Shared', origin: 'a.example', definition: 'class' },
-  ])
-  expect(overlay.mixins).toEqual([
-    { name: 'Identity', origin: 'kernel.astrale.ai', definition: 'interface' },
-  ])
-})
-
-test('retains the legacy short-name import fallback', () => {
-  const ir = {
-    version: 'legacy',
-    domain: 'app.example',
-    types: {},
-    interfaces: {},
-    classes: {},
-    functions: {},
-    imports: {
-      Identity: { origin: 'kernel.astrale.ai', definition: 'interface' },
-    },
-  } satisfies SchemaIR
-
-  expect(buildOverlay({ ir, domainRoot: '', schemaDir: '' }).mixins).toEqual([
-    { name: 'Identity', origin: 'kernel.astrale.ai', definition: 'interface' },
+    { name: 'Shared', origin: first.origin, ref: first.ref },
+    { name: 'Shared', origin: second.origin, ref: second.ref },
   ])
+  expect(overlay.mixins).toEqual([{ name: 'Identity', origin: kernel.origin, ref: kernel.ref }])
+  expect(overlay.requires).toEqual(['a.example', 'b.example'])
 })

package/studio/server/introspect/overlay.ts

@@ -1,13 +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
+ * carry. The import split and dependency list are computed here; handlerLinks,
  * 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.
+ * by a ts-morph pass over current Schema, Runtime, Action, and Workflow files.
  */
-import { existsSync, readFileSync } from 'node:fs'
-import { join } from 'node:path'
-
 import type { CrossDomainImport, SchemaIR, SchemaOverlay } from '../../shared/types'
 
 import { buildHandlerLinks, buildSchemaAnnotations, buildSourceSpans } from './overlay-tsmorph'
@@ -22,46 +18,23 @@ export function buildOverlay({ ir, domainRoot, schemaDir }: OverlayArgs): Schema
   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)
+  for (const descriptor of Object.values(ir?.importsByKey ?? {})) {
+    const entry: CrossDomainImport = {
+      name: descriptor.ref.name,
+      origin: descriptor.origin,
+      ref: descriptor.ref,
+    }
+    if (descriptor.origin === 'kernel.astrale.ai') mixins.push(entry)
     else crossDomainImports.push(entry)
   }
 
-  const { requires, postInstall } = parseCompositionEntry(domainRoot, origin)
-
   return {
     origin,
-    requires,
+    requires: (ir?.dependencies ?? []).map(({ origin }) => origin),
     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

@@ -5,7 +5,7 @@ import { admittedBundleRevisionFromSdk } from './revision'
 const REVISION = `sha256:${'a'.repeat(64)}` as const
 
 describe('installed Bundle revision', () => {
-  test('uses bundle admission before asking the cohort schema owner for its revision', () => {
+  test('uses bundle admission before asking the installed schema owner for its revision', () => {
     const calls: string[] = []
     const root = { format: 'astrale.dsl', version: 'v1', origin: 'notes.example.dev' }
     const input = { wire: true }

package/studio/server/introspect/revision.ts

@@ -5,7 +5,7 @@ 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.
  */