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

package/studio/shared/contracts/schema.ts

@@ -5,7 +5,7 @@
  * is owned by `../schema/identity`; SDK admission owns schema semantics.
  */
 
-import type { IrDefinitionKey, IrDefinitionRef, IrSchemaRef } from '../schema/identity'
+import type { IrClassKey, IrClassRef, IrSchemaRef } from '../schema/identity'
 
 export interface JsonSchema {
   type?: string | string[]
@@ -46,67 +46,27 @@ export type IrCallableOutput =
   | { mode: 'stream'; item: JsonSchema }
   | { mode: 'binary' }
 
-export interface IrMethod {
-  name: string
-  /** Canonical callable input. Legacy projections expose only `params`. */
-  input?: JsonSchema
-  params: Record<string, JsonSchema>
-  /** Names required by canonical `input.required`; absent on legacy Methods. */
-  requiredParams?: string[]
-  /** Canonical discriminated output. Legacy projections expose only `returns`. */
-  output?: IrCallableOutput
-  returns: JsonSchema
-  static: boolean
-  inheritance: MethodInheritance
-  description?: string
-  auth?: IrCallableAuth
-  policy?: unknown
-}
-
-/** Standalone Domain Function projected into the Studio's callable vocabulary. */
-export interface IrFunction {
+export interface IrCallable {
   name: string
   input: JsonSchema
-  params: Record<string, JsonSchema>
-  /** Names required by canonical `input.required`. */
-  requiredParams?: string[]
   output: IrCallableOutput
-  returns: JsonSchema
-  /** Standalone Functions have no receiver; these legacy-compatible fields let
-   * existing callable renderers consume them alongside static Methods. */
-  static: true
-  inheritance: 'default'
   description?: string
   auth?: IrCallableAuth
   policy?: unknown
 }
 
-export interface IrInterface {
-  type: 'interface'
-  name: string
-  /** Canonical declaration owner/family; absent on legacy projections. */
-  origin?: string
-  family?: 'node' | 'edge' | 'both'
-  ref?: IrSchemaRef
-  extends?: string[]
-  extendsRefs?: IrSchemaRef[]
-  properties: Record<string, JsonSchema>
-  /** Canonical `properties.required`; absence, unlike null, encodes optionality. */
-  required?: string[]
-  methods: Record<string, IrMethod>
-  endpoints?: IrEndpoint[]
-  orientation?: 'directed' | 'undirected'
-  constraints?: { noSelf?: true; acyclic?: true }
-  description?: string
-  propertyMetadata?: Record<string, unknown>
-  /** Canonical data declaration; `mediaType` is required and extensions stay lossless. */
-  data?: { mediaType: string; [key: string]: unknown }
+export interface IrMethod extends IrCallable {
+  static: boolean
+  inheritance: MethodInheritance
 }
 
+/** Standalone DSL callable projected without inventing a receiver. */
+export interface IrFunction extends IrCallable {}
+
 export interface IrEndpoint {
   name: string
   types: string[]
-  /** Exact accepted Definition coordinates. `types` remains for existing UI consumers. */
+  /** Exact accepted Definition coordinates. `types` is the local display projection. */
   refs?: IrSchemaRef[]
   /** declared multiplicity for this end; max:null = unbounded ("many"). Absent ⇒ unconstrained. */
   cardinality?: { min: number; max: number | null }
@@ -115,11 +75,10 @@ export interface IrEndpoint {
 export interface IrClass {
   type: 'node' | 'edge'
   name: string
-  /** Canonical declaration owner/ref; absent on legacy projections. */
-  origin?: string
-  ref?: IrSchemaRef
-  implements?: string[]
-  implementsRefs?: IrSchemaRef[]
+  origin: string
+  ref: IrClassRef
+  extends?: string[]
+  extendsRefs?: IrClassRef[]
   /** edges only: the two (source,target) endpoints with role names + allowed types */
   endpoints?: IrEndpoint[]
   orientation?: 'directed' | 'undirected'
@@ -139,10 +98,8 @@ export interface IrClass {
 
 export interface IrImportDescriptor {
   origin: string
-  definition: 'interface' | 'class'
-  ref?: IrDefinitionRef
-  /** Canonical qualified identity; absent on legacy import descriptors. */
-  key?: IrDefinitionKey
+  ref: IrClassRef
+  key: IrClassKey
 }
 
 export type IrViewTarget = { kind: 'domain' } | { kind: 'definition'; definitions: IrSchemaRef[] }
@@ -155,36 +112,26 @@ export interface IrView {
 }
 
 export interface SchemaIR {
+  format: 'astrale.dsl'
   version: string
   domain: string
-  /** Canonical document format; absent on legacy projections. */
-  format?: 'astrale.dsl'
-  types: Record<string, JsonSchema>
-  interfaces: Record<string, IrInterface>
   classes: Record<string, IrClass>
-  imports: Record<string, IrImportDescriptor>
-  /**
-   * Canonical authoritative import index, keyed by `origin:kind.name`.
-   * `imports` remains the unambiguous short-name compatibility index.
-   */
-  importsByKey?: Record<IrDefinitionKey, IrImportDescriptor>
-  /** Exact imported Interface bodies under the same collision-free identity. */
-  importedInterfacesByKey?: Record<IrDefinitionKey, IrInterface>
-  /** Canonical V1 members absent from the legacy serializer projection. */
+  importsByKey: Record<IrClassKey, IrImportDescriptor>
+  importedClassesByKey: Record<IrClassKey, IrClass>
   functions: Record<string, IrFunction>
-  views?: Record<string, IrView>
-  policies?: Record<string, unknown>
-  dependencies?: Array<{ origin: string; revision: string }>
-  /** Exact canonical genesis declaration; absent on legacy projections. */
-  core?: unknown
+  views: Record<string, IrView>
+  policies: Record<string, unknown>
+  dependencies: Array<{ origin: string; revision: string }>
+  core: unknown
 }
 
 export interface HandlerLink {
   owner: string
-  ownerKind: 'class' | 'interface' | 'function'
+  ownerKind: 'class' | 'function'
+  kind: 'action' | 'workflow'
   method: string
   static: boolean
-  /** the legacy runtime registry or current implementation.ts wiring site */
+  /** The Runtime registry or one modular Action/Workflow file. */
   wiringFile?: string
   wiringLine?: number
   /** the resolved handler file (followed from the `execute` import) */
@@ -192,14 +139,6 @@ export interface HandlerLink {
   handlerLine?: number
   /** kernel ops detected in the handler (::update, ::link, createNode, …) */
   kernelCalls?: string[]
-  /** declared auth policy on the runtime config; absent ⇒ defaults to 'required'. */
-  auth?: 'public' | 'optional' | 'required'
-  /** Canonical V1 callable auth, when the handler comes from implementation.ts. */
-  callableAuth?: IrCallableAuth
-  /** authorize hook shape: 'absent' (none), 'noop' (allow-all), 'custom' (real check). */
-  authorize?: 'absent' | 'noop' | 'custom'
-  /** raw source of the authorize hook (for the hover preview). */
-  authorizeSnippet?: string
   /** false ⇒ a todo()/NotImplemented stub → "contract-only" badge */
   implemented: boolean
   /** true ⇒ resolver could not link a file → "unlinked" badge */
@@ -224,20 +163,19 @@ export interface SchemaAnnotation {
 export interface CrossDomainImport {
   name: string
   origin: string
-  definition: 'interface' | 'class'
+  ref: IrClassRef
 }
 
 export interface SchemaOverlay {
   origin: string
-  /** defineDomain({ requires }) — runtime domain dependencies */
+  /** Exact declared Domain dependencies. */
   requires: string[]
-  /** non-kernel ir.imports → true cross-domain imports */
+  /** Non-Kernel imported Classes. */
   crossDomainImports: CrossDomainImport[]
-  /** kernel-origin ir.imports → mixin interfaces (collapsed chip) */
+  /** Kernel base Classes rendered as inherited platform facts. */
   mixins: CrossDomainImport[]
-  postInstall?: string
   handlerLinks: HandlerLink[]
-  /** keyed by anchor ref (class.X / class.X.property.y / class.X.method.m / edge.e / interface.I…) */
+  /** Keyed by Class, Property, Method, Function, Policy, View, or Core anchor. */
   sourceSpans: Record<string, SourceSpan>
   annotations: SchemaAnnotation[]
 }
@@ -251,25 +189,19 @@ export interface StudioSchemaBundle {
   domainId: string
   /** UI/cache identity only. This is not the DSL schema revision. */
   renderFingerprint: string
-  schemaMode: 'canonical-admitted' | 'canonical-preview' | 'legacy' | 'unavailable'
-  /** DSL-owned revision, present only after cohort SDK admission. */
+  schemaMode: 'canonical-admitted' | 'canonical-preview' | 'unavailable'
+  /** DSL-owned revision, present only after installed SDK admission. */
   schemaRevision?: SchemaRevision
   extractedBy: 'runtime-bun' | 'static-tsmorph-fallback'
   depsInstalled: boolean
   ir: SchemaIR | null
   /**
    * Portable canonical V1 document emitted by the domain. `schemaMode` records
-   * whether the cohort SDK admitted it or Studio is rendering it as a structural
-   * preview. Kept separate from the lossy render IR; absent for legacy domains.
+   * whether the installed SDK admitted it or Studio is rendering it as a structural
+   * preview. Kept separate from the lossy render IR.
    */
   schemaRoot?: unknown
   overlay: SchemaOverlay
-  /**
-   * Unambiguous short-name aliases for imported Interface bodies, retained for
-   * legacy renderers. Canonical consumers use `ir.importedInterfacesByKey`, whose
-   * `origin:interface.Name` keys cannot collide. Empty when deps aren't installed.
-   */
-  importedInterfaces?: Record<string, IrInterface>
   /** present when the runtime import failed to compile (render state, not a crash) */
   error?: BundleError | null
   extractedAt: string
@@ -277,12 +209,11 @@ export interface StudioSchemaBundle {
 
 export interface DomainOverview {
   origin: string
-  /** Active SDK composition entry; `domain.ts` is retained for legacy projects. */
-  compositionFile?: 'implementation.ts' | 'domain.ts'
+  /** Active SDK Application entry relative to the project root. */
+  applicationFile?: string
   adapter: 'astrale' | 'cloudflare' | 'unknown'
   prodTarget?: string
   devSecrets?: string
-  postInstall?: string
   requires: string[]
   packageName?: string
   packageVersion?: string
@@ -427,9 +358,9 @@ export interface StudioCoreNode {
 
 /** One materialized edge instance wiring two core nodes. */
 export interface StudioCoreEdge {
-  /** source Core path, owning Domain path, or a legacy meta-node endpoint */
+  /** source Core path or owning Domain path */
   from: string
-  /** target Core path, owning Domain path, or a legacy meta-node endpoint */
+  /** target Core path or owning Domain path */
   to: string
   /** the IR edge class name (keys into StudioSchemaBundle.ir.classes, type:'edge') */
   edgeName: string

package/studio/shared/contracts/surface.test.ts

@@ -6,10 +6,9 @@ import ts from 'typescript'
 const SHARED_ROOT = resolve(import.meta.dir, '..')
 const STUDIO_ROOT = resolve(SHARED_ROOT, '..')
 
-// Frozen from HEAD's former monolithic shared/types.ts before it was split.
-// Keeping this manifest in the test makes the compatibility proof independent
-// of Git and catches any historical symbol silently dropped by a future move.
-const HISTORICAL_BARREL_EXPORTS = [
+// Closed Studio V1 shared surface. Keeping this manifest independent of Git
+// catches accidental aliases and shadow contracts.
+const TARGET_BARREL_EXPORTS = [
   'AGENT_ACCESS_LEVELS',
   'AGENT_EFFORT_LEVELS',
   'AgentAccess',
@@ -61,15 +60,15 @@ const HISTORICAL_BARREL_EXPORTS = [
   'InstancesState',
   'Integration',
   'IntegrationsState',
+  'IrCallable',
   'IrCallableAuth',
   'IrCallableOutput',
   'IrClass',
-  'IrDefinitionKey',
-  'IrDefinitionRef',
+  'IrClassKey',
+  'IrClassRef',
   'IrEndpoint',
   'IrFunction',
   'IrImportDescriptor',
-  'IrInterface',
   'IrMethod',
   'IrSchemaKey',
   'IrSchemaRef',
@@ -108,24 +107,23 @@ const HISTORICAL_BARREL_EXPORTS = [
   'VisibilityState',
 ] as const
 
-// Deliberate canonical identity/revision helpers added alongside the split.
-const INTENTIONAL_BARREL_ADDITIONS = [
+const TARGET_BARREL_HELPERS = [
   'IR_SCHEMA_REF_KINDS',
   'IrSchemaRefKind',
   'STUDIO_SCHEMA_PROJECTION_VERSION',
   'SchemaRevision',
-  'definitionRefKey',
-  'isIrDefinitionRef',
-  'isIrInterfaceRef',
+  'classRefKey',
+  'isIrClassRef',
   'isIrSchemaRef',
   'isSchemaRevision',
-  'parseDefinitionRefKey',
+  'parseClassRefKey',
   'parseSchemaRefKey',
   'schemaRefKey',
 ] as const
 
 function productionFiles(dir: string): string[] {
   return readdirSync(dir).flatMap((entry) => {
+    if (entry === 'node_modules') return []
     const path = join(dir, entry)
     if (statSync(path).isDirectory()) return productionFiles(path)
     return /\.(?:ts|tsx)$/.test(path) && !/\.test\.(?:ts|tsx)$/.test(path) ? [path] : []
@@ -277,10 +275,10 @@ test('types.ts remains a re-export-only compatibility facade', () => {
   expect(source.statements.every(ts.isExportDeclaration)).toBe(true)
 })
 
-test('types.ts exhaustively preserves its historical named export surface', () => {
+test('types.ts exposes exactly the Studio V1 shared surface', () => {
   const exports = namedExports(join(SHARED_ROOT, 'types.ts'))
   const duplicates = exports.filter((name, index) => exports.indexOf(name) !== index)
-  const expected = [...HISTORICAL_BARREL_EXPORTS, ...INTENTIONAL_BARREL_ADDITIONS].sort()
+  const expected = [...TARGET_BARREL_EXPORTS, ...TARGET_BARREL_HELPERS].sort()
 
   expect(duplicates).toEqual([])
   expect(exports.sort()).toEqual(expected)

package/studio/shared/contracts/workspace.ts

@@ -113,18 +113,12 @@ export interface MergeResult {
 
 export type SchemaChangeKind =
   | 'schema-metadata-changed'
-  | 'type-added'
-  | 'type-removed'
-  | 'type-changed'
   | 'import-added'
   | 'import-removed'
   | 'import-changed'
   | 'class-added'
   | 'class-removed'
   | 'class-contract-changed'
-  | 'interface-added'
-  | 'interface-removed'
-  | 'interface-contract-changed'
   | 'edge-added'
   | 'edge-removed'
   | 'edge-contract-changed'
@@ -264,11 +258,8 @@ export interface LayoutState {
 
 /** Persisted per-domain canvas visibility. This is the sole authority for its JSON shape. */
 export interface VisibilityState {
-  /** refs hidden on the canvas: `class.X` | `edge.X` | `domain.<origin>` (interfaces use
-   *  `materializedInterfaces`, not this set — see below) */
+  /** Refs hidden on the canvas: `class.X` | `edge.X` | `domain.<origin>`. */
   hidden: Record<string, true>
+  /** Whether local Class inheritance edges are rendered. */
   showInheritedEdges: boolean
-  /** Local interfaces MATERIALIZED as canvas NODES (default = badge). Keyed by BARE interface
-   *  name (e.g. `Fulfillable`) — a set distinct from `hidden`, so no ref namespace collision. */
-  materializedInterfaces: Record<string, true>
 }

package/studio/shared/schema/identity.test.ts

@@ -1,58 +1,34 @@
 import { describe, expect, test } from 'bun:test'
 
 import {
-  IR_SCHEMA_REF_KINDS,
-  definitionRefKey,
-  isIrDefinitionRef,
-  isIrInterfaceRef,
+  classRefKey,
+  isIrClassRef,
   isIrSchemaRef,
-  parseDefinitionRefKey,
+  parseClassRefKey,
   parseSchemaRefKey,
   schemaRefKey,
-  type IrSchemaRef,
 } from './identity'
 
-describe('canonical schema identity', () => {
-  test('round-trips every structural reference kind without short-name aliases', () => {
-    for (const kind of IR_SCHEMA_REF_KINDS) {
-      const ref = {
-        origin: 'directory.example.dev',
-        kind,
-        name: '$Named_member',
-      } satisfies IrSchemaRef
-      expect(parseSchemaRefKey(schemaRefKey(ref))).toEqual(ref)
-    }
+describe('schema identity', () => {
+  test('round-trips exact Class identity', () => {
+    const ref = { origin: 'docs.example.dev', kind: 'class' as const, name: 'Document' }
+    expect(classRefKey(ref)).toBe('docs.example.dev:class.Document')
+    expect(parseClassRefKey(classRefKey(ref))).toEqual(ref)
+    expect(isIrClassRef(ref)).toBe(true)
   })
 
-  test('keeps class and interface identities distinct', () => {
-    const classRef = { origin: 'contracts.example.dev', kind: 'class', name: 'Shared' } as const
-    const interfaceRef = {
-      origin: 'contracts.example.dev',
-      kind: 'interface',
-      name: 'Shared',
-    } as const
-
-    expect(definitionRefKey(classRef)).toBe('contracts.example.dev:class.Shared')
-    expect(definitionRefKey(interfaceRef)).toBe('contracts.example.dev:interface.Shared')
-    expect(parseDefinitionRefKey(definitionRefKey(classRef))).toEqual(classRef)
-    expect(parseDefinitionRefKey(definitionRefKey(interfaceRef))).toEqual(interfaceRef)
-  })
-
-  test('guards structural refs without claiming SDK admission', () => {
-    expect(isIrSchemaRef({ origin: 'a.dev', kind: 'policy', name: 'may_read' })).toBe(true)
-    expect(isIrDefinitionRef({ origin: 'a.dev', kind: 'class', name: 'Thing' })).toBe(true)
-    expect(isIrDefinitionRef({ origin: 'a.dev', kind: 'policy', name: 'may_read' })).toBe(false)
-    expect(isIrInterfaceRef({ origin: 'a.dev', kind: 'interface', name: 'Named' })).toBe(true)
-    expect(isIrInterfaceRef({ origin: 'a.dev', kind: 'class', name: 'Named' })).toBe(false)
-    expect(isIrSchemaRef({ origin: 'a.dev', kind: 'unknown', name: 'Thing' })).toBe(false)
-    expect(isIrSchemaRef({ origin: 'a.dev', kind: 'class' })).toBe(false)
+  test('preserves all supported schema reference kinds', () => {
+    const ref = { origin: 'docs.example.dev', kind: 'function' as const, name: 'search' }
+    expect(schemaRefKey(ref)).toBe('docs.example.dev:function.search')
+    expect(parseSchemaRefKey(schemaRefKey(ref))).toEqual(ref)
+    expect(isIrSchemaRef(ref)).toBe(true)
   })
 
-  test('rejects malformed and non-definition keys', () => {
-    expect(parseSchemaRefKey('a.dev:unknown.Thing')).toBeUndefined()
-    expect(parseSchemaRefKey('a.dev:class.')).toBeUndefined()
-    expect(parseSchemaRefKey(':class.Thing')).toBeUndefined()
-    expect(parseSchemaRefKey(null)).toBeUndefined()
-    expect(parseDefinitionRefKey('a.dev:type.Payload')).toBeUndefined()
+  test('rejects removed Interface coordinates and malformed keys', () => {
+    expect(isIrSchemaRef({ origin: 'docs.example.dev', kind: 'interface', name: 'Named' })).toBe(
+      false,
+    )
+    expect(parseSchemaRefKey('docs.example.dev:interface.Named')).toBeUndefined()
+    expect(parseClassRefKey('docs.example.dev:function.search')).toBeUndefined()
   })
 })

package/studio/shared/schema/identity.ts

@@ -5,15 +5,7 @@
  * admission remains the authority for whether a reference is semantically valid.
  */
 
-export const IR_SCHEMA_REF_KINDS = [
-  'type',
-  'interface',
-  'class',
-  'function',
-  'policy',
-  'view',
-  'core',
-] as const
+export const IR_SCHEMA_REF_KINDS = ['class', 'function', 'policy', 'view', 'core'] as const
 
 export type IrSchemaRefKind = (typeof IR_SCHEMA_REF_KINDS)[number]
 
@@ -27,14 +19,12 @@ export interface IrSchemaRef {
 /** Canonical DSL key for a schema member: `origin:kind.name`. */
 export type IrSchemaKey = `${string}:${IrSchemaRefKind}.${string}`
 
-export type IrDefinitionRef = Omit<IrSchemaRef, 'kind'> & {
-  kind: 'class' | 'interface'
-}
+export type IrClassRef = Omit<IrSchemaRef, 'kind'> & { kind: 'class' }
 
-export type IrDefinitionKey = `${string}:${IrDefinitionRef['kind']}.${string}`
+export type IrClassKey = `${string}:class.${string}`
 
 const schemaKinds = new Set<string>(IR_SCHEMA_REF_KINDS)
-const schemaKeyPattern = /^(.+):(type|interface|class|function|policy|view|core)\.(.+)$/
+const schemaKeyPattern = /^(.+):(class|function|policy|view|core)\.(.+)$/
 
 /** Structural guard only; it deliberately does not perform SDK admission. */
 export function isIrSchemaRef(value: unknown): value is IrSchemaRef {
@@ -48,19 +38,15 @@ export function isIrSchemaRef(value: unknown): value is IrSchemaRef {
   )
 }
 
-export function isIrDefinitionRef(value: unknown): value is IrDefinitionRef {
-  return isIrSchemaRef(value) && (value.kind === 'class' || value.kind === 'interface')
-}
-
-export function isIrInterfaceRef(value: unknown): value is IrDefinitionRef & { kind: 'interface' } {
-  return isIrSchemaRef(value) && value.kind === 'interface'
+export function isIrClassRef(value: unknown): value is IrClassRef {
+  return isIrSchemaRef(value) && value.kind === 'class'
 }
 
 export function schemaRefKey(ref: IrSchemaRef): IrSchemaKey {
   return `${ref.origin}:${ref.kind}.${ref.name}`
 }
 
-export function definitionRefKey(ref: IrDefinitionRef): IrDefinitionKey {
+export function classRefKey(ref: IrClassRef): IrClassKey {
   return `${ref.origin}:${ref.kind}.${ref.name}`
 }
 
@@ -76,7 +62,7 @@ export function parseSchemaRefKey(value: unknown): IrSchemaRef | undefined {
   }
 }
 
-export function parseDefinitionRefKey(value: unknown): IrDefinitionRef | undefined {
+export function parseClassRefKey(value: unknown): IrClassRef | undefined {
   const ref = parseSchemaRefKey(value)
-  return ref && isIrDefinitionRef(ref) ? ref : undefined
+  return ref && isIrClassRef(ref) ? ref : undefined
 }