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

package/studio/server/state/context.ts

@@ -1,199 +0,0 @@
-/**
- * context.ts — persists studio context items split into two buckets:
- *   - user items at  context/user/index.json   (ContextItem[])
- *   - auto items at  context/auto/index.json    (ContextItem[])
- * Auto items are also mirrored to readable .md files under context/auto/ so an
- * external agent can read them from disk. ALL writes go through store.ts.
- */
-import type { ContextItem, ContextStore } from '../../shared/types'
-
-import { asBoolean, asJsonRecord, asString } from '../json'
-import { readJson, writeJson, writeState } from './store'
-
-const USER_PATH = 'context/user/index.json'
-const AUTO_PATH = 'context/auto/index.json'
-
-function decodeContextItem(value: unknown): ContextItem | undefined {
-  const record = asJsonRecord(value)
-  const id = asString(record?.id)
-  const bucket = record?.bucket === 'user' || record?.bucket === 'auto' ? record.bucket : undefined
-  const title = asString(record?.title)
-  const body = asString(record?.body)
-  const updatedAt = asString(record?.updatedAt)
-  if (!id || !bucket || title === undefined || body === undefined || !updatedAt) return undefined
-  const source = asString(record?.source)
-  const includeInHandoff = asBoolean(record?.includeInHandoff)
-  const freshness = asString(record?.freshness)
-  return {
-    id,
-    bucket,
-    title,
-    body,
-    updatedAt,
-    ...(source === undefined ? {} : { source }),
-    ...(includeInHandoff === undefined ? {} : { includeInHandoff }),
-    ...(freshness === undefined ? {} : { freshness }),
-  }
-}
-
-function decodeContextItems(value: unknown): ContextItem[] | undefined {
-  if (!Array.isArray(value)) return undefined
-  return value.flatMap((item) => {
-    const decoded = decodeContextItem(item)
-    return decoded ? [decoded] : []
-  })
-}
-
-function readUser(root: string): ContextItem[] {
-  return readJson(root, USER_PATH, decodeContextItems, [])
-}
-
-function readAuto(root: string): ContextItem[] {
-  return readJson(root, AUTO_PATH, decodeContextItems, [])
-}
-
-function writeUser(root: string, items: ContextItem[]): void {
-  writeJson(root, USER_PATH, items)
-}
-
-function writeAuto(root: string, items: ContextItem[]): void {
-  writeJson(root, AUTO_PATH, items)
-}
-
-function now(): string {
-  return new Date().toISOString()
-}
-
-export function readContext(root: string): ContextStore {
-  return { user: readUser(root), auto: readAuto(root) }
-}
-
-export function addUserContext(
-  root: string,
-  input: { title: string; body: string; source?: string },
-): ContextItem {
-  const item: ContextItem = {
-    id: crypto.randomUUID(),
-    bucket: 'user',
-    title: input.title,
-    body: input.body,
-    source: input.source,
-    updatedAt: now(),
-  }
-  const items = readUser(root)
-  items.push(item)
-  writeUser(root, items)
-  return item
-}
-
-export function updateContext(
-  root: string,
-  id: string,
-  patch: { title?: string; body?: string },
-): ContextItem | null {
-  const user = readUser(root)
-  const ui = user.findIndex((it) => it.id === id)
-  if (ui !== -1) {
-    const updated: ContextItem = {
-      ...user[ui],
-      ...(patch.title !== undefined ? { title: patch.title } : {}),
-      ...(patch.body !== undefined ? { body: patch.body } : {}),
-      updatedAt: now(),
-    }
-    user[ui] = updated
-    writeUser(root, user)
-    return updated
-  }
-  const auto = readAuto(root)
-  const ai = auto.findIndex((it) => it.id === id)
-  if (ai !== -1) {
-    const updated: ContextItem = {
-      ...auto[ai],
-      ...(patch.title !== undefined ? { title: patch.title } : {}),
-      ...(patch.body !== undefined ? { body: patch.body } : {}),
-      updatedAt: now(),
-    }
-    auto[ai] = updated
-    writeAuto(root, auto)
-    return updated
-  }
-  return null
-}
-
-export function deleteContext(root: string, id: string): boolean {
-  const user = readUser(root)
-  const userKept = user.filter((it) => it.id !== id)
-  if (userKept.length !== user.length) {
-    writeUser(root, userKept)
-    return true
-  }
-  const auto = readAuto(root)
-  const autoKept = auto.filter((it) => it.id !== id)
-  if (autoKept.length !== auto.length) {
-    writeAuto(root, autoKept)
-    return true
-  }
-  return false
-}
-
-export function setAutoInclude(root: string, id: string, include: boolean): ContextItem | null {
-  const auto = readAuto(root)
-  const idx = auto.findIndex((it) => it.id === id)
-  if (idx === -1) return null
-  const updated: ContextItem = {
-    ...auto[idx],
-    includeInHandoff: include,
-    updatedAt: now(),
-  }
-  auto[idx] = updated
-  writeAuto(root, auto)
-  return updated
-}
-
-interface AutoSpec {
-  title: string
-  body: string | undefined
-  file: string
-}
-
-export function materializeAuto(
-  root: string,
-  digests: { changes?: string; schemaChange?: string; comments?: string },
-): void {
-  const specs: AutoSpec[] = [
-    { title: 'Current changes', body: digests.changes, file: 'changes.md' },
-    { title: 'Schema changes', body: digests.schemaChange, file: 'schema-change.md' },
-    { title: 'Open questions digest', body: digests.comments, file: 'comments-digest.md' },
-  ]
-
-  const auto = readAuto(root)
-  const ts = now()
-
-  for (const spec of specs) {
-    if (spec.body === undefined) continue
-    const existing = auto.find((it) => it.title === spec.title)
-    if (existing) {
-      existing.body = spec.body
-      existing.bucket = 'auto'
-      existing.source = 'auto-computed'
-      existing.freshness = ts
-      existing.updatedAt = ts
-      // preserve prior include choice
-      if (existing.includeInHandoff === undefined) existing.includeInHandoff = false
-    } else {
-      auto.push({
-        id: crypto.randomUUID(),
-        bucket: 'auto',
-        title: spec.title,
-        body: spec.body,
-        source: 'auto-computed',
-        updatedAt: ts,
-        freshness: ts,
-        includeInHandoff: false,
-      })
-    }
-    writeState(root, `context/auto/${spec.file}`, spec.body)
-  }
-
-  writeAuto(root, auto)
-}

