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

package/studio/server/sse.ts

@@ -1,60 +0,0 @@
-/**
- * sse.ts — a tiny server-sent-events hub. One-directional server→client; the
- * studio is read-only so the client never pushes here (it uses POST).
- */
-import type { StudioEvent } from '../shared/types'
-
-const encoder = new TextEncoder()
-const clients = new Map<number, ReadableStreamDefaultController<Uint8Array>>()
-let nextId = 1
-
-export function sseResponse(domains: string[]): Response {
-  let id = 0
-  let keepalive: ReturnType<typeof setInterval> | undefined
-  const stream = new ReadableStream<Uint8Array>({
-    start(controller) {
-      id = nextId++
-      clients.set(id, controller)
-      controller.enqueue(encoder.encode(frame({ type: 'hello', domains })))
-      // keepalive comment every 20s — long agent turns can go minutes between
-      // events; without this the connection is idle and gets dropped.
-      keepalive = setInterval(() => {
-        try {
-          controller.enqueue(encoder.encode(': keepalive\n\n'))
-        } catch {
-          clearInterval(keepalive)
-          clients.delete(id)
-        }
-      }, 20_000)
-    },
-    cancel() {
-      clearInterval(keepalive)
-      clients.delete(id)
-    },
-  })
-  return new Response(stream, {
-    headers: {
-      'content-type': 'text/event-stream',
-      'cache-control': 'no-cache, no-transform',
-      connection: 'keep-alive',
-    },
-  })
-}
-
-/** Broadcast an event and report how many clients were registered at dispatch start. */
-export function broadcast(event: StudioEvent): number {
-  const recipients = clients.size
-  const payload = encoder.encode(frame(event))
-  for (const [id, c] of clients) {
-    try {
-      c.enqueue(payload)
-    } catch {
-      clients.delete(id)
-    }
-  }
-  return recipients
-}
-
-function frame(event: StudioEvent): string {
-  return `data: ${JSON.stringify(event)}\n\n`
-}

package/studio/server/state/baseline.test.ts

