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

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

@@ -1,265 +0,0 @@
-import { afterEach, expect, test } from 'bun:test'
-import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-
-import { buildClientTree, buildViews, findSchemaDefinition } from './anatomy-extras'
-
-const roots: string[] = []
-
-afterEach(() => {
-  for (const root of roots.splice(0)) rmSync(root, { recursive: true, force: true })
-})
-
-test('discovers view mounts from any top-level client route registry', () => {
-  const root = mkdtempSync(join(tmpdir(), 'studio-client-tree-'))
-  roots.push(root)
-  const src = join(root, 'client', 'src')
-  mkdirSync(src, { recursive: true })
-  writeFileSync(
-    join(src, 'views.tsx'),
-    `const VIEW_REGISTRY = {
-      '/ui/issues': IssuesView,
-      '/ui/issue': TargetIssueView,
-    }`,
-  )
-  writeFileSync(join(src, 'app.tsx'), `const ROUTES = { '/ui/settings': SettingsView }`)
-
-  expect(buildClientTree(root).routes).toEqual({
-    '/ui/issue': 'TargetIssueView',
-    '/ui/issues': 'IssuesView',
-    '/ui/settings': 'SettingsView',
-  })
-})
-
-test('reads the discovered client directory', () => {
-  const root = mkdtempSync(join(tmpdir(), 'studio-client-tree-configured-'))
-  roots.push(root)
-  const clientDir = join(root, 'frontend')
-  const src = join(clientDir, 'src')
-  mkdirSync(src, { recursive: true })
-  writeFileSync(join(src, 'views.tsx'), `const VIEWS = { '/ui/models': ModelsView }`)
-
-  expect(buildClientTree(root, clientDir)).toMatchObject({
-    present: true,
-    routes: { '/ui/models': 'ModelsView' },
-  })
-})
-
-test('does not treat a removed view registry as Schema authority', () => {
-  const root = mkdtempSync(join(tmpdir(), 'studio-inline-view-registry-'))
-  roots.push(root)
-  const viewsDir = join(root, 'views')
-  mkdirSync(viewsDir, { recursive: true })
-  writeFileSync(
-    join(viewsDir, 'index.ts'),
-    `import { defineView } from '@astrale-os/sdk'
-const services = defineView({
-  auth: 'required',
-  mount: '/ui/services',
-  description: 'Browse services.',
-})
-const service = defineView({
-  auth: 'required',
-  mount: '/ui/service',
-  viewFor: [selfOf(CloudflareWorker)],
-})
-export const views = { services, service }
-`,
-  )
-
-  expect(buildViews(root)).toEqual([])
-})
-
-test('joins canonical Bundle Views with defineFrontend route metadata', () => {
-  const root = mkdtempSync(join(tmpdir(), 'studio-current-react-view-'))
-  roots.push(root)
-  mkdirSync(join(root, 'schema', 'application'), { recursive: true })
-  mkdirSync(join(root, 'views'), { recursive: true })
-  writeFileSync(
-    join(root, 'schema', 'index.ts'),
-    `export { schema } from './application/index.js'\n`,
-  )
-  writeFileSync(
-    join(root, 'schema', 'application', 'index.ts'),
-    `import { defineSchema, view } from '@astrale-os/sdk/schema'
-export const ORIGIN = 'current.example.dev' as const
-const schemaInput = {
-  classes: {},
-  views: {
-    issue: view({
-      target: [Issue, Group],
-      auth: 'optional',
-      description: 'Inspect an issue.',
-    }),
-  },
-} as const
-export const schema = defineSchema(ORIGIN, schemaInput)
-`,
-  )
-  writeFileSync(
-    join(root, 'views', 'routes.ts'),
-    `import { defineFrontend, vite } from '@astrale-os/sdk/application'
-export const frontend = defineFrontend({
-  schema,
-  source: vite(),
-  routes: { issue: '/ui/issues/:id' },
-  entrypoint: 'issue',
-})
-`,
-  )
-
-  expect(findSchemaDefinition(root)).toMatchObject({ origin: 'current.example.dev' })
-  expect(
-    buildViews(root, 'schema', {
-      issue: {
-        name: 'issue',
-        auth: 'optional',
-        description: 'Inspect an issue.',
-        target: {
-          kind: 'definition',
-          definitions: [
-            { origin: 'issues.example.dev', kind: 'class', name: 'Issue' },
-            { origin: 'accounts.example.dev', kind: 'class', name: 'Group' },
-          ],
-        },
-      },
-    }),
-  ).toEqual([
-    {
-      slug: 'issue',
-      kind: 'spa',
-      auth: 'optional',
-      mount: '/ui/issues/:id',
-      url: undefined,
-      viewFor: ['Issue', 'Group'],
-      file: 'views/routes.ts',
-      description: 'Inspect an issue.',
-    },
-  ])
-})
-
-test('discovers Vite frontend default routes from canonical View names', () => {
-  const root = mkdtempSync(join(tmpdir(), 'studio-current-generated-view-'))
-  roots.push(root)
-  mkdirSync(join(root, 'schema'), { recursive: true })
-  mkdirSync(join(root, 'views', 'summary'), { recursive: true })
-  writeFileSync(
-    join(root, 'schema', 'index.ts'),
-    `export const schema = defineSchema('generated.example.dev', {
-  views: { summary: view({ target: 'domain' }) },
-})
-`,
-  )
-  writeFileSync(
-    join(root, 'views', 'summary', 'index.ts'),
-    `const source = vite()
-export const frontend = defineFrontend({
-  schema,
-  source,
-  entrypoint: 'summary',
-})
-`,
-  )
-
-  expect(
-    buildViews(root, 'schema', {
-      summary: {
-        name: 'summary',
-        auth: 'required',
-        target: { kind: 'domain' },
-      },
-    }),
-  ).toEqual([
-    {
-      slug: 'summary',
-      kind: 'spa',
-      auth: 'required',
-      mount: '/summary',
-      url: undefined,
-      file: 'views/summary/index.ts',
-    },
-  ])
-})
-
-test('canonical Bundle views reject static schema and route-only identities', () => {
-  const root = mkdtempSync(join(tmpdir(), 'studio-canonical-view-authority-'))
-  roots.push(root)
-  mkdirSync(join(root, 'schema'), { recursive: true })
-  writeFileSync(
-    join(root, 'schema', 'index.ts'),
-    `export const schema = defineSchema('static.invalid', {
-  views: {
-    account: view({ target: WrongTarget, auth: 'public', description: 'Static guess.' }),
-    sourceOnly: view({ target: WrongTarget, auth: 'public', description: 'Static guess.' }),
-    invented: view({ target: 'domain', auth: 'public' }),
-  },
-})`,
-  )
-  writeFileSync(
-    join(root, 'application.ts'),
-    `export const frontend = defineFrontend({
-  schema,
-  source: external('https://shell.example.dev'),
-  routes: {
-    account: '/account',
-    routeOnly: '/route-only',
-  },
-})`,
-  )
-
-  expect(
-    buildViews(root, 'schema', {
-      account: {
-        name: 'account',
-        auth: 'required',
-        description: 'Admitted account view.',
-        target: {
-          kind: 'definition',
-          definitions: [{ origin: 'accounts.example.dev', kind: 'class', name: 'Account' }],
-        },
-      },
-      sourceOnly: {
-        name: 'sourceOnly',
-        auth: 'optional',
-        description: 'Admitted source-only view.',
-        target: { kind: 'domain' },
-      },
-    }),
-  ).toEqual([
-    {
-      slug: 'account',
-      kind: 'spa',
-      auth: 'required',
-      description: 'Admitted account view.',
-      viewFor: 'Account',
-      url: 'https://shell.example.dev/account',
-      file: 'application.ts',
-    },
-    {
-      slug: 'sourceOnly',
-      kind: 'spa',
-      auth: 'optional',
-      description: 'Admitted source-only view.',
-      url: 'https://shell.example.dev/source-only',
-      file: 'application.ts',
-    },
-  ])
-  expect(buildViews(root, 'schema', {})).toEqual([])
-})
-
-test('uses current ui modules as the client anatomy when no legacy client package is selected', () => {
-  const root = mkdtempSync(join(tmpdir(), 'studio-current-ui-tree-'))
-  roots.push(root)
-  mkdirSync(join(root, 'ui', 'application'), { recursive: true })
-  writeFileSync(
-    join(root, 'ui', 'application', 'index.ts'),
-    `export { Screen } from './screen.js'\n`,
-  )
-  writeFileSync(join(root, 'ui', 'application', 'screen.tsx'), `export const Screen = () => null\n`)
-
-  expect(buildClientTree(root, null)).toMatchObject({
-    present: true,
-    features: [{ name: 'application', files: ['index.ts', 'screen.tsx'] }],
-  })
-})