package/studio/server/state/documents.ts

@@ -1,111 +0,0 @@
-/**
- * documents.ts — context DOCUMENTS the user drops in for the AI agent. Files are
- * stored under `.domain-studio/context/documents/` (allow-listed) and tracked in
- * an index. They travel with the domain and are part of the agent handoff context.
- */
-import { randomUUID } from 'node:crypto'
-import { existsSync } from 'node:fs'
-import { extname } from 'node:path'
-
-import type { DocMeta } from '../../shared/types'
-
-import { asFiniteNumber, asJsonRecord, asString } from '../json'
-import { readJson, removeState, statePath, writeJson, writeStateBuffer } from './store'
-
-const INDEX = 'context/documents/index.json'
-const storedPath = (id: string, name: string) => `context/documents/${id}${extname(name)}`
-
-function decodeDocument(value: unknown): DocMeta | undefined {
-  const record = asJsonRecord(value)
-  const id = asString(record?.id)
-  const name = asString(record?.name)
-  const type = asString(record?.type)
-  const size = asFiniteNumber(record?.size)
-  const addedAt = asString(record?.addedAt)
-  const stored = asString(record?.stored)
-  if (
-    !id ||
-    name === undefined ||
-    type === undefined ||
-    size === undefined ||
-    size < 0 ||
-    !addedAt ||
-    !stored?.startsWith('context/documents/') ||
-    stored.split('/').includes('..')
-  ) {
-    return undefined
-  }
-  const updatedAt = asString(record?.updatedAt)
-  return {
-    id,
-    name,
-    type,
-    size,
-    addedAt,
-    stored,
-    ...(updatedAt === undefined ? {} : { updatedAt }),
-  }
-}
-
-function decodeDocuments(value: unknown): DocMeta[] | undefined {
-  if (!Array.isArray(value)) return undefined
-  return value.flatMap((item) => {
-    const document = decodeDocument(item)
-    return document ? [document] : []
-  })
-}
-
-export function listDocuments(root: string): DocMeta[] {
-  return readJson(root, INDEX, decodeDocuments, [])
-}
-
-export function addDocument(root: string, name: string, type: string, data: Uint8Array): DocMeta {
-  const id = randomUUID()
-  const stored = storedPath(id, name)
-  writeStateBuffer(root, stored, data)
-  const meta: DocMeta = {
-    id,
-    name: name || 'untitled',
-    type: type || 'application/octet-stream',
-    size: data.byteLength,
-    addedAt: new Date().toISOString(),
-    stored,
-  }
-  const docs = listDocuments(root)
-  docs.unshift(meta)
-  writeJson(root, INDEX, docs)
-  return meta
-}
-
-/** Overwrite an existing document's content in place (keeps id/name). */
-export function updateDocument(root: string, id: string, data: Uint8Array): DocMeta | null {
-  const docs = listDocuments(root)
-  const doc = docs.find((d) => d.id === id)
-  if (!doc) return null
-  writeStateBuffer(root, doc.stored, data)
-  doc.size = data.byteLength
-  doc.updatedAt = new Date().toISOString()
-  writeJson(root, INDEX, docs)
-  return doc
-}
-
-export function deleteDocument(root: string, id: string): boolean {
-  const docs = listDocuments(root)
-  const doc = docs.find((d) => d.id === id)
-  if (!doc) return false
-  removeState(root, doc.stored)
-  writeJson(
-    root,
-    INDEX,
-    docs.filter((d) => d.id !== id),
-  )
-  return true
-}
-
-export function readDocument(root: string, id: string): { meta: DocMeta; abs: string } | null {
-  const doc = listDocuments(root).find((d) => d.id === id)
-  if (!doc) return null
-  const abs = statePath(root, doc.stored)
-  if (!existsSync(abs)) return null
-  return { meta: doc, abs }
-}