@@ -1,267 +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 type { SchemaIR } from '../../shared/types'
-
-import { STUDIO_SCHEMA_PROJECTION_VERSION } from '../../shared/types'
-import {
-  BASELINE_FORMAT_VERSION,
-  captureBaseline,
-  computeChanges,
-  hashAnatomyFiles,
-  loadBaseline,
-} from './baseline'
-import { writeJson, writeState } from './store'
-
-const roots: string[] = []
-
-afterEach(() => {
-  while (roots.length) rmSync(roots.pop()!, { recursive: true, force: true })
-})
-
-test('hashes current Application and vertical authoring files', () => {
-  const root = mkdtempSync(join(tmpdir(), 'studio-current-baseline-'))
-  roots.push(root)
-  for (const dir of [
-    'schema',
-    'actions/risk',
-    'providers/mail',
-    'queries/risk',
-    'ui/risk',
-    'views/risk',
-  ]) {
-    mkdirSync(join(root, dir), { recursive: true })
-  }
-  for (const file of [
-    'schema/index.ts',
-    'application.ts',
-    'runtime.ts',
-    'actions/risk/index.ts',
-    'providers/mail/index.ts',
-    'queries/risk/index.ts',
-    'ui/risk/screen.tsx',
-    'views/risk/index.ts',
-    'package.json',
-  ]) {
-    writeFileSync(join(root, file), `${file}\n`)
-  }
-  writeFileSync(join(root, 'README.md'), 'not part of the anatomy fileset\n')
-
-  expect(Object.keys(hashAnatomyFiles(root, 'schema')).sort()).toEqual([
-    'actions/risk/index.ts',
-    'application.ts',
-    'package.json',
-    'providers/mail/index.ts',
-    'queries/risk/index.ts',
-    'runtime.ts',
-    'schema/index.ts',
-    'ui/risk/screen.tsx',
-    'views/risk/index.ts',
-  ])
-})
-
-const schema = (domain: string): SchemaIR => ({
-  format: 'astrale.dsl',
-  version: 'v1',
-  domain,
-  classes: {},
-  importsByKey: {},
-  importedClassesByKey: {},
-  functions: {},
-  views: {},
-  policies: {},
-  dependencies: [],
-  core: {},
-})
-
-const canonicalRoot = {
-  format: 'astrale.dsl',
-  version: 'v1',
-  origin: 'notes.example.dev',
-} as const
-
-test('persists a versioned canonical baseline with revision and raw root', () => {
-  const root = mkdtempSync(join(tmpdir(), 'studio-versioned-baseline-'))
-  roots.push(root)
-  const revision = `sha256:${'b'.repeat(64)}` as const
-
-  captureBaseline(
-    root,
-    { ir: schema('notes.example.dev'), root: canonicalRoot, revision },
-    { source: 'hash' },
-  )
-
-  expect(loadBaseline(root)).toMatchObject({
-    formatVersion: BASELINE_FORMAT_VERSION,
-    revision,
-    root: canonicalRoot,
-    files: { source: 'hash' },
-  })
-})
-
-test('invalidates an unversioned baseline instead of diffing it through a new projection', () => {
-  const root = mkdtempSync(join(tmpdir(), 'studio-legacy-baseline-'))
-  roots.push(root)
-  writeJson(root, '.cache/baseline/meta.json', { capturedAt: '2026-01-01T00:00:00.000Z' })
-  writeJson(root, '.cache/baseline/ir.json', schema('notes.example.dev'))
-  writeJson(root, '.cache/baseline/files.json', {})
-
-  expect(loadBaseline(root)).toBeNull()
-})
-
-const corruptBaselineCases = [
-  {
-    name: 'missing meta',
-    mutate: (root: string) => rmSync(join(root, '.domain-studio/.cache/baseline/meta.json')),
-  },
-  {
-    name: 'syntactically invalid meta',
-    mutate: (root: string) => writeState(root, '.cache/baseline/meta.json', '{'),
-  },
-  {
-    name: 'structurally invalid meta',
-    mutate: (root: string) =>
-      writeJson(root, '.cache/baseline/meta.json', {
-        formatVersion: BASELINE_FORMAT_VERSION,
-        projectionVersion: STUDIO_SCHEMA_PROJECTION_VERSION,
-      }),
-  },
-  {
-    name: 'future baseline format',
-    mutate: (root: string) =>
-      writeJson(root, '.cache/baseline/meta.json', {
-        formatVersion: BASELINE_FORMAT_VERSION + 1,
-        projectionVersion: STUDIO_SCHEMA_PROJECTION_VERSION,
-        revision: `sha256:${'d'.repeat(64)}`,
-      }),
-  },
-  {
-    name: 'future projection format',
-    mutate: (root: string) =>
-      writeJson(root, '.cache/baseline/meta.json', {
-        formatVersion: BASELINE_FORMAT_VERSION,
-        projectionVersion: STUDIO_SCHEMA_PROJECTION_VERSION + 1,
-        revision: `sha256:${'d'.repeat(64)}`,
-      }),
-  },
-  {
-    name: 'missing IR',
-    mutate: (root: string) => rmSync(join(root, '.domain-studio/.cache/baseline/ir.json')),
-  },
-  {
-    name: 'syntactically invalid IR',
-    mutate: (root: string) => writeState(root, '.cache/baseline/ir.json', '{'),
-  },
-  {
-    name: 'structurally invalid IR',
-    mutate: (root: string) =>
-      writeJson(root, '.cache/baseline/ir.json', {
-        ...schema('notes.example.dev'),
-        classes: { Broken: null },
-      }),
-  },
-  {
-    name: 'missing canonical root',
-    mutate: (root: string) => rmSync(join(root, '.domain-studio/.cache/baseline/schema-root.json')),
-  },
-  {
-    name: 'syntactically invalid canonical root',
-    mutate: (root: string) => writeState(root, '.cache/baseline/schema-root.json', '{'),
-  },
-  {
-    name: 'structurally invalid canonical root',
-    mutate: (root: string) =>
-      writeJson(root, '.cache/baseline/schema-root.json', { canonical: true }),
-  },
-  {
-    name: 'missing file hashes',
-    mutate: (root: string) => rmSync(join(root, '.domain-studio/.cache/baseline/files.json')),
-  },
-  {
-    name: 'syntactically invalid file hashes',
-    mutate: (root: string) => writeState(root, '.cache/baseline/files.json', '{'),
-  },
-  {
-    name: 'structurally invalid file hashes',
-    mutate: (root: string) => writeJson(root, '.cache/baseline/files.json', { source: 42 }),
-  },
-] as const
-
-for (const scenario of corruptBaselineCases) {
-  test(`invalidates a baseline with ${scenario.name}`, () => {
-    const root = mkdtempSync(join(tmpdir(), 'studio-corrupt-baseline-'))
-    roots.push(root)
-    const revision = `sha256:${'d'.repeat(64)}` as const
-    captureBaseline(root, { ir: schema('notes.example.dev'), root: canonicalRoot, revision }, {})
-
-    scenario.mutate(root)
-
-    expect(loadBaseline(root)).toBeNull()
-  })
-}
-
-test('keeps a valid current-format legacy baseline without a canonical root or revision', () => {
-  const root = mkdtempSync(join(tmpdir(), 'studio-legacy-v2-baseline-'))
-  roots.push(root)
-  const legacyIr = { ...schema('notes.example.dev'), version: 'legacy' }
-
-  captureBaseline(root, { ir: legacyIr, root: null, revision: null }, { source: 'hash' })
-
-  expect(loadBaseline(root)).toMatchObject({
-    formatVersion: BASELINE_FORMAT_VERSION,
-    ir: legacyIr,
-    root: null,
-    revision: null,
-    files: { source: 'hash' },
-  })
-})
-
-test('uses equal admitted revisions to suppress projection-only schema churn', () => {
-  const root = mkdtempSync(join(tmpdir(), 'studio-revision-baseline-'))
-  roots.push(root)
-  const revision = `sha256:${'c'.repeat(64)}` as const
-  captureBaseline(
-    root,
-    {
-      ir: schema('old-projection.example.dev'),
-      root: { ...canonicalRoot, origin: 'old-projection.example.dev' },
-      revision,
-    },
-    {},
-  )
-
-  const changes = computeChanges(
-    root,
-    schema('new-projection.example.dev'),
-    {},
-    {
-      currentRevision: revision,
-      git: { hasGit: false },
-    },
-  )
-  expect(changes.schemaChanges).toEqual([])
-  expect(changes.structuralStatus).toBe('none')
-  expect(changes.baselineRevision).toBe(revision)
-  expect(changes.currentRevision).toBe(revision)
-})
-
-test('uses caller-provided Git enrichment without importing workspace effects', () => {
-  const root = mkdtempSync(join(tmpdir(), 'studio-enriched-baseline-'))
-  roots.push(root)
-  captureBaseline(root, { ir: schema('notes.example.dev'), root: null, revision: null }, {})
-
-  const changes = computeChanges(
-    root,
-    schema('notes.example.dev'),
-    {},
-    {
-      git: { hasGit: true, diffText: 'diff --git a/schema/index.ts b/schema/index.ts' },
-    },
-  )
-
-  expect(changes.source).toBe('git')
-  expect(changes.hasGit).toBe(true)
-  expect(changes.schemaDiffText).toBe('diff --git a/schema/index.ts b/schema/index.ts')
-})

