@astrale-os/cli 1.0.0-beta.9 → 1.0.0-npm-deprecated.0

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

@@ -1,146 +0,0 @@
-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 type { SchemaIR } from '../../shared/types'
-
-import { buildHandlerLinks, buildSchemaAnnotations, buildSourceSpans } from './overlay-tsmorph'
-
-const roots: string[] = []
-afterEach(() => {
-  while (roots.length) rmSync(roots.pop()!, { recursive: true, force: true })
-})
-
-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',
-        },
-      },
-    },
-  },
-  functions: {
-    createIssue: {
-      name: 'createIssue',
-      input: {},
-      output: { mode: 'value', schema: {} },
-      auth: 'anonymous',
-    },
-  },
-  views: {},
-  policies: {},
-  dependencies: [],
-  core: {},
-}
-
-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))
-      `,
-    )
-
-    expect(
-      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([
-      {
-        owner: 'Issue',
-        ownerKind: 'class',
-        kind: 'action',
-        method: 'rename',
-        handlerFile: 'actions/rename.ts',
-        kernelCalls: ['graph.update'],
-      },
-      {
-        owner: 'issues.example',
-        ownerKind: 'function',
-        kind: 'workflow',
-        method: 'createIssue',
-        handlerFile: 'workflows/create.ts',
-        kernelCalls: ['graph.create'],
-      },
-    ])
-  })
-
-  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 },
-        })
-      `,
-    )
-    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')
-  })
-
-  test('does not invent warnings for admitted enum values', () => {
-    expect(buildSchemaAnnotations({ ir })).toEqual([])
-  })
-})

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

@@ -1,9 +0,0 @@
-/**
- * Compatibility facade for the ts-morph source overlay.
- *
- * 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.test.ts

@@ -1,44 +0,0 @@
-import { expect, test } from 'bun:test'
-
-import type { IrClassKey, SchemaIR } from '../../shared/types'
-
-import { buildOverlay } from './overlay'
-
-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',
-    classes: {},
-    functions: {},
-    importsByKey: {
-      [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: 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,40 +0,0 @@
-/**
- * overlay.ts — the Studio overlay over the DSL IR. Computes what the IR cannot
- * 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 current Schema, Runtime, Action, and Workflow files.
- */
-import type { CrossDomainImport, SchemaIR, SchemaOverlay } from '../../shared/types'
-
-import { buildHandlerLinks, buildSchemaAnnotations, buildSourceSpans } from './overlay-tsmorph'
-
-export interface OverlayArgs {
-  ir: SchemaIR | null
-  domainRoot: string
-  schemaDir: string
-}
-
-export function buildOverlay({ ir, domainRoot, schemaDir }: OverlayArgs): SchemaOverlay {
-  const origin = ir?.domain ?? ''
-  const mixins: CrossDomainImport[] = []
-  const crossDomainImports: CrossDomainImport[] = []
-  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)
-  }
-
-  return {
-    origin,
-    requires: (ir?.dependencies ?? []).map(({ origin }) => origin),
-    crossDomainImports,
-    mixins,
-    handlerLinks: buildHandlerLinks({ ir, domainRoot }),
-    sourceSpans: buildSourceSpans({ ir, schemaDir }),
-    annotations: buildSchemaAnnotations({ ir }),
-  }
-}

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

@@ -1,54 +0,0 @@
-import { describe, expect, test } from 'bun:test'
-
-import { admittedBundleRevisionFromSdk } from './revision'
-
-const REVISION = `sha256:${'a'.repeat(64)}` as const
-
-describe('installed Bundle 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 }
-    const sdk = {
-      bundle: {
-        accept(value: unknown) {
-          calls.push('bundle.accept')
-          expect(value).toBe(input)
-          return { root, closure: [] }
-        },
-      },
-      schema: {
-        revision(value: unknown) {
-          calls.push('schema.revision')
-          expect(value).toBe(root)
-          return REVISION
-        },
-      },
-    }
-
-    expect(admittedBundleRevisionFromSdk(sdk, input)).toBe(REVISION)
-    expect(calls).toEqual(['bundle.accept', 'schema.revision'])
-  })
-
-  test('fails closed when bundle admission or the returned revision is invalid', () => {
-    expect(
-      admittedBundleRevisionFromSdk(
-        { bundle: { accept: () => ({ root: {} }) }, schema: { revision: () => 'sha-short' } },
-        {},
-      ),
-    ).toBeNull()
-    expect(
-      admittedBundleRevisionFromSdk(
-        {
-          bundle: {
-            accept: () => {
-              throw new Error('invalid bundle')
-            },
-          },
-          schema: { revision: () => REVISION },
-        },
-        {},
-      ),
-    ).toBeNull()
-  })
-})