package/studio/server/state/integrations.ts

@@ -1,81 +0,0 @@
-/**
- * integrations.ts — persists user-declared integrations at integrations.json
- * ({ integrations: Integration[] }). `detectedSubfolders` is a caller-supplied
- * hint (a shallow readdir of integrations/) merged in on read, never persisted.
- * ALL writes go through store.ts.
- */
-import type { Integration, IntegrationsState } from '../../shared/types'
-
-import { asJsonRecord, asString } from '../json'
-import { readJson, writeJson } from './store'
-
-const PATH = 'integrations.json'
-
-interface IntegrationsFile {
-  integrations: Integration[]
-}
-
-function decodeIntegration(value: unknown): Integration | undefined {
-  const record = asJsonRecord(value)
-  const id = asString(record?.id)
-  const name = asString(record?.name)
-  const kind = asString(record?.kind)
-  const status = asString(record?.status)
-  if (id === undefined || name === undefined || kind === undefined || status === undefined)
-    return undefined
-  const notes = asString(record?.notes)
-  return { id, name, kind, status, ...(notes === undefined ? {} : { notes }) }
-}
-
-function decodeIntegrationsFile(value: unknown): IntegrationsFile | undefined {
-  const record = asJsonRecord(value)
-  if (!record) return undefined
-  return {
-    integrations: Array.isArray(record.integrations)
-      ? record.integrations.flatMap((item) => {
-          const integration = decodeIntegration(item)
-          return integration ? [integration] : []
-        })
-      : [],
-  }
-}
-
-function read(root: string): Integration[] {
-  return readJson(root, PATH, decodeIntegrationsFile, { integrations: [] }).integrations
-}
-
-function write(root: string, integrations: Integration[]): void {
-  writeJson(root, PATH, { integrations })
-}
-
-export function readIntegrations(root: string, detectedSubfolders: string[]): IntegrationsState {
-  return { integrations: read(root), detectedSubfolders }
-}
-
-export function upsertIntegration(
-  root: string,
-  input: { id?: string; name: string; kind: string; status: string; notes?: string },
-): Integration {
-  const integrations = read(root)
-  const id = input.id ?? crypto.randomUUID()
-  const next: Integration = {
-    id,
-    name: input.name,
-    kind: input.kind,
-    status: input.status,
-    notes: input.notes,
-  }
-  const idx = integrations.findIndex((it) => it.id === id)
-  if (idx === -1) integrations.push(next)
-  else integrations[idx] = next
-  write(root, integrations)
-  return next
-}
-
-export function deleteIntegration(root: string, id: string): boolean {
-  const integrations = read(root)
-  const kept = integrations.filter((it) => it.id !== id)
-  if (kept.length === integrations.length) return false
-  write(root, kept)
-  return true
-}

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

