@astrale-os/cli 1.0.0-beta.0 → 1.0.0-beta.10

package/studio/server/introspect/config-preview.test.ts

@@ -0,0 +1,32 @@
+import { expect, test } from 'bun:test'
+
+import { parseConfigPreview } from './config-preview'
+
+test('config preview ignores examples in comments and preserves URL literals', () => {
+  const preview = parseConfigPreview(`
+// cloudflare({ prod: { route: 'commented.invalid', secrets: '.env.fake' } })
+/* astrale({ prod: { instance: 'commented-instance' } }) */
+export default deploy(domain, cloudflare({
+  dev: { client: { dir: 'client' }, secrets: '.env.dev' },
+  prod: {
+    client: { dir: 'client' },
+    route: 'https://services.example.dev/path',
+    secrets: '.env.prod',
+  },
+}))
+`)
+
+  expect(preview).toEqual({
+    adapter: 'cloudflare',
+    prodTarget: 'route: https://services.example.dev/path',
+    devSecrets: '.env.dev',
+    configuredSecretFiles: ['.env.dev', '.env.prod'],
+  })
+})
+
+test('config preview reports dynamic configuration as unknown instead of inventing authority', () => {
+  expect(parseConfigPreview(`export default makeDeployment(domain)`)).toEqual({
+    adapter: 'unknown',
+    configuredSecretFiles: [],
+  })
+})

package/studio/server/introspect/config-preview.ts