package/studio/server/introspect/anatomy-extras.ts

@@ -1,10 +0,0 @@
-/**
- * Compatibility facade for Studio's static anatomy extractors.
- *
- * Semantic ownership lives under `anatomy/`; existing consumers keep this
- * stable entrypoint.
- */
-export { buildClientTree } from './anatomy/client-tree'
-export { buildEnvFields } from './anatomy/env-fields'
-export { findSchemaDefinition, type SchemaDefinitionLocation } from './anatomy/schema-definition'
-export { buildViews } from './anatomy/views'

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

@@ -1,41 +0,0 @@
-import { afterEach, expect, test } from 'bun:test'
-import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs'
-import { tmpdir } from 'node:os'
-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(nested: boolean) {
-  const root = mkdtempSync(join(tmpdir(), 'studio-anatomy-application-'))
-  roots.push(root)
-  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'),
-    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 a root Application', () => {
-  const input = project(false)
-  expect(buildAnatomy(input).overview.applicationFile).toBe('application.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

@@ -1,147 +0,0 @@
-/**
- * anatomy.ts — the non-schema structure: overview (identity/adapter/pkg),
- * views, client tree, env fields, and a SHALLOW readdir of integrations/
- * (dir names only — a hint, never a parse).
- *
- * Overview is implemented here; views/client/env are filled by the
- * introspection swarm in anatomy-extras.ts. The composition entry is statically
- * parsed, never executed (its dependency graph may have import side effects).
- */
-import { existsSync, readFileSync, readdirSync, statSync } from 'node:fs'
-import { join, relative } from 'node:path'
-
-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,
-  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, canonicalViews),
-    client: buildClientTree(root, clientDir ?? null),
-    env: buildEnvFields(root),
-    detectedIntegrations: detectIntegrations(root),
-  }
-}
-
-function buildOverview(
-  root: string,
-  schemaDirName: string,
-  clientDir?: string,
-  schemaOrigin?: string,
-): DomainOverview {
-  const pkg = readPackageJsonSafe(join(root, 'package.json'))
-  const astraleDeps: Record<string, string> = {}
-  for (const [k, v] of Object.entries({
-    ...(pkg?.dependencies ?? {}),
-    ...(pkg?.devDependencies ?? {}),
-  })) {
-    if (k.startsWith('@astrale-os/')) astraleDeps[k] = String(v)
-  }
-
-  const config = readConfigPreview(root)
-
-  const application = resolveApplicationEntry(root)
-  const applicationSrc = application === null ? '' : readTextSafe(application)
-  const origin =
-    schemaOrigin ??
-    applicationSrc.match(/defineSchema\(\s*['"]([^'"]+)['"]/)?.[1] ??
-    readTextSafe(join(root, schemaDirName, 'index.ts')).match(
-      /defineSchema\(\s*['"]([^'"]+)['"]/,
-    )?.[1] ??
-    ''
-
-  return {
-    origin,
-    applicationFile:
-      application === null ? undefined : relative(root, application).replaceAll('\\', '/'),
-    adapter: config.adapter,
-    prodTarget: config.prodTarget,
-    devSecrets: config.devSecrets,
-    requires: [],
-    packageName: pkg?.name,
-    packageVersion: pkg?.version,
-    astraleDeps,
-    schemaDir: schemaDirName,
-    client: clientDir ? relative(root, clientDir).replaceAll('\\', '/') || '.' : undefined,
-  }
-}
-
-function detectIntegrations(root: string): string[] {
-  const dir = join(root, readSettings(root).integrationsDir)
-  if (!existsSync(dir)) return []
-  try {
-    return readdirSync(dir).filter((e) => {
-      try {
-        return statSync(join(dir, e)).isDirectory()
-      } catch {
-        return false
-      }
-    })
-  } catch {
-    return []
-  }
-}
-
-function readTextSafe(f: string): string {
-  try {
-    return existsSync(f) ? readFileSync(f, 'utf8') : ''
-  } catch {
-    return ''
-  }
-}
-
-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 {
-    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,69 +0,0 @@
-/**
- * bundle.ts — assembles the StudioSchemaBundle: runtime IR (PRIMARY) + ts-morph
- * 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).
- */
-import type { StudioSchemaBundle } from '../../shared/types'
-
-import { type DomainHandle, depsInstalled } from '../domain'
-import { readSettings } from '../state/settings'
-import { renderFingerprintOf } from './hash'
-import { buildOverlay } from './overlay'
-import { runtimeExtract } from './runtime'
-
-export async function buildBundle(handle: DomainHandle): Promise<StudioSchemaBundle> {
-  const installed = depsInstalled(handle.root)
-  let ir = null
-  let schemaRoot: unknown | undefined
-  let schemaMode: StudioSchemaBundle['schemaMode'] = 'unavailable'
-  let schemaRevision: StudioSchemaBundle['schemaRevision']
-  let error: StudioSchemaBundle['error'] = null
-  let extractedBy: StudioSchemaBundle['extractedBy'] = 'runtime-bun'
-
-  if (installed) {
-    const r = await runtimeExtract(
-      handle.schemaIndex,
-      handle.root,
-      readSettings(handle.root).introspectTimeoutMs,
-    )
-    if (r.ok) {
-      ir = r.ir
-      if (r.root !== null) schemaRoot = r.root
-      schemaMode = r.schemaMode
-      if (r.revision !== null) schemaRevision = r.revision
-    } else {
-      error = { message: r.error?.message ?? 'schema failed to compile' }
-      extractedBy = 'static-tsmorph-fallback'
-    }
-  } else {
-    extractedBy = 'static-tsmorph-fallback'
-    error = {
-      message:
-        'dependencies not installed — run `pnpm install` in the domain for full-fidelity schema rendering',
-    }
-  }
-
-  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,
-    renderFingerprint,
-    schemaMode,
-    ...(schemaRevision === undefined ? {} : { schemaRevision }),
-    extractedBy,
-    depsInstalled: installed,
-    ir,
-    ...(schemaRoot === undefined ? {} : { schemaRoot }),
-    overlay,
-    error,
-    extractedAt: new Date().toISOString(),
-  }
-}