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

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

@@ -1,119 +0,0 @@
-/**
- * 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,30 +0,0 @@
-/** 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 projectRoot = process.argv[3] ?? process.cwd()
-const input = process.argv[2]
-const schemaFile = input && !isAbsolute(input) ? resolve(projectRoot, input) : input
-
-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,
-    }),
-  )
-}
-
-main().catch((cause: unknown) => {
-  const error = cause instanceof Error ? cause : new Error(String(cause))
-  process.stdout.write(
-    JSON.stringify({ ok: false, error: { message: error.message, stack: error.stack ?? '' } }),
-  )
-  process.exit(0)
-})

package/studio/server/introspect/core.ts

@@ -1,45 +0,0 @@
-/**
- * core.ts — assembles a domain's StudioCore: the genesis node/edge graph
- * 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.
- */
-import type { StudioCore } from '../../shared/types'
-
-import { type DomainHandle, depsInstalled } from '../domain'
-import { readSettings } from '../state/settings'
-import { coreExtract } from './runtime'
-
-export async function buildCore(handle: DomainHandle): Promise<StudioCore> {
-  const at = new Date().toISOString()
-  const empty = (error: StudioCore['error']): StudioCore => ({
-    domain: handle.origin ?? handle.id,
-    nodes: [],
-    edges: [],
-    error,
-    extractedAt: at,
-  })
-
-  if (!depsInstalled(handle.root)) {
-    return empty({
-      message: 'dependencies not installed — run `pnpm install` in the domain for core extraction',
-    })
-  }
-
-  const r = await coreExtract(
-    handle.schemaIndex,
-    handle.root,
-    readSettings(handle.root).introspectTimeoutMs,
-  )
-  // r.ok && r.core===null  → the domain simply defines no core (not an error).
-  if (!r.ok) return empty(r.error ?? { message: 'core extraction failed' })
-  if (!r.core) return empty(null)
-
-  return {
-    domain: r.core.domain,
-    nodes: r.core.nodes,
-    edges: r.core.edges,
-    error: null,
-    extractedAt: at,
-  }
-}

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

@@ -1,124 +0,0 @@
-import { describe, expect, test } from 'bun:test'
-
-import type { IrClass, IrFunction, SchemaIR } from '../../shared/types'
-
-import { diffSchemas, structuralStatusOf } from './diff'
-
-const callable = (returnsType = 'string'): IrFunction => ({
-  name: 'inspect',
-  input: { type: 'object', properties: {}, additionalProperties: false },
-  output: { mode: 'value', schema: { type: returnsType } },
-  auth: 'authenticated',
-})
-
-const schema = (functions: SchemaIR['functions']): SchemaIR => ({
-  version: 'v1',
-  format: 'astrale.dsl',
-  domain: 'example.test',
-  classes: {},
-  importsByKey: {},
-  importedClassesByKey: {},
-  functions,
-  views: {},
-  policies: {},
-  dependencies: [],
-  core: {},
-})
-
-const withClass = (member: IrClass): SchemaIR => ({
-  ...schema({}),
-  classes: { [member.name]: member },
-})
-
-describe('canonical standalone Function diffs', () => {
-  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' }])
-    const removed = diffSchemas(populated, empty)
-    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' }])
-  })
-
-  test('detects auth and output-mode changes in callable contracts', () => {
-    const before = callable()
-    const after: IrFunction = {
-      ...before,
-      auth: 'authorized',
-      output: { mode: 'stream', item: { type: 'string' } },
-    }
-
-    expect(diffSchemas(schema({ inspect: before }), schema({ inspect: after }))).toEqual([
-      { kind: 'function-signature-changed', target: 'inspect' },
-    ])
-  })
-
-  test('uses canonical required membership and compares complete value schemas', () => {
-    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: {},
-    })
-
-    expect(diffSchemas(withClass(member([], 1)), withClass(member(['name'], 2)))).toEqual([
-      {
-        kind: 'prop-schema-changed',
-        target: 'Person.name',
-        detail: 'value constraints changed',
-      },
-      {
-        kind: 'prop-required-changed',
-        target: 'Person.name',
-        detail: 'optional → required',
-      },
-    ])
-  })
-
-  test('tracks canonical views, policies, dependencies, topology, and Core', () => {
-    const before: SchemaIR = {
-      ...withClass({
-        type: 'edge',
-        name: 'owns',
-        origin: 'example.test',
-        ref: { origin: 'example.test', kind: 'class', name: 'owns' },
-        properties: {},
-        required: [],
-        methods: {},
-        orientation: 'directed',
-        endpoints: [],
-      }),
-      views: { home: { name: 'home', target: { kind: 'domain' }, auth: 'public' } },
-      policies: { canRead: { anyOf: [] } },
-      dependencies: [{ origin: 'kernel.astrale.ai', revision: 'sha256:one' }],
-      core: { nodes: {}, edges: [] },
-    }
-    const after: SchemaIR = {
-      ...before,
-      classes: {
-        owns: { ...before.classes.owns, orientation: 'undirected' },
-      },
-      views: { home: { ...before.views!.home, auth: 'required' } },
-      policies: { canRead: { anyOf: [{ name: 'owner' }] } },
-      dependencies: [{ origin: 'kernel.astrale.ai', revision: 'sha256:two' }],
-      core: { nodes: { root: {} }, edges: [] },
-    }
-
-    expect(diffSchemas(before, after).map((change) => change.kind)).toEqual([
-      'edge-contract-changed',
-      'view-changed',
-      'policy-changed',
-      'dependency-changed',
-      'core-changed',
-    ])
-  })
-})

