@astrale-os/cli 0.8.1-alpha.6 → 1.0.0-beta.0

package/studio/server/state/views.ts

@@ -3,8 +3,8 @@
  *
  * Discovery and launches deliberately go through the public `astrale view`
  * and `astrale query` commands. The Studio therefore shares the CLI's real
- * View:resolve, identity, instance, delegation, proxy, and shell-handshake
- * behavior instead of maintaining a second preview implementation.
+ * View resolution, identity, instance, delegation, proxy, and Shell behavior
+ * instead of maintaining a second preview implementation.
  */
 import type {
   RememberedViewTarget,
@@ -16,7 +16,6 @@ import type {
   ViewTargetResult,
 } from '../../shared/types'
 
-import { ensureViewDevServer } from '../view-dev-server'
 import { activeInstanceName } from './instance'
 import { readJson, writeJson } from './store'
 
@@ -50,10 +49,6 @@ interface RawQueryResult {
 // commands and make the close complete before the next open allocates a port.
 let viewSessionCommandTail: Promise<void> = Promise.resolve()
 
-export function localViewUrl(serverUrl: string, mount: string): string {
-  return new URL(mount.replace(/^\//, ''), `${new URL(serverUrl).origin}/`).toString()
-}
-
 export async function getViewRuntime(
   root: string,
   origin: string,
@@ -62,49 +57,70 @@ export async function getViewRuntime(
   timeoutMs: number,
 ): Promise<ViewRuntime> {
   const instance = await activeInstanceName()
-  const serverPromise = !instance
-    ? Promise.resolve({
-        status: 'unavailable' as const,
-        reason: 'Choose an Astrale instance before opening a local view.',
-      })
-    : view.mount
-      ? ensureViewDevServer(root)
-      : Promise.resolve({
-          status: 'unavailable' as const,
-          reason: 'This view has no local SPA mount.',
-        })
-
-  const targetRequired = viewClasses(view).length > 0
-  const targetsPromise = targetRequired
+  const targetRequired = viewDefinitionBindings(origin, view, bundle).length > 0
+  const targets = targetRequired
     ? instance
-      ? listViewTargets(root, origin, view, bundle, instance, timeoutMs)
-      : Promise.resolve<ViewTargetResult>({
+      ? await listViewTargets(root, origin, view, bundle, instance, timeoutMs)
+      : ({
           status: 'unavailable',
           items: [],
           selected: null,
           stale: null,
           truncated: false,
           reason: 'No active Astrale instance.',
-        })
-    : Promise.resolve<ViewTargetResult>({
+        } satisfies ViewTargetResult)
+    : ({
         status: 'available',
         items: [],
         selected: null,
         stale: null,
         truncated: false,
-      })
-
-  const [server, targets] = await Promise.all([serverPromise, targetsPromise])
+      } satisfies ViewTargetResult)
 
   return {
     slug: view.slug,
     instance,
     targetRequired,
-    server,
     targets,
   }
 }
 
+export function viewSessionArgs(
+  origin: string,
+  slug: string,
+  instance: string,
+  targetRef?: string,
+): string[] {
+  const args = ['view', `/:${assertOrigin(origin)}:view.${assertViewSlug(slug)}`]
+  if (targetRef) args.push('--target', targetRef)
+  args.push('--no-open', '--json', '-i', instance)
+  return args
+}
+
+interface OpenedViewPayload {
+  session?: {
+    id?: string
+    pageUrl?: string
+    view?: { route?: { href?: string } }
+  }
+}
+
+export function readyViewSession(
+  opened: OpenedViewPayload | null,
+  target: ViewTargetCandidate | null,
+): Extract<ViewSessionResult, { status: 'ready' }> | null {
+  const session = opened?.session
+  const viewUrl = session?.view?.route?.href
+  if (!session?.id || !session.pageUrl || !viewUrl) return null
+  return {
+    status: 'ready',
+    sessionId: session.id,
+    pageUrl: session.pageUrl,
+    viewUrl,
+    target,
+  }
+}
+
 export async function launchViewSession(
   root: string,
   origin: string,
@@ -115,12 +131,9 @@ export async function launchViewSession(
 ): Promise<ViewSessionResult> {
   const instance = await activeInstanceName()
   if (!instance) return { status: 'unavailable', reason: 'No active Astrale instance.' }
-  if (!view.mount) {
-    return { status: 'unavailable', reason: 'This view has no local SPA mount.' }
-  }
 
   let target: ViewTargetCandidate | null = null
-  if (viewClasses(view).length > 0) {
+  if (viewDefinitionBindings(origin, view, bundle).length > 0) {
     const targetId = typeof request.targetId === 'string' ? request.targetId.trim() : ''
     if (!targetId) return { status: 'unavailable', reason: 'Select a target before opening.' }
     const targets = await listViewTargets(root, origin, view, bundle, instance, timeoutMs)
@@ -136,26 +149,13 @@ export async function launchViewSession(
     }
   }
 
-  const server = await ensureViewDevServer(root)
-  if (server.status !== 'running') {
-    return {
-      status: 'unavailable',
-      reason: server.reason,
-    }
-  }
-
-  const args = ['view', '--view-url', localViewUrl(server.url, view.mount), '--handshake', 'shell']
-
-  if (target) {
-    args.push('--target', target.ref)
-  }
-
-  args.push('--no-open', '--json', '-i', instance)
-  const opened = await runViewSessionCommand<{
-    session?: { id?: string; pageUrl?: string; view?: { url?: string } }
-  }>(args, Math.max(20_000, timeoutMs + 12_000))
-  const session = opened.data?.session
-  if (!opened.ok || !session?.id || !session.pageUrl || !session.view?.url) {
+  const args = viewSessionArgs(origin, view.slug, instance, target?.ref)
+  const opened = await runViewSessionCommand<OpenedViewPayload>(
+    args,
+    Math.max(20_000, timeoutMs + 12_000),
+  )
+  const session = opened.ok ? readyViewSession(opened.data, target) : null
+  if (!session) {
     return {
       status: 'unavailable',
       reason: opened.detail || '`astrale view` could not start the preview session.',
@@ -163,13 +163,7 @@ export async function launchViewSession(
   }
 
   if (target) rememberTarget(root, instance, view.slug, target)
-  return {
-    status: 'ready',
-    sessionId: session.id,
-    pageUrl: session.pageUrl,
-    viewUrl: session.view.url,
-    target,
-  }
+  return session
 }
 
 export async function closeViewSession(sessionId: string): Promise<{ ok: true }> {
@@ -186,10 +180,7 @@ async function listViewTargets(
   instance: string,
   timeoutMs: number,
 ): Promise<ViewTargetResult> {
-  const bindings = viewClasses(view).map((className) => ({
-    className,
-    classOrigin: bundle?.ir?.imports[className]?.origin ?? origin,
-  }))
+  const bindings = viewDefinitionBindings(origin, view, bundle)
   if (bindings.length === 0) {
     return {
       status: 'available',
@@ -202,7 +193,7 @@ async function listViewTargets(
 
   const queried = await Promise.all(
     bindings.map(async (binding) => {
-      const definition = targetDefinition(binding.className, binding.classOrigin)
+      const definition = targetDefinition(binding.className, binding.classOrigin, binding.kind)
       const result = await runAstraleJson<RawQueryResult>(
         [
           'query',
@@ -294,12 +285,123 @@ export function targetFromRow(
   }
 }
 
-export function targetDefinition(className: string, classOrigin: string): string {
-  return `/:${assertOrigin(classOrigin)}:class.${assertSchemaName(className)}`
+export function targetDefinition(
+  className: string,
+  classOrigin: string,
+  kind: 'class' | 'interface' = 'class',
+): string {
+  return `/:${assertOrigin(classOrigin)}:${kind}.${assertSchemaName(className)}`
+}
+
+interface ViewDefinitionBinding {
+  className: string
+  classOrigin: string
+  kind: 'class' | 'interface'
+}
+
+/** Preserve exact canonical View target coordinates. The short-name anatomy
+ * fallback exists only for legacy defineView registries. */
+export function viewDefinitionBindings(
+  origin: string,
+  view: ViewInfo,
+  bundle: StudioSchemaBundle | null,
+): ViewDefinitionBinding[] {
+  const target = bundle?.ir?.views?.[view.slug]?.target
+  if (target) {
+    if (target.kind === 'domain') return []
+    return uniqueViewBindings(
+      target.definitions
+        .filter(
+          (definition): definition is typeof definition & { kind: 'class' | 'interface' } =>
+            definition.kind === 'class' || definition.kind === 'interface',
+        )
+        .map((definition) => ({
+          className: definition.name,
+          classOrigin: definition.origin,
+          kind: definition.kind,
+        })),
+    )
+  }
+
+  const names = Array.isArray(view.viewFor) ? view.viewFor : view.viewFor ? [view.viewFor] : []
+  const ir = bundle?.ir
+  if (!ir) {
+    return uniqueViewBindings(
+      names.map((className) => ({ className, classOrigin: origin, kind: 'class' })),
+    )
+  }
+
+  return uniqueViewBindings(
+    names.flatMap((className) => {
+      const local: ViewDefinitionBinding[] = []
+      const localClass = ir.classes[className]
+      const localInterface = ir.interfaces[className]
+      if (localClass) {
+        local.push({
+          className,
+          classOrigin: localClass.ref?.origin ?? localClass.origin ?? ir.domain ?? origin,
+          kind: 'class',
+        })
+      }
+      if (localInterface) {
+        local.push({
+          className,
+          classOrigin: localInterface.ref?.origin ?? localInterface.origin ?? ir.domain ?? origin,
+          kind: 'interface',
+        })
+      }
+
+      // Presence of the exact index makes it authoritative, including when it
+      // has no candidate for this short anatomy name. Since this API is plural,
+      // retain every exact homonym instead of picking one by object order.
+      if (ir.importsByKey !== undefined) {
+        const imported = Object.keys(ir.importsByKey).flatMap((key) => {
+          const binding = viewBindingFromDefinitionKey(key)
+          return binding?.className === className ? [binding] : []
+        })
+        return [...local, ...imported]
+      }
+
+      const legacy = ir.imports[className]
+      if (legacy) {
+        return [
+          ...local,
+          {
+            className,
+            classOrigin: legacy.origin,
+            kind: legacy.definition,
+          } satisfies ViewDefinitionBinding,
+        ]
+      }
+
+      // Old serializer projections did not retain exact indexes or declaration
+      // refs. Preserve their historical local-class assumption only here.
+      return local.length > 0 ? local : [{ className, classOrigin: origin, kind: 'class' }]
+    }),
+  )
+}
+
+function viewBindingFromDefinitionKey(key: string): ViewDefinitionBinding | null {
+  const separator = key.lastIndexOf(':')
+  if (separator <= 0) return null
+  const classOrigin = key.slice(0, separator)
+  const ref = key.slice(separator + 1)
+  const match = /^(class|interface)\.([A-Za-z_$][\w$]*)$/.exec(ref)
+  if (!match) return null
+  return {
+    className: match[2]!,
+    classOrigin,
+    kind: match[1] as ViewDefinitionBinding['kind'],
+  }
 }
 
-function viewClasses(view: ViewInfo): string[] {
-  return Array.isArray(view.viewFor) ? view.viewFor : view.viewFor ? [view.viewFor] : []
+function uniqueViewBindings(bindings: ViewDefinitionBinding[]): ViewDefinitionBinding[] {
+  const unique = new Map<string, ViewDefinitionBinding>()
+  for (const binding of bindings) {
+    const key = `${binding.classOrigin}:${binding.kind}.${binding.className}`
+    if (!unique.has(key)) unique.set(key, binding)
+  }
+  return [...unique.values()]
 }
 
 function rememberTarget(
@@ -338,6 +440,11 @@ function assertSchemaName(value: string): string {
   return value
 }
 
+function assertViewSlug(value: string): string {
+  if (!/^[a-z][a-z0-9-]*$/.test(value)) throw new Error(`Invalid view slug: ${value}`)
+  return value
+}
+
 function stringProp(props: Record<string, unknown>, suffixes: string[]): string | undefined {
   for (const suffix of suffixes) {
     for (const [key, value] of Object.entries(props)) {

package/studio/server/watch.test.ts

@@ -0,0 +1,36 @@
+import { expect, test } from 'bun:test'
+import { join } from 'node:path'
+
+import type { DomainHandle } from './domain'
+
+import { affectsBundle, ANATOMY_PATHS } from './watch'
+import { DOMAIN_SET_TRIGGER_FILES } from './workspace-watch'
+
+const handle: DomainHandle = {
+  id: 'current',
+  root: '/workspace/current',
+  configFile: '/workspace/current/astrale.config.ts',
+  domainFile: '/workspace/current/implementation.ts',
+  schemaDirName: 'schema',
+  schemaDir: '/workspace/current/schema',
+  schemaIndex: '/workspace/current/schema/index.ts',
+}
+
+test('watches current layout roots and reconciles either composition entry', () => {
+  expect(ANATOMY_PATHS).toContain('implementation.ts')
+  expect(ANATOMY_PATHS).toContain('ui')
+  expect(ANATOMY_PATHS).toContain('handlers')
+  expect(ANATOMY_PATHS).toContain('queries')
+  expect(ANATOMY_PATHS).toContain('workflows')
+  expect(DOMAIN_SET_TRIGGER_FILES.has('implementation.ts')).toBe(true)
+  expect(DOMAIN_SET_TRIGGER_FILES.has('domain.ts')).toBe(true)
+})
+
+test('composition and handler source changes invalidate the schema bundle', () => {
+  expect(affectsBundle(handle, join(handle.root, 'implementation.ts'))).toBe(true)
+  expect(affectsBundle(handle, join(handle.root, 'domain.ts'))).toBe(true)
+  expect(affectsBundle(handle, join(handle.root, 'actions', 'risk', 'create.ts'))).toBe(true)
+  expect(affectsBundle(handle, join(handle.root, 'functions', 'user', 'ensure.ts'))).toBe(true)
+  expect(affectsBundle(handle, join(handle.root, 'handlers', 'create.ts'))).toBe(true)
+  expect(affectsBundle(handle, join(handle.root, 'views', 'routes.ts'))).toBe(false)
+})

package/studio/server/watch.ts

@@ -11,20 +11,24 @@ import type { DomainHandle } from './domain'
 
 import { getBundle, invalidate } from './cache'
 import { broadcast } from './sse'
+import { ANATOMY_GLOBS } from './state/baseline'
 
-const ANATOMY = [
-  'domain.ts',
-  'core.ts',
-  'core',
-  'runtime',
-  'views',
+export const ANATOMY_PATHS = [...ANATOMY_GLOBS.files, ...ANATOMY_GLOBS.dirs]
+
+// These paths can feed the ts-morph handler/source overlay. Their content is
+// part of the schema bundle cache even though they are outside schema/ itself.
+const BUNDLE_SOURCE_DIRS = new Set([
+  'actions',
+  'capabilities',
   'functions',
-  'client/src',
-  'deps.ts',
-  'env.ts',
-  'package.json',
-  'astrale.config.ts',
-]
+  'handlers',
+  'mutations',
+  'queries',
+  'rules',
+  'runtime',
+  'utils',
+  'workflows',
+])
 
 function ignored(p: string): boolean {
   return (
@@ -35,15 +39,16 @@ function ignored(p: string): boolean {
   )
 }
 
-function affectsBundle(handle: DomainHandle, path: string): boolean {
+export function affectsBundle(handle: DomainHandle, path: string): boolean {
   const rel = relative(handle.root, path).split('\\').join('/')
-  return rel === 'domain.ts' || rel === 'runtime' || rel.startsWith('runtime/')
+  const topLevel = rel.split('/')[0]
+  return rel === 'implementation.ts' || rel === 'domain.ts' || BUNDLE_SOURCE_DIRS.has(topLevel)
 }
 
 export function watchDomain(handle: DomainHandle): () => void {
   const schemaW = chokidar.watch(handle.schemaDir, { ignoreInitial: true, ignored })
   const anatomyW = chokidar.watch(
-    ANATOMY.map((p) => join(handle.root, p)),
+    ANATOMY_PATHS.map((p) => join(handle.root, p)),
     { ignoreInitial: true, ignored },
   )
 
@@ -53,7 +58,9 @@ export function watchDomain(handle: DomainHandle): () => void {
   schemaW.on('all', () => {
     clearTimeout(st)
     st = setTimeout(async () => {
-      invalidate(handle.id, 'schema')
+      // Origin and View declarations are part of the current schema, so schema
+      // edits invalidate both render surfaces.
+      invalidate(handle.id, 'all')
       broadcast({ type: 'resolving', domainId: handle.id })
       const b = await getBundle(handle.id, true)
       if (b?.error)
@@ -63,6 +70,7 @@ export function watchDomain(handle: DomainHandle): () => void {
         domainId: handle.id,
         schemaHash: b?.schemaHash ?? 'sha-none',
       })
+      broadcast({ type: 'anatomy-diff', domainId: handle.id })
     }, 150)
   })
 

package/studio/server/workspace-watch.ts

@@ -1,7 +1,7 @@
 /**
  * workspace-watch.ts — keeps the domain registry in sync with the workspace while
  * the studio is running. A domain dropped in (or one whose astrale.config.ts +
- * domain.ts + schema/index.ts triple just completed) is registered, booted, and
+ * composition entry + schema/index.ts triple just completed) is registered, booted, and
  * announced over SSE; one whose triple vanished is unregistered. It reuses
  * `scanWorkspace` (detection) + `bootDomain` (lifecycle), so there is no second
  * source of truth for "what is a domain" or "how a domain comes online".
@@ -17,7 +17,12 @@ import { broadcast } from './sse'
 const IGNORED =
   /(^|[/\\])(node_modules|\.git|\.astrale|\.domain-studio|dist|\.dist|\.next|\.cache|\.turbo|\.vercel|coverage)([/\\]|$)/
 // only these file changes can change the domain SET (vs. ordinary in-domain edits)
-const TRIGGERS = new Set(['astrale.config.ts', 'domain.ts', 'index.ts'])
+export const DOMAIN_SET_TRIGGER_FILES = new Set([
+  'astrale.config.ts',
+  'implementation.ts',
+  'domain.ts',
+  'index.ts',
+])
 
 /**
  * Watch `root` for domains appearing/disappearing.
@@ -84,7 +89,7 @@ export function watchWorkspace(
     timer = setTimeout(() => void run(), 400)
   }
   const onFile = (p: string) => {
-    if (TRIGGERS.has(basename(p))) schedule()
+    if (DOMAIN_SET_TRIGGER_FILES.has(basename(p))) schedule()
   }
 
   const watcher = chokidar.watch(root, {