@@ -1,34 +0,0 @@
-import { afterEach, expect, test } from 'bun:test'
-import { mkdtempSync, rmSync } from 'node:fs'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-
-import { asJsonRecord } from '../json'
-import { readLayout, saveLayout } from './layout'
-import { readJson, writeJson } from './store'
-
-const roots: string[] = []
-
-afterEach(() => {
-  while (roots.length > 0) rmSync(roots.pop()!, { recursive: true, force: true })
-})
-
-test('reads the old layout hash key but writes only renderFingerprint', () => {
-  const root = mkdtempSync(join(tmpdir(), 'studio-layout-'))
-  roots.push(root)
-  writeJson(root, 'layout.json', {
-    schemaHash: 'sha-legacy',
-    positions: { 'class.Note': { x: 1, y: 2 } },
-  })
-
-  expect(readLayout(root)).toEqual({
-    renderFingerprint: 'sha-legacy',
-    positions: { 'class.Note': { x: 1, y: 2 } },
-  })
-
-  saveLayout(root, { 'class.Note': { x: 3, y: 4 } }, 'sha-current')
-  expect(readJson(root, 'layout.json', asJsonRecord, {})).toEqual({
-    renderFingerprint: 'sha-current',
-    positions: { 'class.Note': { x: 3, y: 4 } },
-  })
-})

package/studio/server/state/layout.ts

