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

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

@@ -6,28 +6,36 @@ import { join } from 'node:path'
 import { buildAnatomy } from './anatomy'
 
 const roots: string[] = []
-
 afterEach(() => {
   for (const root of roots.splice(0)) rmSync(root, { recursive: true, force: true })
 })
 
-function project(entry: 'implementation.ts' | 'domain.ts') {
-  const root = mkdtempSync(join(tmpdir(), 'studio-anatomy-entry-'))
+function project(nested: boolean) {
+  const root = mkdtempSync(join(tmpdir(), 'studio-anatomy-application-'))
   roots.push(root)
-  mkdirSync(join(root, 'schema'), { recursive: true })
+  const owner = nested ? join(root, 'domain') : root
+  mkdirSync(join(owner, 'schema'), { recursive: true })
   writeFileSync(join(root, 'package.json'), '{}\n')
-  writeFileSync(join(root, 'astrale.config.ts'), 'export default {}\n')
-  writeFileSync(join(root, entry), 'export const domain = {}\n')
-  writeFileSync(join(root, 'schema/index.ts'), "defineSchema('example.astrale.ai', {})\n")
-  return root
+  writeFileSync(
+    join(root, 'astrale.config.ts'),
+    nested
+      ? "import application from './domain/application.js'\nexport default { application }\n"
+      : 'export default {}\n',
+  )
+  writeFileSync(join(owner, 'application.ts'), 'export const application = {}\n')
+  writeFileSync(
+    join(owner, 'schema/index.ts'),
+    "defineSchema('example.astrale.ai', { classes: {} })\n",
+  )
+  return { root, schemaDirName: nested ? 'domain/schema' : 'schema' }
 }
 
-test('overview anchors current projects to implementation.ts', () => {
-  const anatomy = buildAnatomy({ root: project('implementation.ts'), schemaDirName: 'schema' })
-  expect(anatomy.overview.compositionFile).toBe('implementation.ts')
+test('overview anchors a root Application', () => {
+  const input = project(false)
+  expect(buildAnatomy(input).overview.applicationFile).toBe('application.ts')
 })
 
-test('overview preserves domain.ts as the legacy composition entry', () => {
-  const anatomy = buildAnatomy({ root: project('domain.ts'), schemaDirName: 'schema' })
-  expect(anatomy.overview.compositionFile).toBe('domain.ts')
+test('overview preserves the config-imported nested Application path', () => {
+  const input = project(true)
+  expect(buildAnatomy(input).overview.applicationFile).toBe('domain/application.ts')
 })

package/studio/server/introspect/anatomy.ts

@@ -10,24 +10,33 @@
 import { existsSync, readFileSync, readdirSync, statSync } from 'node:fs'
 import { join, relative } from 'node:path'
 
-import type { DomainAnatomy, DomainOverview } from '../../shared/types'
+import type { DomainAnatomy, DomainOverview, SchemaIR } from '../../shared/types'
 
+import { resolveApplicationEntry } from '../domain'
+import { asJsonRecord, asString, parseJson } from '../json'
 import { readSettings } from '../state/settings'
 import { buildClientTree, buildEnvFields, buildViews, findSchemaDefinition } from './anatomy-extras'
+import { readConfigPreview } from './config-preview'
 
 export interface AnatomyArgs {
   root: string
   schemaDirName: string
   clientDir?: string
+  canonicalViews?: NonNullable<SchemaIR['views']>
 }
 
-export function buildAnatomy({ root, schemaDirName, clientDir }: AnatomyArgs): DomainAnatomy {
+export function buildAnatomy({
+  root,
+  schemaDirName,
+  clientDir,
+  canonicalViews,
+}: AnatomyArgs): DomainAnatomy {
   const schema = findSchemaDefinition(root, schemaDirName)
   const authoredClientDir =
     clientDir ?? (existsSync(join(root, 'ui')) ? join(root, 'ui') : undefined)
   return {
     overview: buildOverview(root, schemaDirName, authoredClientDir, schema?.origin),
-    views: buildViews(root, schemaDirName),
+    views: buildViews(root, schemaDirName, canonicalViews),
     client: buildClientTree(root, clientDir ?? null),
     env: buildEnvFields(root),
     detectedIntegrations: detectIntegrations(root),
@@ -40,7 +49,7 @@ function buildOverview(
   clientDir?: string,
   schemaOrigin?: string,
 ): DomainOverview {
-  const pkg = readJsonSafe(join(root, 'package.json'))
+  const pkg = readPackageJsonSafe(join(root, 'package.json'))
   const astraleDeps: Record<string, string> = {}
   for (const [k, v] of Object.entries({
     ...(pkg?.dependencies ?? {}),
@@ -49,26 +58,13 @@ function buildOverview(
     if (k.startsWith('@astrale-os/')) astraleDeps[k] = String(v)
   }
 
-  const config = readTextSafe(join(root, 'astrale.config.ts'))
-  let adapter: DomainOverview['adapter'] = 'unknown'
-  if (/\bastrale\s*\(/.test(config)) adapter = 'astrale'
-  else if (/\bcloudflare\s*\(/.test(config)) adapter = 'cloudflare'
+  const config = readConfigPreview(root)
 
-  const instance = config.match(/instance\s*:\s*['"]([^'"]+)['"]/)?.[1]
-  const route = config.match(/route\s*:\s*['"]([^'"]+)['"]/)?.[1]
-  const devSecrets =
-    config.match(/dev\s*:\s*\{[^}]*secrets\s*:\s*['"]([^'"]+)['"]/)?.[1] ??
-    config.match(/secrets\s*:\s*['"]([^'"]+)['"]/)?.[1]
-
-  const compositionFile = existsSync(join(root, 'implementation.ts'))
-    ? 'implementation.ts'
-    : existsSync(join(root, 'domain.ts'))
-      ? 'domain.ts'
-      : undefined
-  const domainSrc = compositionFile ? readTextSafe(join(root, compositionFile)) : ''
+  const application = resolveApplicationEntry(root)
+  const applicationSrc = application === null ? '' : readTextSafe(application)
   const origin =
     schemaOrigin ??
-    domainSrc.match(/defineSchema\(\s*['"]([^'"]+)['"]/)?.[1] ??
+    applicationSrc.match(/defineSchema\(\s*['"]([^'"]+)['"]/)?.[1] ??
     readTextSafe(join(root, schemaDirName, 'index.ts')).match(
       /defineSchema\(\s*['"]([^'"]+)['"]/,
     )?.[1] ??
@@ -76,11 +72,11 @@ function buildOverview(
 
   return {
     origin,
-    compositionFile,
-    adapter,
-    prodTarget: instance ? `instance: ${instance}` : route ? `route: ${route}` : undefined,
-    devSecrets,
-    postInstall: undefined,
+    applicationFile:
+      application === null ? undefined : relative(root, application).replaceAll('\\', '/'),
+    adapter: config.adapter,
+    prodTarget: config.prodTarget,
+    devSecrets: config.devSecrets,
     requires: [],
     packageName: pkg?.name,
     packageVersion: pkg?.version,
@@ -114,9 +110,37 @@ function readTextSafe(f: string): string {
   }
 }
 
-function readJsonSafe(f: string): any {
+interface PackageOverview {
+  name?: string
+  version?: string
+  dependencies?: Record<string, string>
+  devDependencies?: Record<string, string>
+}
+
+function decodeDependencyMap(value: unknown): Record<string, string> | undefined {
+  const record = asJsonRecord(value)
+  if (!record) return undefined
+  return Object.fromEntries(
+    Object.entries(record).filter(
+      (entry): entry is [string, string] => typeof entry[1] === 'string',
+    ),
+  )
+}
+
+function readPackageJsonSafe(f: string): PackageOverview | null {
   try {
-    return JSON.parse(readFileSync(f, 'utf8'))
+    const record = asJsonRecord(parseJson(readFileSync(f, 'utf8')))
+    if (!record) return null
+    const name = asString(record.name)
+    const version = asString(record.version)
+    const dependencies = decodeDependencyMap(record.dependencies)
+    const devDependencies = decodeDependencyMap(record.devDependencies)
+    return {
+      ...(name === undefined ? {} : { name }),
+      ...(version === undefined ? {} : { version }),
+      ...(dependencies === undefined ? {} : { dependencies }),
+      ...(devDependencies === undefined ? {} : { devDependencies }),
+    }
   } catch {
     return null
   }

package/studio/server/introspect/bundle.ts

@@ -1,6 +1,6 @@
 /**
  * bundle.ts — assembles the StudioSchemaBundle: runtime IR (PRIMARY) + ts-morph
- * overlay + schemaHash + deps-installed precondition. Never throws; a failed
+ * overlay + render fingerprint + deps-installed precondition. Never throws; a failed
  * runtime import becomes a render-state error (with the overlay still computed
  * statically, so anchors/handler-links survive a mid-edit compile break).
  */
@@ -8,7 +8,7 @@ import type { StudioSchemaBundle } from '../../shared/types'
 
 import { type DomainHandle, depsInstalled } from '../domain'
 import { readSettings } from '../state/settings'
-import { schemaHashOf } from './hash'
+import { renderFingerprintOf } from './hash'
 import { buildOverlay } from './overlay'
 import { runtimeExtract } from './runtime'
 
@@ -16,7 +16,8 @@ export async function buildBundle(handle: DomainHandle): Promise<StudioSchemaBun
   const installed = depsInstalled(handle.root)
   let ir = null
   let schemaRoot: unknown | undefined
-  let importedInterfaces: StudioSchemaBundle['importedInterfaces']
+  let schemaMode: StudioSchemaBundle['schemaMode'] = 'unavailable'
+  let schemaRevision: StudioSchemaBundle['schemaRevision']
   let error: StudioSchemaBundle['error'] = null
   let extractedBy: StudioSchemaBundle['extractedBy'] = 'runtime-bun'
 
@@ -29,7 +30,8 @@ export async function buildBundle(handle: DomainHandle): Promise<StudioSchemaBun
     if (r.ok) {
       ir = r.ir
       if (r.root !== null) schemaRoot = r.root
-      importedInterfaces = r.importedInterfaces
+      schemaMode = r.schemaMode
+      if (r.revision !== null) schemaRevision = r.revision
     } else {
       error = { message: r.error?.message ?? 'schema failed to compile' }
       extractedBy = 'static-tsmorph-fallback'
@@ -44,19 +46,23 @@ export async function buildBundle(handle: DomainHandle): Promise<StudioSchemaBun
 
   const overlay = buildOverlay({ ir, domainRoot: handle.root, schemaDir: handle.schemaDir })
   if (ir) handle.origin = ir.domain
+  const renderFingerprint =
+    schemaRoot !== undefined
+      ? renderFingerprintOf(schemaRoot)
+      : ir
+        ? renderFingerprintOf(ir)
+        : 'sha-none'
 
   return {
     domainId: handle.id,
-    // The Kernel installs the canonical DomainSchema root, not the Studio's
-    // lossy render projection. Legacy domains have no root and retain IR hashing.
-    schemaHash:
-      schemaRoot !== undefined ? schemaHashOf(schemaRoot) : ir ? schemaHashOf(ir) : 'sha-none',
+    renderFingerprint,
+    schemaMode,
+    ...(schemaRevision === undefined ? {} : { schemaRevision }),
     extractedBy,
     depsInstalled: installed,
     ir,
     ...(schemaRoot === undefined ? {} : { schemaRoot }),
     overlay,
-    importedInterfaces,
     error,
     extractedAt: new Date().toISOString(),
   }