package/studio/server/state/baseline.ts

@@ -1,354 +0,0 @@
-/**
- * baseline.ts — the PRIMARY change tracker. On first launch we capture a
- * versioned snapshot (canonical revision/root, render IR, and a content hash of
- * the "anatomy + schema fileset")
- * under `.domain-studio/.cache/baseline/`. Subsequent runs diff the live state
- * against that baseline to compute a ChangeSet. Git (git.ts) only enriches when
- * a real repo is present; the fixtures are not repos, so baseline stands alone.
- *
- * Layout under `.cache/baseline/`:
- *   ir.json           — the captured render SchemaIR (or null)
- *   schema-root.json  — the admitted portable V1 root (or null)
- *   files.json        — { [relpathFromRoot]: sha256 }
- *   meta.json         — format/projection versions, revision, capturedAt
- */
-import { createHash } from 'node:crypto'
-import { existsSync, readFileSync, readdirSync, statSync } from 'node:fs'
-import { join, relative, resolve } from 'node:path'
-
-import type {
-  ChangeSet,
-  FileChange,
-  SchemaChange,
-  SchemaIR,
-  SchemaRevision,
-} from '../../shared/types'
-
-import { isSchemaRevision, STUDIO_SCHEMA_PROJECTION_VERSION } from '../../shared/types'
-import { isCanonicalDomainSchemaV1 } from '../introspect/canonical-schema'
-import { diffSchemas, structuralStatusOf } from '../introspect/diff'
-import { decodeSchemaIR } from '../introspect/schema-ir-json'
-import { asFiniteNumber, asJsonRecord, asStringRecord, parseJson } from '../json'
-import { readState, writeJson } from './store'
-
-const BASE = '.cache/baseline'
-export const BASELINE_FORMAT_VERSION = 2
-
-/** Directories to never descend into when hashing the fileset. */
-const SKIP_DIRS = new Set(['node_modules', '.dist', 'dist', '.domain-studio', '.git'])
-
-/**
- * The "anatomy + schema fileset": directories walked recursively + standalone
- * files. The schema dir is injected per-domain (its name is configurable), so it
- * is NOT listed here — see hashAnatomyFiles. Everything else is a fixed contract.
- */
-export const ANATOMY_GLOBS = {
-  dirs: [
-    'actions',
-    'core',
-    'providers',
-    'runtime',
-    'views',
-    'integrations',
-    'migrations',
-    'mutations',
-    'queries',
-    'rules',
-    'scripts',
-    'states',
-    'ui',
-    'utils',
-    'workflows',
-    'client/src',
-  ],
-  files: [
-    'application.ts',
-    'runtime.ts',
-    'index.ts',
-    'core.ts',
-    'deps.ts',
-    'env.ts',
-    'package.json',
-    'pnpm-workspace.yaml',
-    'astrale.config.ts',
-  ],
-} as const
-
-function sha256(buf: Buffer): string {
-  return createHash('sha256').update(buf).digest('hex')
-}
-
-/** Recursively collect file paths under `dir` (absolute), skipping SKIP_DIRS. */
-function walkFiles(dir: string, out: string[]): void {
-  let entries: string[]
-  try {
-    entries = readdirSync(dir)
-  } catch {
-    return
-  }
-  for (const e of entries) {
-    if (SKIP_DIRS.has(e)) continue
-    const full = join(dir, e)
-    let st
-    try {
-      st = statSync(full)
-    } catch {
-      continue
-    }
-    if (st.isDirectory()) walkFiles(full, out)
-    else if (st.isFile()) out.push(full)
-  }
-}
-
-/**
- * Hash (sha256) every file in the anatomy + schema fileset. Keys are paths
- * relative to `root`, forward-slashed. Missing dirs/files are silently skipped.
- */
-export function hashAnatomyFiles(root: string, schemaDirName: string): Record<string, string> {
-  const r = resolve(root)
-  const absFiles: string[] = []
-
-  // Schema dir (configurable name) + the fixed anatomy dirs.
-  for (const d of [schemaDirName, ...ANATOMY_GLOBS.dirs]) {
-    const abs = join(r, d)
-    if (existsSync(abs)) {
-      let st
-      try {
-        st = statSync(abs)
-      } catch {
-        st = null
-      }
-      if (st?.isDirectory()) walkFiles(abs, absFiles)
-      else if (st?.isFile()) absFiles.push(abs)
-    }
-  }
-
-  // Standalone files.
-  for (const f of ANATOMY_GLOBS.files) {
-    const abs = join(r, f)
-    if (existsSync(abs)) {
-      try {
-        if (statSync(abs).isFile()) absFiles.push(abs)
-      } catch {
-        /* skip */
-      }
-    }
-  }
-
-  const hashes: Record<string, string> = {}
-  for (const abs of absFiles) {
-    let buf: Buffer
-    try {
-      buf = readFileSync(abs)
-    } catch {
-      continue
-    }
-    const key = relative(r, abs).split('\\').join('/')
-    hashes[key] = sha256(buf)
-  }
-  return hashes
-}
-
-export interface Baseline {
-  formatVersion: typeof BASELINE_FORMAT_VERSION
-  projectionVersion: number
-  ir: SchemaIR | null
-  /** Admitted canonical root only; null for legacy/preview snapshots. */
-  root: unknown | null
-  revision: SchemaRevision | null
-  files: Record<string, string>
-  capturedAt?: string
-}
-
-export interface BaselineSchemaSnapshot {
-  ir: SchemaIR | null
-  /** Admitted canonical root only; preview roots must be passed as null. */
-  root: unknown | null
-  revision: SchemaRevision | null
-}
-
-interface BaselineMeta {
-  formatVersion: number
-  projectionVersion: number
-  revision: SchemaRevision | null
-  capturedAt?: string
-}
-
-function decodeBaselineMeta(value: unknown): BaselineMeta | undefined {
-  const record = asJsonRecord(value)
-  if (!record) return undefined
-  const formatVersion = asFiniteNumber(record.formatVersion)
-  const projectionVersion = asFiniteNumber(record.projectionVersion)
-  const revision =
-    record.revision === null
-      ? null
-      : isSchemaRevision(record.revision)
-        ? record.revision
-        : undefined
-  const capturedAt = record.capturedAt
-  if (
-    formatVersion === undefined ||
-    projectionVersion === undefined ||
-    revision === undefined ||
-    (capturedAt !== undefined && typeof capturedAt !== 'string')
-  ) {
-    return undefined
-  }
-  return {
-    formatVersion,
-    projectionVersion,
-    revision,
-    ...(capturedAt === undefined ? {} : { capturedAt }),
-  }
-}
-
-function decodeNullableSchemaIR(value: unknown): SchemaIR | null | undefined {
-  return value === null ? null : decodeSchemaIR(value)
-}
-
-function decodeNullableSchemaRoot(value: unknown): unknown | null | undefined {
-  return value === null ? null : isCanonicalDomainSchemaV1(value) ? value : undefined
-}
-
-function readBaselineJson<T>(
-  root: string,
-  subpath: string,
-  decode: (value: unknown) => T | undefined,
-): T | undefined {
-  const raw = readState(root, subpath)
-  if (raw === null) return undefined
-  const parsed = parseJson(raw)
-  return parsed === undefined ? undefined : decode(parsed)
-}
-
-/** Persist a baseline snapshot under `.cache/baseline/`. All writes go through the store. */
-export function captureBaseline(
-  root: string,
-  snapshot: BaselineSchemaSnapshot,
-  fileHashes: Record<string, string>,
-): void {
-  writeJson(root, `${BASE}/ir.json`, snapshot.ir)
-  writeJson(root, `${BASE}/schema-root.json`, snapshot.root)
-  writeJson(root, `${BASE}/files.json`, fileHashes)
-  writeJson(root, `${BASE}/meta.json`, {
-    formatVersion: BASELINE_FORMAT_VERSION,
-    projectionVersion: STUDIO_SCHEMA_PROJECTION_VERSION,
-    revision: snapshot.revision,
-    capturedAt: new Date().toISOString(),
-  } satisfies BaselineMeta)
-}
-
-/**
- * Load a current baseline. Older/unrecognised formats and render-projection
- * versions are explicitly invalidated so adapter changes cannot masquerade as
- * authored schema changes. The lifecycle will seed a replacement snapshot.
- */
-export function loadBaseline(root: string): Baseline | null {
-  const meta = readBaselineJson(root, `${BASE}/meta.json`, decodeBaselineMeta)
-  if (
-    !meta ||
-    meta.formatVersion !== BASELINE_FORMAT_VERSION ||
-    meta.projectionVersion !== STUDIO_SCHEMA_PROJECTION_VERSION ||
-    !isSchemaRevisionOrNull(meta.revision)
-  ) {
-    return null
-  }
-  const ir = readBaselineJson(root, `${BASE}/ir.json`, decodeNullableSchemaIR)
-  const schemaRoot = readBaselineJson(root, `${BASE}/schema-root.json`, decodeNullableSchemaRoot)
-  const files = readBaselineJson(root, `${BASE}/files.json`, asStringRecord)
-  if (ir === undefined || schemaRoot === undefined || files === undefined) return null
-  if (meta.revision !== null && (schemaRoot === null || ir === null)) return null
-  if (meta.revision === null && schemaRoot !== null) return null
-  return {
-    formatVersion: BASELINE_FORMAT_VERSION,
-    projectionVersion: STUDIO_SCHEMA_PROJECTION_VERSION,
-    ir,
-    root: schemaRoot,
-    revision: meta.revision ?? null,
-    files,
-    capturedAt: meta.capturedAt,
-  }
-}
-
-function isSchemaRevisionOrNull(value: unknown): value is SchemaRevision | null {
-  return value === null || isSchemaRevision(value)
-}
-
-/** Compare two file-hash maps into added/modified/removed FileChange[]. */
-function diffFiles(prev: Record<string, string>, next: Record<string, string>): FileChange[] {
-  const out: FileChange[] = []
-  for (const file of Object.keys(next)) {
-    if (!(file in prev)) out.push({ file, status: 'added' })
-    else if (prev[file] !== next[file]) out.push({ file, status: 'modified' })
-  }
-  for (const file of Object.keys(prev)) {
-    if (!(file in next)) out.push({ file, status: 'removed' })
-  }
-  out.sort((a, b) => a.file.localeCompare(b.file))
-  return out
-}
-
-/** A compact human-readable summary of schema changes (baseline source fallback for diff text). */
-function summarizeSchemaChanges(changes: SchemaChange[]): string {
-  if (changes.length === 0) return 'No schema changes.'
-  return changes
-    .map((c) => {
-      const detail = c.detail ? `: ${c.detail}` : ''
-      return `${c.kind} ${c.target}${detail}`
-    })
-    .join('\n')
-}
-
-/**
- * Compute the live ChangeSet against the captured baseline. On first launch
- * (no baseline yet) this returns an empty, 'none' ChangeSet with
- * hasBaseline:false so the UI shows "no changes" and the caller can then
- * capture an initial baseline.
- */
-export function computeChanges(
-  root: string,
-  currentIr: SchemaIR | null,
-  currentFiles: Record<string, string>,
-  opts: {
-    currentRevision?: SchemaRevision | null
-    git: { hasGit: boolean; diffText?: string }
-  },
-): ChangeSet {
-  const { hasGit } = opts.git
-  const source: ChangeSet['source'] = hasGit ? 'git' : 'baseline'
-  const baseline = loadBaseline(root)
-
-  if (!baseline) {
-    return {
-      source,
-      hasGit,
-      hasBaseline: false,
-      schemaChanges: [],
-      fileChanges: [],
-      structuralStatus: 'none',
-      ...(opts.currentRevision ? { currentRevision: opts.currentRevision } : {}),
-    }
-  }
-
-  const schemaChanges =
-    baseline.revision && opts.currentRevision === baseline.revision
-      ? []
-      : diffSchemas(baseline.ir ?? null, currentIr)
-  const structuralStatus = structuralStatusOf(schemaChanges)
-  const fileChanges = diffFiles(baseline.files ?? {}, currentFiles)
-
-  const schemaDiffText = hasGit ? opts.git.diffText : summarizeSchemaChanges(schemaChanges)
-
-  return {
-    source,
-    hasGit,
-    hasBaseline: true,
-    schemaChanges,
-    fileChanges,
-    schemaDiffText,
-    structuralStatus,
-    ...(baseline.revision ? { baselineRevision: baseline.revision } : {}),
-    ...(opts.currentRevision ? { currentRevision: opts.currentRevision } : {}),
-    baselineCapturedAt: baseline.capturedAt,
-  }
-}