@@ -0,0 +1,119 @@
+/**
+ * Static, non-authoritative preview of astrale.config.ts.
+ *
+ * Deployment configuration is owned by the SDK adapter and is executable
+ * TypeScript. Studio deliberately does not execute it during anatomy/env reads;
+ * these few fields are only display/editor hints and may be unknown when the
+ * configuration is computed dynamically.
+ */
+import { readFileSync } from 'node:fs'
+import { join } from 'node:path'
+
+export interface ConfigPreview {
+  adapter: 'astrale' | 'cloudflare' | 'unknown'
+  prodTarget?: string
+  devSecrets?: string
+  configuredSecretFiles: string[]
+}
+
+function withoutComments(source: string): string {
+  let output = ''
+  let quote: "'" | '"' | '`' | null = null
+  let escaped = false
+  for (let index = 0; index < source.length; index++) {
+    const char = source[index]!
+    const next = source[index + 1]
+    if (quote) {
+      output += char
+      if (escaped) escaped = false
+      else if (char === '\\') escaped = true
+      else if (char === quote) quote = null
+      continue
+    }
+    if (char === "'" || char === '"' || char === '`') {
+      quote = char
+      output += char
+      continue
+    }
+    if (char === '/' && next === '/') {
+      while (index + 1 < source.length && source[index + 1] !== '\n') index++
+      continue
+    }
+    if (char === '/' && next === '*') {
+      index += 2
+      while (index < source.length && !(source[index] === '*' && source[index + 1] === '/')) {
+        if (source[index] === '\n') output += '\n'
+        index++
+      }
+      index++
+      continue
+    }
+    output += char
+  }
+  return output
+}
+
+function stringField(source: string, name: string): string | undefined {
+  const match = new RegExp(`\\b${name}\\s*:\\s*(['"])(.*?)\\1`).exec(source)
+  return match?.[2]
+}
+
+function objectBody(source: string, name: string): string | undefined {
+  const start = new RegExp(`\\b${name}\\s*:\\s*\\{`).exec(source)
+  if (!start) return undefined
+  const opening = source.indexOf('{', start.index)
+  let depth = 1
+  let quote: "'" | '"' | '`' | null = null
+  let escaped = false
+  for (let index = opening + 1; index < source.length; index++) {
+    const char = source[index]!
+    if (quote) {
+      if (escaped) escaped = false
+      else if (char === '\\') escaped = true
+      else if (char === quote) quote = null
+      continue
+    }
+    if (char === "'" || char === '"' || char === '`') {
+      quote = char
+      continue
+    }
+    if (char === '{') depth++
+    else if (char === '}' && --depth === 0) return source.slice(opening + 1, index)
+  }
+  return undefined
+}
+
+export function parseConfigPreview(source: string): ConfigPreview {
+  const active = withoutComments(source)
+  const adapter: ConfigPreview['adapter'] = /\bastrale\s*\(/.test(active)
+    ? 'astrale'
+    : /\bcloudflare\s*\(/.test(active)
+      ? 'cloudflare'
+      : 'unknown'
+  const prod = objectBody(active, 'prod') ?? active
+  const dev = objectBody(active, 'dev') ?? ''
+  const instance = stringField(prod, 'instance')
+  const route = stringField(prod, 'route')
+  const configuredSecretFiles = [...active.matchAll(/\bsecrets\s*:\s*(['"])(.*?)\1/g)].map(
+    (match) => match[2]!,
+  )
+  const devSecrets = stringField(dev, 'secrets')
+  return {
+    adapter,
+    ...(instance
+      ? { prodTarget: `instance: ${instance}` }
+      : route
+        ? { prodTarget: `route: ${route}` }
+        : {}),
+    ...(devSecrets ? { devSecrets } : {}),
+    configuredSecretFiles: [...new Set(configuredSecretFiles)],
+  }
+}
+
+export function readConfigPreview(root: string): ConfigPreview {
+  try {
+    return parseConfigPreview(readFileSync(join(root, 'astrale.config.ts'), 'utf8'))
+  } catch {
+    return { adapter: 'unknown', configuredSecretFiles: [] }
+  }
+}

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

@@ -2,27 +2,27 @@ import { describe, expect, test } from 'bun:test'
 
 import type { IrClass, IrFunction, SchemaIR } from '../../shared/types'
 
-import { classify, diffSchemas } from './diff'
+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 => ({
@@ -31,21 +31,19 @@ const withClass = (member: IrClass): SchemaIR => ({
 })
 
 describe('canonical standalone Function diffs', () => {
-  test('classifies addition as additive and removal as breaking', () => {
+  test('reports additions and removals without claiming Runtime compatibility', () => {
     const empty = schema({})
     const populated = schema({ inspect: callable() })
-    expect(diffSchemas(empty, populated)).toEqual([
-      { kind: 'function-added', target: 'inspect', breaking: false },
-    ])
+    expect(diffSchemas(empty, populated)).toEqual([{ kind: 'function-added', target: 'inspect' }])
     const removed = diffSchemas(populated, empty)
-    expect(removed).toEqual([{ kind: 'function-removed', target: 'inspect', breaking: true }])
-    expect(classify(removed)).toBe('breaking')
+    expect(removed).toEqual([{ kind: 'function-removed', target: 'inspect' }])
+    expect(structuralStatusOf(removed)).toBe('changed')
   })
 
   test('detects a standalone Function signature change', () => {
     expect(
       diffSchemas(schema({ inspect: callable() }), schema({ inspect: callable('number') })),
-    ).toEqual([{ kind: 'function-signature-changed', target: 'inspect', breaking: true }])
+    ).toEqual([{ kind: 'function-signature-changed', target: 'inspect' }])
   })
 
   test('detects auth and output-mode changes in callable contracts', () => {
@@ -57,7 +55,7 @@ describe('canonical standalone Function diffs', () => {
     }
 
     expect(diffSchemas(schema({ inspect: before }), schema({ inspect: after }))).toEqual([
-      { kind: 'function-signature-changed', target: 'inspect', breaking: true },
+      { kind: 'function-signature-changed', target: 'inspect' },
     ])
   })
 
@@ -65,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: {},
@@ -75,13 +75,11 @@ describe('canonical standalone Function diffs', () => {
         kind: 'prop-schema-changed',
         target: 'Person.name',
         detail: 'value constraints changed',
-        breaking: true,
       },
       {
         kind: 'prop-required-changed',
         target: 'Person.name',
         detail: 'optional → required',
-        breaking: true,
       },
     ])
   })
@@ -91,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: {},