package/studio/server/introspect/diff.ts

@@ -1,316 +0,0 @@
-/**
- * diff.ts — indicative structural diff of two Studio render IRs. Pure.
- *
- * Canonical V1 keeps optionality in the owning `required` arrays and nullability
- * in each value schema. This inventory makes no installation or data-migration claim;
- * only the Kernel Runtime can assess those transitions against installed data.
- */
-import type {
-  IrClass,
-  IrFunction,
-  IrMethod,
-  JsonSchema,
-  SchemaChange,
-  SchemaIR,
-} from '../../shared/types'
-
-export function isOptional(s: JsonSchema | undefined): boolean {
-  if (!s) return false
-  return Array.isArray(s.type) ? s.type.includes('null') : false
-}
-
-export function baseType(s: JsonSchema | undefined): string {
-  if (!s) return 'unknown'
-  const t = s.type
-  if (Array.isArray(t)) {
-    const base = t.filter((x) => x !== 'null')
-    return (base.length ? base.join('|') : 'null') + (s.enum ? `(${s.enum.join(',')})` : '')
-  }
-  if (typeof t === 'string') return t + (s.enum ? `(${s.enum.join(',')})` : '')
-  return s.enum ? `enum(${s.enum.join(',')})` : 'unknown'
-}
-
-function callableContract(m: IrMethod | IrFunction): unknown {
-  return {
-    input: m.input,
-    output: m.output,
-    ...('static' in m ? { static: m.static, inheritance: m.inheritance } : {}),
-    auth: m.auth,
-    policy: m.policy,
-  }
-}
-
-export function diffSchemas(prev: SchemaIR | null, next: SchemaIR | null): SchemaChange[] {
-  const changes: SchemaChange[] = []
-  if (!prev || !next) return changes
-
-  if (
-    !same(
-      { format: prev.format, version: prev.version, domain: prev.domain },
-      {
-        format: next.format,
-        version: next.version,
-        domain: next.domain,
-      },
-    )
-  ) {
-    changes.push({ kind: 'schema-metadata-changed', target: next.domain })
-  }
-
-  diffValueRecord(prev.importsByKey, next.importsByKey, 'import', changes)
-  diffMembers(prev.classes, next.classes, changes)
-  diffFunctions(prev.functions ?? {}, next.functions ?? {}, changes)
-  diffViews(prev.views ?? {}, next.views ?? {}, changes)
-  diffValueRecord(prev.policies ?? {}, next.policies ?? {}, 'policy', changes)
-  diffDependencies(prev.dependencies ?? [], next.dependencies ?? [], changes)
-  if (!same(prev.core, next.core) && (prev.core !== undefined || next.core !== undefined)) {
-    changes.push({ kind: 'core-changed', target: next.domain })
-  }
-  return changes
-}
-
-function diffValueRecord(
-  prev: Record<string, unknown>,
-  next: Record<string, unknown>,
-  scope: 'import' | 'policy',
-  out: SchemaChange[],
-): void {
-  for (const name of sortedKeys(next)) {
-    if (!(name in prev)) {
-      out.push({ kind: `${scope}-added`, target: name })
-    }
-  }
-  for (const name of sortedKeys(prev)) {
-    if (!(name in next)) {
-      out.push({ kind: `${scope}-removed`, target: name })
-    } else if (!same(prev[name], next[name])) {
-      out.push({ kind: `${scope}-changed`, target: name })
-    }
-  }
-}
-
-function diffFunctions(
-  prev: Record<string, IrFunction>,
-  next: Record<string, IrFunction>,
-  out: SchemaChange[],
-): void {
-  for (const name of sortedKeys(next)) {
-    if (!prev[name]) out.push({ kind: 'function-added', target: name })
-  }
-  for (const name of sortedKeys(prev)) {
-    if (!next[name]) {
-      out.push({ kind: 'function-removed', target: name })
-      continue
-    }
-    if (!same(callableContract(prev[name]), callableContract(next[name]))) {
-      out.push({ kind: 'function-signature-changed', target: name })
-    }
-    if (prev[name].description !== next[name].description) {
-      out.push({ kind: 'function-metadata-changed', target: name })
-    }
-  }
-}
-
-function diffViews(
-  prev: NonNullable<SchemaIR['views']>,
-  next: NonNullable<SchemaIR['views']>,
-  out: SchemaChange[],
-): void {
-  for (const name of sortedKeys(next)) {
-    if (!(name in prev)) out.push({ kind: 'view-added', target: name })
-  }
-  for (const name of sortedKeys(prev)) {
-    if (!(name in next)) {
-      out.push({ kind: 'view-removed', target: name })
-      continue
-    }
-    if (
-      !same(
-        { target: prev[name].target, auth: prev[name].auth },
-        {
-          target: next[name].target,
-          auth: next[name].auth,
-        },
-      )
-    ) {
-      out.push({ kind: 'view-changed', target: name })
-    }
-    if (prev[name].description !== next[name].description) {
-      out.push({ kind: 'view-metadata-changed', target: name })
-    }
-  }
-}
-
-function diffDependencies(
-  prev: NonNullable<SchemaIR['dependencies']>,
-  next: NonNullable<SchemaIR['dependencies']>,
-  out: SchemaChange[],
-): void {
-  const before = Object.fromEntries(
-    prev.map((dependency) => [dependency.origin, dependency.revision]),
-  )
-  const after = Object.fromEntries(
-    next.map((dependency) => [dependency.origin, dependency.revision]),
-  )
-  for (const origin of sortedKeys(after)) {
-    if (!(origin in before)) {
-      out.push({ kind: 'dependency-added', target: origin })
-    }
-  }
-  for (const origin of sortedKeys(before)) {
-    if (!(origin in after)) {
-      out.push({ kind: 'dependency-removed', target: origin })
-    } else if (before[origin] !== after[origin]) {
-      out.push({
-        kind: 'dependency-changed',
-        target: origin,
-        detail: `${before[origin]} → ${after[origin]}`,
-      })
-    }
-  }
-}
-
-function memberKind(member: IrClass): 'class' | 'edge' {
-  return member.type === 'edge' ? 'edge' : 'class'
-}
-
-function diffMembers(
-  prev: Record<string, IrClass>,
-  next: Record<string, IrClass>,
-  out: SchemaChange[],
-): void {
-  for (const name of sortedKeys(next)) {
-    if (!prev[name]) {
-      const k = memberKind(next[name])
-      out.push({ kind: `${k}-added` as SchemaChange['kind'], target: name })
-    }
-  }
-  for (const name of sortedKeys(prev)) {
-    if (!next[name]) {
-      const k = memberKind(prev[name])
-      out.push({ kind: `${k}-removed` as SchemaChange['kind'], target: name })
-      continue
-    }
-    diffMemberBody(name, prev[name], next[name], out)
-  }
-}
-
-function diffMemberBody(name: string, a: IrClass, b: IrClass, out: SchemaChange[]): void {
-  const pa = a.properties ?? {}
-  const pb = b.properties ?? {}
-  for (const p of sortedKeys(pb)) {
-    if (!pa[p]) {
-      const required = propertyRequired(b, p)
-      out.push({
-        kind: 'prop-added',
-        target: `${name}.${p}`,
-        detail: required ? 'required' : 'optional',
-      })
-    }
-  }
-  for (const p of sortedKeys(pa)) {
-    if (!pb[p]) {
-      out.push({ kind: 'prop-removed', target: `${name}.${p}` })
-      continue
-    }
-    if (!same(pa[p], pb[p])) {
-      const baseChanged = baseType(pa[p]) !== baseType(pb[p])
-      out.push({
-        kind: baseChanged ? 'prop-type-changed' : 'prop-schema-changed',
-        target: `${name}.${p}`,
-        detail: baseChanged
-          ? `${baseType(pa[p])} → ${baseType(pb[p])}`
-          : 'value constraints changed',
-      })
-    }
-    const wasOpt = !propertyRequired(a, p)
-    const nowOpt = !propertyRequired(b, p)
-    if (wasOpt !== nowOpt) {
-      out.push({
-        kind: 'prop-required-changed',
-        target: `${name}.${p}`,
-        detail: wasOpt ? 'optional → required' : 'required → optional',
-      })
-    }
-  }
-
-  const ma = a.methods ?? {}
-  const mb = b.methods ?? {}
-  for (const m of sortedKeys(mb)) {
-    if (!ma[m]) {
-      out.push({
-        kind: 'method-added',
-        target: `${name}.${m}`,
-      })
-    }
-  }
-  for (const m of sortedKeys(ma)) {
-    if (!mb[m]) {
-      out.push({ kind: 'method-removed', target: `${name}.${m}` })
-      continue
-    }
-    if (!same(callableContract(ma[m]), callableContract(mb[m]))) {
-      out.push({ kind: 'method-signature-changed', target: `${name}.${m}` })
-    }
-    if (ma[m].description !== mb[m].description) {
-      out.push({ kind: 'method-metadata-changed', target: `${name}.${m}` })
-    }
-  }
-
-  const kind = memberKind(b)
-  if (!same(memberContract(a), memberContract(b))) {
-    out.push({
-      kind: `${kind}-contract-changed`,
-      target: name,
-    })
-  }
-  if (!same(memberMetadata(a), memberMetadata(b))) {
-    out.push({ kind: 'definition-metadata-changed', target: name })
-  }
-}
-
-function propertyRequired(member: IrClass, name: string): boolean {
-  return member.required ? member.required.includes(name) : !isOptional(member.properties?.[name])
-}
-
-function memberContract(member: IrClass): unknown {
-  return {
-    type: member.type,
-    origin: member.origin,
-    ref: member.ref,
-    extends: member.extendsRefs ?? member.extends,
-    endpoints: member.endpoints,
-    orientation: member.orientation,
-    constraints: member.constraints,
-    propertyMetadata: member.propertyMetadata,
-    data: member.data,
-    policies: member.policies,
-  }
-}
-
-function memberMetadata(member: IrClass): unknown {
-  return { description: member.description, icon: member.icon }
-}
-
-function sortedKeys(value: Record<string, unknown>): string[] {
-  return Object.keys(value).sort((left, right) => left.localeCompare(right))
-}
-
-function same(left: unknown, right: unknown): boolean {
-  return JSON.stringify(canonical(left)) === JSON.stringify(canonical(right))
-}
-
-function canonical(value: unknown): unknown {
-  if (Array.isArray(value)) return value.map(canonical)
-  if (value === null || typeof value !== 'object') return value
-  return Object.fromEntries(
-    Object.entries(value as Record<string, unknown>)
-      .filter(([, item]) => item !== undefined)
-      .sort(([left], [right]) => left.localeCompare(right))
-      .map(([key, item]) => [key, canonical(item)]),
-  )
-}
-
-export function structuralStatusOf(changes: SchemaChange[]): 'none' | 'changed' {
-  return changes.length === 0 ? 'none' : 'changed'
-}