package/studio/server/introspect/revision.ts

@@ -1,49 +0,0 @@
-import type { SchemaRevision } from '../../shared/types'
-
-import { isSchemaRevision } from '../../shared/types'
-
-type AnyRecord = Record<string, unknown>
-
-/**
- * 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>,
-  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
-  } catch {
-    return null
-  }
-}
-
-export async function admittedBundleRevision(
-  domainRoot: string,
-  input: unknown,
-): Promise<SchemaRevision | null> {
-  try {
-    const sdkModule: Record<string, unknown> = await import(
-      Bun.resolveSync('@astrale-os/sdk/schema', domainRoot)
-    )
-    return admittedBundleRevisionFromSdk(sdkModule, input)
-  } catch {
-    return null
-  }
-}
-
-function asRecord(value: unknown): AnyRecord | null {
-  return value !== null && typeof value === 'object' && !Array.isArray(value)
-    ? (value as AnyRecord)
-    : null
-}

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

@@ -1,157 +0,0 @@
-import { afterEach, describe, expect, test } from 'bun:test'
-import { mkdirSync, mkdtempSync, realpathSync, rmSync, symlinkSync, writeFileSync } from 'node:fs'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-
-import type { DomainHandle } from '../domain'
-
-import { buildBundle } from './bundle'
-import { renderFingerprintOf } from './hash'
-import { admittedBundleRevision } from './revision'
-import { coreExtract, runtimeExtract } from './runtime'
-
-const roots: string[] = []
-afterEach(() => {
-  while (roots.length > 0) rmSync(roots.pop()!, { recursive: true, force: true })
-})
-
-function fixtureRoot(label: string): string {
-  const root = mkdtempSync(join(tmpdir(), `studio-${label}-`))
-  roots.push(root)
-  mkdirSync(join(root, 'schema'), { recursive: true })
-  writeFileSync(join(root, 'package.json'), '{"type":"module"}\n')
-  writeFileSync(join(root, 'astrale.config.ts'), 'export default {}\n')
-  const sdk = realpathSync(join(import.meta.dir, '../../../node_modules/@astrale-os/sdk'))
-  const scope = join(root, 'node_modules', '@astrale-os')
-  mkdirSync(scope, { recursive: true })
-  symlinkSync(sdk, join(scope, 'sdk'), 'dir')
-  return root
-}
-
-function currentFixture(): DomainHandle {
-  const root = fixtureRoot('canonical-runtime')
-  const schemaIndex = join(root, 'schema/index.ts')
-  const applicationFile = join(root, 'application.ts')
-  writeFileSync(
-    schemaIndex,
-    `
-      import { bundle, core, defineSchema, nodeClass, view } from '@astrale-os/sdk/schema'
-      const Named = nodeClass({ properties: {} })
-      export const DirectorySchema = defineSchema('directory.runtime.test', {
-        classes: { Named },
-      })
-      const Document = nodeClass({ extends: [Named], properties: {} })
-      const welcome = core.node(Document, {})
-      export const schema = defineSchema('documents.runtime.test', {
-        dependencies: { directory: DirectorySchema },
-        classes: { Document },
-        views: { editor: view({ target: Document }) },
-        core: { nodes: { welcome } },
-      })
-      export const installedBundle = bundle.create(schema)
-    `,
-  )
-  writeFileSync(applicationFile, `throw new Error('Application entry was imported')\n`)
-  return {
-    id: 'documents-runtime-test',
-    root,
-    configFile: join(root, 'astrale.config.ts'),
-    applicationFile,
-    schemaDirName: 'schema',
-    schemaDir: join(root, 'schema'),
-    schemaIndex,
-  }
-}
-
-describe('SDK V1 schema extractor', () => {
-  test('uses the authored SDK for admission and projects exact imported Classes', async () => {
-    const handle = currentFixture()
-    const result = await runtimeExtract(handle.schemaIndex, handle.root)
-    expect(result).toMatchObject({
-      ok: true,
-      schemaMode: 'canonical-admitted',
-      root: {
-        format: 'astrale.dsl',
-        version: 'v1',
-        origin: 'documents.runtime.test',
-      },
-      ir: {
-        domain: 'documents.runtime.test',
-        views: { editor: { auth: 'required', target: { kind: 'definition' } } },
-        importsByKey: {
-          'directory.runtime.test:class.Named': {
-            ref: { origin: 'directory.runtime.test', kind: 'class', name: 'Named' },
-          },
-        },
-      },
-    })
-    expect(result.revision).toMatch(/^sha256:[0-9a-f]{64}$/)
-  })
-
-  test('transports the DSL revision while keeping render identity separate', async () => {
-    const handle = currentFixture()
-    const extracted = await runtimeExtract(handle.schemaIndex, handle.root)
-    if (extracted.revision === null) throw new Error('expected an admitted Schema revision')
-    const built = await buildBundle(handle)
-    expect(built.schemaRoot).toEqual(extracted.root)
-    expect(built.schemaRevision).toBe(extracted.revision)
-    expect(built.renderFingerprint).toBe(renderFingerprintOf(extracted.root))
-    expect(built.renderFingerprint).not.toBe(renderFingerprintOf(extracted.ir))
-  })
-
-  test('re-admits installed Bundle JSON before comparing its revision', async () => {
-    const handle = currentFixture()
-    const extracted = await runtimeExtract(handle.schemaIndex, handle.root)
-    if (extracted.revision === null) throw new Error('expected an admitted Schema revision')
-    const fixture = (await import(handle.schemaIndex)) as { installedBundle: unknown }
-    const installedWire = JSON.parse(JSON.stringify(fixture.installedBundle))
-    expect(await admittedBundleRevision(handle.root, installedWire)).toBe(extracted.revision)
-  })
-
-  test('renders a V1-shaped root as preview when SDK admission fails', async () => {
-    const root = fixtureRoot('canonical-preview')
-    const schemaIndex = join(root, 'schema/index.ts')
-    writeFileSync(
-      schemaIndex,
-      `export const schema = {
-        format: 'astrale.dsl', version: 'v1', origin: 'not an origin',
-        dependencies: {}, classes: {}, functions: {}, policies: {}, views: {},
-        core: { nodes: {}, edges: [] },
-      }\n`,
-    )
-    expect(await runtimeExtract(schemaIndex, root)).toMatchObject({
-      ok: true,
-      schemaMode: 'canonical-preview',
-      revision: null,
-    })
-  })
-
-  test('extracts Core through the pure Schema entry without importing Application', async () => {
-    const handle = currentFixture()
-    expect(await coreExtract(handle.schemaIndex, handle.root)).toEqual({
-      ok: true,
-      core: {
-        domain: 'documents.runtime.test',
-        nodes: [
-          {
-            path: '/:documents.runtime.test:core.welcome',
-            className: 'Document',
-            data: {},
-          },
-        ],
-        edges: [],
-      },
-    })
-  })
-})
-
-test('rejects the removed compiled-IR compatibility envelope', async () => {
-  const root = fixtureRoot('removed-runtime')
-  const schemaIndex = join(root, 'schema/index.ts')
-  writeFileSync(schemaIndex, `export const D = { $: { ir: { domain: 'legacy' } } }\n`)
-  expect(await runtimeExtract(schemaIndex, root)).toMatchObject({
-    ok: false,
-    schemaMode: 'unavailable',
-    revision: null,
-  })
-})

package/studio/server/introspect/runtime.ts

@@ -1,140 +0,0 @@
-/**
- * runtime.ts — the introspection driver. Spawns the Bun extractor island in a
- * short-lived subprocess (cwd = domain dir so the domain's own node_modules
- * resolve the @astrale-os/* packages), with a hard timeout. Returns the raw
- * render IR plus the raw canonical root (when present), or an error render-state
- * — never throws.
- */
-import type { SchemaIR, SchemaRevision, StudioCore, StudioSchemaBundle } from '../../shared/types'
-
-import { isSchemaRevision } from '../../shared/types'
-
-const EXTRACTOR = new URL('./extractor.ts', import.meta.url).pathname
-const CORE_EXTRACTOR = new URL('./core-extractor.ts', import.meta.url).pathname
-
-export interface RuntimeExtractResult {
-  ok: boolean
-  ir: SchemaIR | null
-  /** Portable canonical V1 document. Null only for failures. */
-  root: unknown | null
-  schemaMode: StudioSchemaBundle['schemaMode']
-  /** Present only when the Domain's installed SDK admitted `root`. */
-  revision: SchemaRevision | null
-  error?: { message: string }
-}
-
-export async function runtimeExtract(
-  schemaIndexPath: string,
-  domainDir: string,
-  timeoutMs = 20000,
-): Promise<RuntimeExtractResult> {
-  try {
-    const proc = Bun.spawn(['bun', 'run', EXTRACTOR, schemaIndexPath, domainDir], {
-      cwd: domainDir,
-      stdout: 'pipe',
-      stderr: 'pipe',
-    })
-    const timer = setTimeout(() => proc.kill(9), timeoutMs)
-    const out = await new Response(proc.stdout).text()
-    await proc.exited
-    clearTimeout(timer)
-
-    if (!out.trim()) {
-      const err = await new Response(proc.stderr).text()
-      return {
-        ok: false,
-        ir: null,
-        root: null,
-        schemaMode: 'unavailable',
-        revision: null,
-        error: { message: err.trim() || 'extractor produced no output' },
-      }
-    }
-    const parsed = JSON.parse(out)
-    if (!parsed.ok)
-      return {
-        ok: false,
-        ir: null,
-        root: null,
-        schemaMode: 'unavailable',
-        revision: null,
-        error: parsed.error ?? { message: 'extraction failed' },
-      }
-    const schemaMode = parsed.schemaMode
-    const revision = parsed.revision
-    const validMode = schemaMode === 'canonical-admitted' || schemaMode === 'canonical-preview'
-    const validRevision =
-      schemaMode === 'canonical-admitted' ? isSchemaRevision(revision) : revision == null
-    const validRoot = parsed.root !== null && parsed.root !== undefined
-    if (!validMode || !validRevision || !validRoot) {
-      return {
-        ok: false,
-        ir: null,
-        root: null,
-        schemaMode: 'unavailable',
-        revision: null,
-        error: { message: 'extractor produced an invalid schema admission envelope' },
-      }
-    }
-    return {
-      ok: true,
-      ir: parsed.ir as SchemaIR,
-      root: parsed.root ?? null,
-      schemaMode,
-      revision: revision ?? null,
-    }
-  } catch (e: any) {
-    return {
-      ok: false,
-      ir: null,
-      root: null,
-      schemaMode: 'unavailable',
-      revision: null,
-      error: { message: String(e?.message ?? e) },
-    }
-  }
-}
-
-export interface CoreExtractResult {
-  ok: boolean
-  /** the resolved core graph, or null when the domain defines no core */
-  core: Pick<StudioCore, 'domain' | 'nodes' | 'edges'> | null
-  error?: { message: string }
-}
-
-/**
- * Spawn the Core extractor over the pure Schema entry. Returns the projected
- * graph or an error and never imports Application or Runtime modules.
- */
-export async function coreExtract(
-  schemaIndexPath: string,
-  domainDir: string,
-  timeoutMs = 20000,
-): Promise<CoreExtractResult> {
-  try {
-    const proc = Bun.spawn(['bun', 'run', CORE_EXTRACTOR, schemaIndexPath, domainDir], {
-      cwd: domainDir,
-      stdout: 'pipe',
-      stderr: 'pipe',
-    })
-    const timer = setTimeout(() => proc.kill(9), timeoutMs)
-    const out = await new Response(proc.stdout).text()
-    await proc.exited
-    clearTimeout(timer)
-
-    if (!out.trim()) {
-      const err = await new Response(proc.stderr).text()
-      return {
-        ok: false,
-        core: null,
-        error: { message: err.trim() || 'core extractor produced no output' },
-      }
-    }
-    const parsed = JSON.parse(out)
-    if (!parsed.ok)
-      return { ok: false, core: null, error: parsed.error ?? { message: 'core extraction failed' } }
-    return { ok: true, core: (parsed.core ?? null) as CoreExtractResult['core'] }
-  } catch (e: any) {
-    return { ok: false, core: null, error: { message: String(e?.message ?? e) } }
-  }
-}