@astrale-os/cli 1.0.0-beta.2 → 1.0.0-beta.20

package/studio/server/domain.test.ts

@@ -1,14 +1,14 @@
-import { afterEach, 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 { basename, join } from 'node:path'
 
-import { resolveTarget } from './detect'
 import {
   depsInstalled,
   isDomainDir,
   registerDomain,
-  resolveDomainEntry,
+  resolveApplicationEntry,
+  resolveSchemaEntry,
   unregisterDomain,
 } from './domain'
 
@@ -20,76 +20,58 @@ afterEach(() => {
   while (roots.length) rmSync(roots.pop()!, { recursive: true, force: true })
 })
 
-function fixture(entry: 'implementation.ts' | 'domain.ts', parent = tmpdir()): string {
-  const root = mkdtempSync(join(parent, 'studio-domain-layout-'))
+function fixture(nested = false): string {
+  const root = mkdtempSync(join(tmpdir(), 'studio-application-layout-'))
   roots.push(root)
-  mkdirSync(join(root, 'schema'), { recursive: true })
-  writeFileSync(join(root, 'astrale.config.ts'), 'export default {}\n')
-  writeFileSync(join(root, entry), 'export const domain = {}\n')
-  writeFileSync(join(root, 'schema/index.ts'), 'export const schema = {}\n')
+  const owner = nested ? join(root, 'domain') : root
+  mkdirSync(join(owner, 'schema'), { recursive: true })
+  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 default {}\n')
+  writeFileSync(join(owner, 'schema/index.ts'), 'export const schema = {}\n')
   return root
 }
 
-test('detects the current implementation.ts layout and requires its SDK dependency', () => {
-  const root = fixture('implementation.ts')
-
-  expect(isDomainDir(root)).toBe(true)
-  expect(basename(resolveDomainEntry(root)!)).toBe('implementation.ts')
-  expect(depsInstalled(root)).toBe(false)
-
-  mkdirSync(join(root, 'node_modules', '@astrale-os', 'kernel-core'), { recursive: true })
-  expect(depsInstalled(root)).toBe(false)
-  mkdirSync(join(root, 'node_modules', '@astrale-os', 'sdk'), { recursive: true })
-  expect(depsInstalled(root)).toBe(true)
-
-  const handle = registerDomain(root)!
-  domainIds.push(handle.id)
-  expect(basename(handle.domainFile)).toBe('implementation.ts')
-  expect(resolveTarget(root).map((domain) => domain.root)).toEqual([root])
-})
-
-test('preserves domain.ts and kernel-core as the legacy fallback', () => {
-  const root = fixture('domain.ts')
-  mkdirSync(join(root, 'node_modules', '@astrale-os', 'kernel-core'), { recursive: true })
-
-  expect(isDomainDir(root)).toBe(true)
-  expect(depsInstalled(root)).toBe(true)
-  const handle = registerDomain(root)!
-  domainIds.push(handle.id)
-  expect(basename(handle.domainFile)).toBe('domain.ts')
-})
-
-test('prefers implementation.ts when both composition entries exist', () => {
-  const root = fixture('domain.ts')
-  writeFileSync(join(root, 'implementation.ts'), 'export const domain = {}\n')
-
-  expect(basename(resolveDomainEntry(root)!)).toBe('implementation.ts')
-})
+describe('SDK V1 project discovery', () => {
+  test('discovers conventional root Application and Schema entries', () => {
+    const root = fixture()
+    expect(isDomainDir(root)).toBe(true)
+    expect(basename(resolveApplicationEntry(root)!)).toBe('application.ts')
+    expect(basename(resolveSchemaEntry(root, resolveApplicationEntry(root)!)!)).toBe('index.ts')
+    const handle = registerDomain(root)!
+    domainIds.push(handle.id)
+    expect(basename(handle.applicationFile)).toBe('application.ts')
+    expect(handle.schemaDirName).toBe('schema')
+  })
 
-test('recognizes only an SDK that resolves from the Domain through an autonomous hoist', () => {
-  const isolatedWorkspace = mkdtempSync(join(tmpdir(), 'studio-domain-no-hoist-'))
-  roots.push(isolatedWorkspace)
-  mkdirSync(join(isolatedWorkspace, 'packages'))
-  const isolatedRoot = fixture('implementation.ts', join(isolatedWorkspace, 'packages'))
-  expect(depsInstalled(isolatedRoot)).toBe(false)
+  test('follows a config-imported nested Application and adjacent Schema', () => {
+    const root = fixture(true)
+    const application = resolveApplicationEntry(root)!
+    expect(application).toBe(join(root, 'domain/application.ts'))
+    expect(resolveSchemaEntry(root, application)).toBe(join(root, 'domain/schema/index.ts'))
+  })
 
-  const hoistedWorkspace = mkdtempSync(join(tmpdir(), 'studio-domain-hoist-'))
-  roots.push(hoistedWorkspace)
-  mkdirSync(join(hoistedWorkspace, 'packages'))
-  mkdirSync(join(hoistedWorkspace, 'node_modules', '@astrale-os', 'sdk'), { recursive: true })
-  writeFileSync(
-    join(hoistedWorkspace, 'node_modules', '@astrale-os', 'sdk', 'package.json'),
-    JSON.stringify({
-      name: '@astrale-os/sdk',
-      type: 'module',
-      exports: { './schema': './schema.js' },
-    }),
-  )
-  writeFileSync(
-    join(hoistedWorkspace, 'node_modules', '@astrale-os', 'sdk', 'schema.js'),
-    'export const schema = {}\n',
-  )
-  const hoistedRoot = fixture('implementation.ts', join(hoistedWorkspace, 'packages'))
+  test('requires the semantic SDK dependency, not Kernel implementation packages', () => {
+    const root = fixture()
+    expect(depsInstalled(root)).toBe(false)
+    mkdirSync(join(root, 'node_modules', '@astrale-os', 'kernel-core'), { recursive: true })
+    expect(depsInstalled(root)).toBe(false)
+    mkdirSync(join(root, 'node_modules', '@astrale-os', 'sdk'), { recursive: true })
+    expect(depsInstalled(root)).toBe(true)
+  })
 
-  expect(depsInstalled(hoistedRoot)).toBe(true)
+  test('rejects implementation.ts and domain.ts compatibility layouts', () => {
+    const root = mkdtempSync(join(tmpdir(), 'studio-legacy-layout-'))
+    roots.push(root)
+    mkdirSync(join(root, 'schema'))
+    writeFileSync(join(root, 'astrale.config.ts'), 'export default {}\n')
+    writeFileSync(join(root, 'implementation.ts'), 'export default {}\n')
+    writeFileSync(join(root, 'domain.ts'), 'export default {}\n')
+    writeFileSync(join(root, 'schema/index.ts'), 'export const schema = {}\n')
+    expect(isDomainDir(root)).toBe(false)
+  })
 })

package/studio/server/domain.ts

@@ -1,74 +1,95 @@
-/**
- * domain.ts — DomainHandle resolution + the in-process registry. A "domain" is
- * confirmed by astrale.config.ts + a composition entry + <schemaDir>/index.ts.
- * Current SDK projects use implementation.ts; domain.ts remains the legacy
- * fallback. The schema dir is configurable (default 'schema') and threaded
- * everywhere.
- */
-import { existsSync } from 'node:fs'
-import { basename, join, resolve } from 'node:path'
+/** SDK V1 project discovery and the in-process Studio registry. */
+import { existsSync, readFileSync } from 'node:fs'
+import { basename, dirname, extname, join, relative, resolve } from 'node:path'
 
 export interface DomainHandle {
-  id: string
-  root: string
-  configFile: string
-  /** Active composition entry (implementation.ts when present, otherwise legacy domain.ts). */
-  domainFile: string
-  schemaDirName: string
-  schemaDir: string
-  schemaIndex: string
+  readonly id: string
+  readonly root: string
+  readonly configFile: string
+  readonly applicationFile: string
+  readonly schemaDirName: string
+  readonly schemaDir: string
+  readonly schemaIndex: string
   origin?: string
 }
 
 const registry = new Map<string, DomainHandle>()
 
-export const DOMAIN_ENTRY_FILES = ['implementation.ts', 'domain.ts'] as const
-
 export function makeId(root: string): string {
   return basename(resolve(root)).replace(/[^a-zA-Z0-9_-]/g, '-') || 'domain'
 }
 
-/** Resolve the current composition entry, preferring the SDK layout. */
-export function resolveDomainEntry(root: string): string | null {
-  const r = resolve(root)
-  for (const file of DOMAIN_ENTRY_FILES) {
-    const candidate = join(r, file)
-    if (existsSync(candidate)) return candidate
+/** Resolve the Application imported by config, with root application.ts as convention. */
+export function resolveApplicationEntry(root: string): string | null {
+  const project = resolve(root)
+  const conventional = join(project, 'application.ts')
+  if (existsSync(conventional)) return conventional
+  const config = join(project, 'astrale.config.ts')
+  if (!existsSync(config)) return null
+  let source: string
+  try {
+    source = readFileSync(config, 'utf8')
+  } catch {
+    return null
+  }
+  for (const match of source.matchAll(/\bfrom\s+['"]([^'"]+)['"]/gu)) {
+    const specifier = match[1]
+    if (
+      !specifier?.startsWith('.') ||
+      basename(specifier).replace(/\.[^.]+$/u, '') !== 'application'
+    ) {
+      continue
+    }
+    const selected = resolveSourceFile(project, specifier)
+    if (selected !== null) return selected
   }
   return null
 }
 
-/** The single definition of "is this dir an Astrale domain": the triple must all exist. */
+/** Resolve schema.ts or schema/index.ts beside the Application, then at project root. */
+export function resolveSchemaEntry(
+  root: string,
+  applicationFile: string,
+  schemaDirName = 'schema',
+): string | null {
+  const project = resolve(root)
+  const applicationDir = dirname(applicationFile)
+  const candidates = [
+    join(applicationDir, 'schema.ts'),
+    join(applicationDir, schemaDirName, 'index.ts'),
+    join(project, 'schema.ts'),
+    join(project, schemaDirName, 'index.ts'),
+  ]
+  return [...new Set(candidates)].find(existsSync) ?? null
+}
+
 export function isDomainDir(root: string, schemaDirName = 'schema'): boolean {
-  const r = resolve(root)
-  return (
-    existsSync(join(r, 'astrale.config.ts')) &&
-    resolveDomainEntry(r) !== null &&
-    existsSync(join(r, schemaDirName, 'index.ts'))
-  )
+  const project = resolve(root)
+  if (!existsSync(join(project, 'astrale.config.ts'))) return false
+  const application = resolveApplicationEntry(project)
+  return application !== null && resolveSchemaEntry(project, application, schemaDirName) !== null
 }
 
-/** Confirm + register a domain rooted at `root`. Returns null if the triple is incomplete. */
 export function registerDomain(root: string, schemaDirName = 'schema'): DomainHandle | null {
-  const r = resolve(root)
-  if (!isDomainDir(r, schemaDirName)) return null
-  const domainFile = resolveDomainEntry(r)
-  if (!domainFile) return null
-  const schemaDir = join(r, schemaDirName)
+  const project = resolve(root)
+  const applicationFile = resolveApplicationEntry(project)
+  if (applicationFile === null || !existsSync(join(project, 'astrale.config.ts'))) return null
+  const schemaIndex = resolveSchemaEntry(project, applicationFile, schemaDirName)
+  if (schemaIndex === null) return null
+  const schemaDir = dirname(schemaIndex)
   const handle: DomainHandle = {
-    id: makeId(r),
-    root: r,
-    configFile: join(r, 'astrale.config.ts'),
-    domainFile,
-    schemaDirName,
+    id: makeId(project),
+    root: project,
+    configFile: join(project, 'astrale.config.ts'),
+    applicationFile,
+    schemaDirName: relative(project, schemaDir).replaceAll('\\', '/') || '.',
     schemaDir,
-    schemaIndex: join(schemaDir, 'index.ts'),
+    schemaIndex,
   }
   registry.set(handle.id, handle)
   return handle
 }
 
-/** Drop a domain from the registry (its dir/triple is gone). */
 export function unregisterDomain(id: string): void {
   registry.delete(id)
 }
@@ -81,25 +102,23 @@ export function allDomains(): DomainHandle[] {
   return [...registry.values()]
 }
 
-/** Does the domain have the dependency cohort required by its project layout installed? */
+/** Studio's current project model always requires the semantic SDK Schema facade. */
 export function depsInstalled(root: string): boolean {
-  const installed = (packageDir: string, specifier: string): boolean => {
-    if (existsSync(join(root, 'node_modules', '@astrale-os', packageDir))) return true
-    try {
-      Bun.resolveSync(specifier, root)
-      return true
-    } catch {
-      return false
-    }
+  if (existsSync(join(root, 'node_modules', '@astrale-os', 'sdk'))) return true
+  try {
+    Bun.resolveSync('@astrale-os/sdk/schema', root)
+    return true
+  } catch {
+    return false
   }
+}
 
-  // A workspace may hoist the package above the Domain root. Check both the
-  // conventional local link and Bun's real resolver from the Domain boundary.
-  const sdk = installed('sdk', '@astrale-os/sdk/schema')
-  const entry = resolveDomainEntry(root)
-
-  // implementation.ts is an SDK boundary by contract. Legacy domain.ts
-  // projects may predate the SDK facade and depend on kernel-core directly.
-  if (entry?.endsWith('implementation.ts')) return sdk
-  return sdk || installed('kernel-core', '@astrale-os/kernel-core')
+function resolveSourceFile(root: string, specifier: string): string | null {
+  const absolute = resolve(root, specifier)
+  const extension = extname(absolute)
+  const candidates =
+    extension === ''
+      ? [`${absolute}.ts`, join(absolute, 'index.ts')]
+      : [absolute, `${absolute.slice(0, -extension.length)}.ts`]
+  return candidates.find(existsSync) ?? null
 }

package/studio/server/handoff/copy.ts

@@ -10,7 +10,7 @@ import type { Comment, ContextItem, DocMeta, SchemaRevision, ThreadEntry } from
 interface CopyParts {
   origin: string
   root: string
-  /** Studio render fingerprint retained by the legacy annotate machine-state. */
+  /** Studio render fingerprint retained by the handoff machine-state. */
   renderFingerprint: string
   schemaRevision?: SchemaRevision
   openComments: Comment[]

package/studio/server/index.ts

@@ -42,7 +42,7 @@ const domains = resolveTarget(target, schemaDir)
 if (!domains.length) {
   console.error(`\n  ✗ No Astrale domains found at ${target}`)
   console.error(
-    `    (looking for: astrale.config.ts + implementation.ts (or legacy domain.ts) + ${schemaDir}/index.ts)\n`,
+    `    (looking for: astrale.config.ts + application.ts + schema.ts or ${schemaDir}/index.ts)\n`,
   )
   process.exit(1)
 }

package/studio/server/instances/probe.test.ts

@@ -21,7 +21,7 @@ describe('installed Domain introspection', () => {
     ])
   })
 
-  test('retains the complete installed Bundle for cohort SDK admission', () => {
+  test('retains the complete installed Bundle for installed SDK admission', () => {
     const root = {
       version: 'v1',
       domain: 'issues.astrale.ai',

package/studio/server/introspect/anatomy/views/routes.ts

@@ -1,9 +1,9 @@
-import { existsSync } from 'node:fs'
 import { join, relative } from 'node:path'
 import { Node, type SourceFile, SyntaxKind } from 'ts-morph'
 
 import type { ViewInfo } from '../../../../shared/types'
 
+import { resolveApplicationEntry } from '../../../domain'
 import { defineSchemaCalls, schemaProject } from '../schema-definition'
 import {
   addSource,
@@ -44,27 +44,29 @@ export function buildSchemaViewSources(root: string, schemaDirName: string): Map
   return sources
 }
 
-function frontendKind(
-  frontendName: string,
-  input: Node,
-  source: SourceFile,
-): { kind: ViewInfo['kind']; external: boolean } {
-  if (frontendName === 'reactFrontend') return { kind: 'spa', external: false }
-  const sourceName = callName(objectProperty(input, 'source', source))
-  if (sourceName === 'generatedFrontend') return { kind: 'inline-html', external: false }
-  if (sourceName === 'viteFrontend' || sourceName === 'prebuiltFrontend') {
-    return { kind: 'spa', external: false }
-  }
-  if (sourceName === 'externalFrontend') return { kind: 'spa', external: true }
-  return { kind: 'unknown', external: false }
+function defaultRoute(name: string): string {
+  return `/${name
+    .replace(/([a-z0-9])([A-Z])/gu, '$1-$2')
+    .replace(/[_\s]+/gu, '-')
+    .toLowerCase()}`
+}
+
+function frontendSource(input: Node, source: SourceFile): { externalOrigin?: string } {
+  const value = objectProperty(input, 'source', source)
+  if (!value || !Node.isCallExpression(value)) return {}
+  if (callName(value) !== 'external') return {}
+  const origin = literalString(value.getArguments()[0], source)
+  return origin === undefined ? {} : { externalOrigin: origin }
 }
 
-export function buildFrontendViews(root: string): ViewInfo[] {
+export function buildFrontendViews(
+  root: string,
+  canonicalViewNames: readonly string[],
+): ViewInfo[] {
   const project = makeProject()
-  const compositionFiles = ['implementation.ts', 'domain.ts']
-    .map((file) => join(root, file))
-    .filter((file) => existsSync(file))
-  const sources = [...new Set([...listSourceFiles(join(root, 'views')), ...compositionFiles])]
+  const application = resolveApplicationEntry(root)
+  const applicationFiles = application === null ? [] : [application]
+  const sources = [...new Set([...listSourceFiles(join(root, 'views')), ...applicationFiles])]
     .map((file) => addSource(project, file))
     .filter((source): source is SourceFile => source !== null)
   const views: ViewInfo[] = []
@@ -72,30 +74,37 @@ export function buildFrontendViews(root: string): ViewInfo[] {
   for (const source of sources) {
     for (const call of source.getDescendantsOfKind(SyntaxKind.CallExpression)) {
       const frontendName = callName(call)
-      if (frontendName !== 'frontendArtifact' && frontendName !== 'reactFrontend') continue
+      if (frontendName !== 'defineFrontend') continue
       const input = objectValue(call.getArguments()[0], source)
       if (!input) continue
       const routes = objectValue(objectProperty(input, 'routes', source) ?? undefined, source)
-      if (!routes || !Node.isObjectLiteralExpression(routes)) continue
-      const artifact = frontendKind(frontendName, input, source)
-
-      for (const property of routes.getProperties()) {
-        const slug = propertySlug(property)
-        const routeValue = propertyValue(property, source)
-        if (!slug || !routeValue) continue
-        const routeName = callName(routeValue)
-        const routeInput = Node.isCallExpression(routeValue)
-          ? objectValue(routeValue.getArguments()[0], source)
-          : objectValue(routeValue, source)
-        if (!routeInput) continue
+      const declared = new Map<string, string>()
+      if (routes && Node.isObjectLiteralExpression(routes)) {
+        for (const property of routes.getProperties()) {
+          const slug = propertySlug(property)
+          const routeValue = propertyValue(property, source)
+          if (!slug || !routeValue) continue
+          const direct = literalString(routeValue, source)
+          const routeInput = objectValue(routeValue, source)
+          const path =
+            direct ??
+            (routeInput
+              ? literalString(objectProperty(routeInput, 'path', source) ?? undefined, source)
+              : undefined)
+          if (path) declared.set(slug, path)
+        }
+      }
+      const frontend = frontendSource(input, source)
 
-        const path = literalString(objectProperty(routeInput, 'path', source) ?? undefined, source)
-        const href = literalString(objectProperty(routeInput, 'href', source) ?? undefined, source)
+      for (const slug of canonicalViewNames) {
+        const path = declared.get(slug) ?? defaultRoute(slug)
+        const url = frontend.externalOrigin
+          ? new URL(path, `${frontend.externalOrigin}/`).toString()
+          : undefined
         views.push({
           slug,
-          kind: routeName === 'reactRoute' ? 'spa' : artifact.kind,
-          ...(href ? { url: href } : { url: undefined }),
-          ...(!href && (path || !artifact.external) ? { mount: path ?? `/ui/${slug}` } : {}),
+          kind: 'spa',
+          ...(url ? { url } : { mount: path }),
           file: relative(root, source.getFilePath()).replaceAll('\\', '/'),
         })
       }

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

@@ -1,6 +1,5 @@
 import type { SchemaIR, ViewInfo } from '../../../shared/types'
 
-import { buildLegacyViews } from './views/legacy'
 import { buildFrontendViews, buildSchemaViewSources } from './views/routes'
 
 function mergeRoute(target: ViewInfo, incoming: ViewInfo): void {
@@ -30,7 +29,7 @@ function canonicalViewInfo(slug: string, view: NonNullable<SchemaIR['views']>[st
  * Join canonical View definitions with route/source metadata. Passing a
  * canonical map (including an empty map) makes it authoritative: static routes
  * cannot invent Views or override identity, target, auth, or description.
- * Without it, the legacy defineView registry remains the compatibility source.
+ * Without admitted canonical Views, Studio does not invent authoring semantics.
  */
 export function buildViews(
   root: string,
@@ -38,21 +37,17 @@ export function buildViews(
   canonicalViews?: NonNullable<SchemaIR['views']>,
 ): ViewInfo[] {
   const merged = new Map<string, ViewInfo>()
-  if (canonicalViews !== undefined) {
-    for (const [slug, view] of Object.entries(canonicalViews)) {
-      merged.set(slug, canonicalViewInfo(slug, view))
-    }
-    for (const [slug, file] of buildSchemaViewSources(root, _schemaDirName)) {
-      const current = merged.get(slug)
-      if (current) current.file = file
-    }
-  } else {
-    for (const view of buildLegacyViews(root)) merged.set(view.slug, view)
+  const admittedViews = canonicalViews ?? {}
+  for (const [slug, view] of Object.entries(admittedViews)) {
+    merged.set(slug, canonicalViewInfo(slug, view))
   }
-  for (const view of buildFrontendViews(root)) {
+  for (const [slug, file] of buildSchemaViewSources(root, _schemaDirName)) {
+    const current = merged.get(slug)
+    if (current) current.file = file
+  }
+  for (const view of buildFrontendViews(root, Object.keys(admittedViews))) {
     const current = merged.get(view.slug)
     if (current) mergeRoute(current, view)
-    else if (canonicalViews === undefined) merged.set(view.slug, view)
   }
   return [...merged.values()]
 }