package/studio/server/introspect/extractor.ts

@@ -1,41 +0,0 @@
-/** Bun subprocess that imports only the authored Schema entry and its installed SDK. */
-import {
-  admitCanonicalSchemaFromSdk,
-  findCanonicalDomainSchemaExport,
-  projectCanonicalSchema,
-} from './canonical-schema'
-
-const schemaPath = process.argv[2]
-const projectRoot = process.argv[3] ?? process.cwd()
-
-async function main(): Promise<void> {
-  if (!schemaPath) throw new Error('extractor: missing <schemaPath>')
-  const exports = (await import(schemaPath)) as Record<string, unknown>
-  const candidate = findCanonicalDomainSchemaExport(exports)
-  if (candidate === null) {
-    throw new Error('Schema entry exports no canonical V1 DomainSchema.')
-  }
-  const sdk = (await import(Bun.resolveSync('@astrale-os/sdk/schema', projectRoot))) as Record<
-    string,
-    unknown
-  >
-  const admission = admitCanonicalSchemaFromSdk(sdk, candidate)
-  const projected = projectCanonicalSchema(admission.root, admission.closure)
-  process.stdout.write(
-    JSON.stringify({
-      ok: true,
-      ir: projected.ir,
-      root: admission.root,
-      schemaMode: admission.status === 'admitted' ? 'canonical-admitted' : 'canonical-preview',
-      revision: admission.revision,
-    }),
-  )
-}
-
-main().catch((cause: unknown) => {
-  const error = cause instanceof Error ? cause : new Error(String(cause))
-  process.stdout.write(
-    JSON.stringify({ ok: false, error: { message: error.message, stack: error.stack ?? '' } }),
-  )
-  process.exit(0)
-})

package/studio/server/introspect/hash.ts

@@ -1,24 +0,0 @@
-import { createHash } from 'node:crypto'
-
-/** Deterministic JSON with stable key order — so cosmetic edits/reordering don't churn the hash. */
-export function canonicalJSON(value: unknown): string {
-  return JSON.stringify(sortKeys(value))
-}
-
-function sortKeys(v: any): any {
-  if (Array.isArray(v)) return v.map(sortKeys)
-  if (v && typeof v === 'object') {
-    const out: Record<string, any> = {}
-    for (const k of Object.keys(v).sort()) out[k] = sortKeys(v[k])
-    return out
-  }
-  return v
-}
-
-/**
- * Short, deterministic identity for Studio rendering/cache invalidation only.
- * This is deliberately not the DSL-owned `schema.revision()`.
- */
-export function renderFingerprintOf(value: unknown): string {
-  return 'sha-' + createHash('sha256').update(canonicalJSON(value)).digest('hex').slice(0, 12)
-}