@@ -1,82 +0,0 @@
-/**
- * layout.ts — persisted manual graph layout per domain. Positions are keyed by
- * node id (e.g. `class.Monitor`), so they survive schema changes: removed nodes'
- * positions are harmless, new nodes fall back to auto-layout. Stamped with the
- * render fingerprint for reference. Persisted via the allow-listed store
- * (layout.json).
- */
-import type { LayoutState, NodePosition } from '../../shared/types'
-
-import { asFiniteNumber, asJsonRecord, asString } from '../json'
-import { readJson, removeState, writeJson } from './store'
-
-const FILE = 'layout.json'
-
-interface StoredLayout extends LayoutState {
-  schemaHash?: string
-}
-
-function decodePosition(value: unknown): NodePosition | undefined {
-  const record = asJsonRecord(value)
-  const x = asFiniteNumber(record?.x)
-  const y = asFiniteNumber(record?.y)
-  if (x === undefined || y === undefined) return undefined
-  const w = asFiniteNumber(record?.w)
-  const h = asFiniteNumber(record?.h)
-  return { x, y, ...(w === undefined ? {} : { w }), ...(h === undefined ? {} : { h }) }
-}
-
-function decodeStoredLayout(value: unknown): StoredLayout | undefined {
-  const record = asJsonRecord(value)
-  if (!record) return undefined
-  const positions: Record<string, NodePosition> = {}
-  for (const [id, candidate] of Object.entries(asJsonRecord(record.positions) ?? {})) {
-    const position = decodePosition(candidate)
-    if (position) positions[id] = position
-  }
-  const renderFingerprint = asString(record.renderFingerprint)
-  const schemaHash = asString(record.schemaHash)
-  return {
-    positions,
-    ...(renderFingerprint === undefined ? {} : { renderFingerprint }),
-    ...(schemaHash === undefined ? {} : { schemaHash }),
-  }
-}
-
-export function readLayout(root: string): LayoutState {
-  const stored = readJson(root, FILE, decodeStoredLayout, { positions: {} })
-  return {
-    ...((stored.renderFingerprint ?? stored.schemaHash)
-      ? { renderFingerprint: stored.renderFingerprint ?? stored.schemaHash }
-      : {}),
-    positions: stored.positions ?? {},
-  }
-}
-
-export function saveLayout(
-  root: string,
-  positions: Record<string, NodePosition>,
-  renderFingerprint?: string,
-): LayoutState {
-  const next: LayoutState = { renderFingerprint, positions }
-  writeJson(root, FILE, next)
-  return next
-}
-
-export function setNodePositions(
-  root: string,
-  updates: Record<string, NodePosition>,
-  renderFingerprint?: string,
-): LayoutState {
-  const cur = readLayout(root)
-  const next: LayoutState = {
-    renderFingerprint: renderFingerprint ?? cur.renderFingerprint,
-    positions: { ...cur.positions, ...updates },
-  }
-  writeJson(root, FILE, next)
-  return next
-}
-
-export function resetLayout(root: string): void {
-  removeState(root, FILE)
-}

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

@@ -1,78 +0,0 @@
-import { afterEach, expect, test } from 'bun:test'
-import { mkdtempSync, rmSync } from 'node:fs'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-
-import { readSettings, updateSettings } from './settings'
-import { writeJson } from './store'
-
-const roots: string[] = []
-
-afterEach(() => {
-  while (roots.length) rmSync(roots.pop()!, { recursive: true, force: true })
-})
-
-test('remembers sanitized model overrides independently per harness', () => {
-  const root = mkdtempSync(join(tmpdir(), 'studio-settings-models-'))
-  roots.push(root)
-
-  const saved = updateSettings(root, {
-    agentModels: {
-      ' Codex ': ' gpt-5.6-sol ',
-      claude: ' opus ',
-      empty: ' ',
-    },
-  })
-
-  expect(saved.agentModels).toEqual({
-    codex: 'gpt-5.6-sol',
-    claude: 'opus',
-  })
-  expect(readSettings(root).agentModels).toEqual(saved.agentModels)
-})
-
-test('rejects malformed model maps and entries without discarding unrelated settings', () => {
-  const root = mkdtempSync(join(tmpdir(), 'studio-settings-bad-models-'))
-  roots.push(root)
-  writeJson(root, 'settings.json', { agentModels: ['gpt-bad'], agentEffort: 'low' })
-
-  const settings = readSettings(root)
-  expect(settings.agentModels).toEqual({})
-  expect(settings.agentEffort).toBe('low')
-
-  writeJson(root, 'settings.json', {
-    agentModels: { codex: null, claude: { id: 'opus' }, valid: ' model-ok ' },
-  })
-  expect(readSettings(root).agentModels).toEqual({ valid: 'model-ok' })
-})
-
-test('drops destructive timing values from disk and API patches', () => {
-  const root = mkdtempSync(join(tmpdir(), 'studio-settings-timings-'))
-  roots.push(root)
-  writeJson(root, 'settings.json', {
-    introspectTimeoutMs: -1,
-    instancePollMs: 1_000.5,
-    updatesPollMs: 9_999,
-    viewProbeTimeoutMs: 120_001,
-  })
-
-  expect(readSettings(root)).toMatchObject({
-    introspectTimeoutMs: 20_000,
-    instancePollMs: 30_000,
-    updatesPollMs: 600_000,
-    viewProbeTimeoutMs: 8_000,
-  })
-
-  const saved = updateSettings(root, {
-    introspectTimeoutMs: Number.POSITIVE_INFINITY,
-    instancePollMs: 1_000,
-    updatesPollMs: 86_400_000,
-    viewProbeTimeoutMs: 250,
-  })
-  expect(saved).toMatchObject({
-    introspectTimeoutMs: 20_000,
-    instancePollMs: 1_000,
-    updatesPollMs: 86_400_000,
-    viewProbeTimeoutMs: 250,
-  })
-})

package/studio/server/state/settings.ts

@@ -1,73 +0,0 @@
-/**
- * settings.ts — per-domain power-user overrides for values the studio otherwise
- * hard-codes (first: the integrations/ folder name). Stored at
- * `.domain-studio/settings.json`; missing keys fall back to DEFAULT_SETTINGS.
- * Surfaced subtly in the UI (command palette + a faint gear) for power users.
- */
-import {
-  parseStudioNumericSetting,
-  STUDIO_NUMERIC_LIMITS,
-  type NumericStudioSetting,
-} from '../../shared/settings-values'
-import { AGENT_ACCESS_LEVELS, AGENT_EFFORT_LEVELS, type StudioSettings } from '../../shared/types'
-import { asJsonRecord, asString } from '../json'
-import { readJson, writeJson } from './store'
-
-const PATH = 'settings.json'
-
-export const DEFAULT_SETTINGS: StudioSettings = {
-  agentEffort: 'high',
-  agentAccess: 'full',
-  agentModels: {},
-  integrationsDir: 'integrations',
-  introspectTimeoutMs: 20000,
-  instancePollMs: 30000,
-  updatesPollMs: 600000,
-  viewProbeTimeoutMs: 8000,
-}
-
-function normalizeSettings(input: unknown): Partial<StudioSettings> {
-  const record = asJsonRecord(input)
-  if (!record) return {}
-  const out: Partial<StudioSettings> = {}
-  for (const key of Object.keys(STUDIO_NUMERIC_LIMITS) as NumericStudioSetting[]) {
-    const value = parseStudioNumericSetting(key, record[key])
-    if (value !== null) out[key] = value
-  }
-
-  const effort = AGENT_EFFORT_LEVELS.find((candidate) => candidate === record.agentEffort)
-  if (effort) out.agentEffort = effort
-  const access = AGENT_ACCESS_LEVELS.find((candidate) => candidate === record.agentAccess)
-  if (access) out.agentAccess = access
-
-  const integrationsDir = asString(record.integrationsDir)
-  if (integrationsDir !== undefined) out.integrationsDir = integrationsDir
-
-  const models = asJsonRecord(record.agentModels)
-  if (models) {
-    out.agentModels = Object.fromEntries(
-      Object.entries(models)
-        .filter((entry): entry is [string, string] => typeof entry[1] === 'string')
-        .map(([harness, model]) => [harness.trim().toLowerCase(), model.trim()])
-        .filter(([harness, model]) => !!harness && !!model),
-    )
-  }
-  return out
-}
-
-function decodeSettings(value: unknown): Partial<StudioSettings> | undefined {
-  return asJsonRecord(value) ? normalizeSettings(value) : undefined
-}
-
-export function readSettings(root: string): StudioSettings {
-  return {
-    ...DEFAULT_SETTINGS,
-    ...readJson(root, PATH, decodeSettings, {}),
-  }
-}
-
-export function updateSettings(root: string, patch: Partial<StudioSettings>): StudioSettings {
-  const next: StudioSettings = { ...readSettings(root), ...normalizeSettings(patch) }
-  writeJson(root, PATH, next)
-  return next
-}