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

package/src/commands/mutate.ts

@@ -1,122 +0,0 @@
-import type { MutationResult } from '@astrale-os/sdk/mutation'
-
-import chalk from 'chalk'
-import { readFile } from 'node:fs/promises'
-
-import type { KernelCommandOpts } from '../connection'
-import type { CommandDefinition } from '../program/index'
-
-import { runKernelCommand } from '../connection'
-import { AstraleError } from '../errors'
-import { prepareMutation } from '../graph/index'
-import { failInput } from '../lib/log'
-import { output } from '../lib/output'
-import { renderTable } from '../lib/table'
-
-type MutateOpts = KernelCommandOpts & {
-  data?: string
-  file?: string
-  dry?: boolean
-}
-
-export async function mutateCommand(opts: MutateOpts): Promise<void> {
-  let mutation
-  try {
-    mutation = prepareMutation(await readDocument(opts))
-  } catch (error) {
-    failInput(error, opts)
-  }
-
-  if (opts.dry) {
-    output(mutation, opts)
-    return
-  }
-
-  await runKernelCommand<MutationResult>({
-    opts,
-    label: 'Mutate',
-    fn: ({ graph }) => graph.mutate(mutation),
-    format: (result, format, machine) => {
-      if (machine || format.format !== undefined) output(result, format)
-      else printResult(result)
-    },
-  })
-}
-
-async function readDocument(opts: MutateOpts): Promise<unknown> {
-  const authored = [opts.data !== undefined, opts.file !== undefined].filter(Boolean).length
-  if (authored > 1) throw new TypeError('--data and --file are mutually exclusive')
-  if (opts.data !== undefined) return parseJson(opts.data, '--data')
-  if (opts.file !== undefined) {
-    let raw: string
-    try {
-      raw = await readFile(opts.file, 'utf8')
-    } catch (error) {
-      throw new AstraleError('FILE_READ_FAILED', `Cannot read --file ${opts.file}.`, undefined, {
-        cause: error,
-      })
-    }
-    return parseJson(raw, opts.file)
-  }
-  if (process.stdin.isTTY) {
-    throw new TypeError('No mutation provided; use --data, --file, or stdin')
-  }
-  const chunks: Buffer[] = []
-  for await (const chunk of process.stdin) chunks.push(Buffer.from(chunk))
-  const raw = Buffer.concat(chunks).toString('utf8').trim()
-  if (raw.length === 0) throw new TypeError('No mutation provided on stdin')
-  return parseJson(raw, 'stdin')
-}
-
-function parseJson(raw: string, source: string): unknown {
-  try {
-    return JSON.parse(raw)
-  } catch {
-    throw new TypeError(`${source} must contain valid JSON`)
-  }
-}
-
-function printResult(result: MutationResult): void {
-  const rows = Object.entries(result.createdNodes).map(([binding, id]) => ({ binding, id }))
-  if (rows.length === 0) {
-    console.log(chalk.dim('  applied — no Nodes created'))
-    return
-  }
-  console.log(`  ${chalk.bold('Created nodes:')}`)
-  console.log(
-    renderTable(rows, {
-      columns: [
-        { key: 'binding', header: 'BINDING', color: chalk.cyan },
-        { key: 'id', header: 'ID', color: chalk.dim },
-      ],
-      showHeader: true,
-    }),
-  )
-}
-
-export default {
-  name: 'mutate',
-  description: 'Apply one atomic Mutation V3 graph transition',
-  afterHelpText: `
-Behavior:
-  Accepts a canonical astrale.graph.mutation/v3 document or its exact
-  { preconditions, operations } authoring input. Source is --data, --file,
-  or stdin. --dry admits and prints the canonical document without opening a
-  Kernel connection. The result contains the real createdNodes binding map.
-
-  Legacy PatchData nodes/edges arms and createdEdges IDs are not part of
-  Mutation V3 and are rejected rather than approximated.
-
-Examples:
-  $ astrale mutate --file mutation.v3.json
-  $ astrale mutate --data '{"preconditions":[],"operations":[]}' --dry
-`,
-  options: [
-    { flags: '-d, --data <json>', description: 'Mutation V3 JSON document' },
-    { flags: '-f, --file <path>', description: 'Read a Mutation V3 document from a file' },
-    { flags: '--dry', description: 'Admit and print canonical Mutation V3 without dispatch' },
-  ],
-  action: async (opts) => {
-    await mutateCommand(opts as MutateOpts)
-  },
-} satisfies CommandDefinition

package/src/commands/query.ts

@@ -1,136 +0,0 @@
-import type { QueryDirection } from '@astrale-os/sdk/query'
-
-import { readFile } from 'node:fs/promises'
-
-import type { KernelCommandOpts, SelfExpansionMeta } from '../connection'
-import type { CommandDefinition } from '../program/index'
-
-import { expandSelfInPath, runKernelCommand, withSelfHint } from '../connection'
-import { AstraleError } from '../errors'
-import { prepareQuery, type QueryCommandInput } from '../graph/index'
-import { failInput } from '../lib/log'
-import { isMachine, output } from '../lib/output'
-
-type QueryOpts = KernelCommandOpts & {
-  ast?: string
-  file?: string
-  definition?: string
-  edge?: string
-  direction?: QueryDirection
-  limit?: string
-  cursor?: string
-}
-
-export async function queryCommand(sources: string[], opts: QueryOpts): Promise<void> {
-  let input: QueryCommandInput
-  try {
-    const ast = await readAst(opts)
-    input = {
-      sources,
-      ...(ast === undefined ? {} : { ast }),
-      definition: opts.definition,
-      edge: opts.edge,
-      direction: opts.direction,
-      limit: opts.limit,
-      cursor: opts.cursor,
-    }
-  } catch (error) {
-    failInput(error, opts)
-  }
-
-  let prepared
-  try {
-    prepared = prepareQuery(input)
-  } catch (error) {
-    failInput(error, opts)
-  }
-
-  await runKernelCommand({
-    opts,
-    label: 'Query',
-    fn: async (context) => {
-      const expanded = await Promise.all(sources.map((source) => expandSelfInPath(source, context)))
-      const meta: SelfExpansionMeta | undefined = expanded.find(
-        (entry) => entry.meta !== undefined,
-      )?.meta
-      const resolved =
-        meta === undefined
-          ? prepared
-          : prepareQuery({ ...input, sources: expanded.map(({ path }) => path) })
-      return withSelfHint(() => context.graph.query(resolved.ast, { page: resolved.page }), meta)
-    },
-    format: (response, format) => {
-      output(response.result, format)
-      if (response.page.next && !isMachine(format)) {
-        process.stderr.write(`  cursor: ${response.page.next}\n`)
-      }
-    },
-  })
-}
-
-async function readAst(opts: QueryOpts): Promise<unknown | undefined> {
-  if (opts.ast !== undefined && opts.file !== undefined) {
-    throw new TypeError('--ast and --file are mutually exclusive')
-  }
-  if (opts.ast !== undefined) return parseJson(opts.ast, '--ast')
-  if (opts.file === undefined) return undefined
-  let raw: string
-  try {
-    raw = await readFile(opts.file, 'utf8')
-  } catch (error) {
-    throw new AstraleError('FILE_READ_FAILED', `Cannot read --file ${opts.file}.`, undefined, {
-      cause: error,
-    })
-  }
-  return parseJson(raw, opts.file)
-}
-
-function parseJson(raw: string, source: string): unknown {
-  try {
-    return JSON.parse(raw)
-  } catch {
-    throw new TypeError(`${source} must contain valid JSON`)
-  }
-}
-
-export default {
-  name: 'query',
-  description: 'Run one canonical Query V6 graph read',
-  afterHelpText: `
-Behavior:
-  Positional Paths and --definition author a finite Query V6 read. --edge adds
-  one exact Edge-Class expansion; --direction defaults to outgoing. --ast and
-  --file accept a complete canonical astrale.graph.query/v6 document, including
-  Property ordering and Node or Edge reference/value projections. --cursor resumes
-  one caller-bound query scope.
-
-  Legacy depth/children selector JSON and raw Cypher are not portable Kernel
-  V2 query contracts and are not accepted.
-
-Examples:
-  $ astrale query /:notes.example.dev:class.Note --limit 50
-  $ astrale query --definition /:notes.example.dev:class.Note --limit 50
-  $ astrale query @note --edge /:notes.example.dev:class.references --direction outgoing --limit 25
-  $ astrale query --file query.v6.json --cursor "$CURSOR"
-`,
-  arguments: [{ name: 'sources...', description: 'Canonical source Paths', required: false }],
-  options: [
-    { flags: '--ast <json>', description: 'Canonical Query V6 JSON document' },
-    { flags: '-f, --file <path>', description: 'Read a canonical Query V6 document from a file' },
-    {
-      flags: '--definition <path>',
-      description: 'Select Nodes satisfying one exact Class',
-    },
-    { flags: '--edge <class>', description: 'Expand one exact Edge Class' },
-    {
-      flags: '--direction <direction>',
-      description: 'Edge direction (requires --edge)',
-      choices: ['outgoing', 'incoming', 'incident'],
-    },
-    { flags: '--limit <n>', description: 'Finite selected binding limit (default: 100)' },
-    { flags: '--cursor <token>', description: 'Resume one live query scope' },
-  ],
-  action: async (sources, opts) => {
-    await queryCommand((sources as string[] | undefined) ?? [], opts as QueryOpts)
-  },
-} satisfies CommandDefinition

package/src/commands/session/analyze.ts

@@ -1,50 +0,0 @@
-import chalk from 'chalk'
-
-import type { CommandDefinition } from '../../program/index'
-
-import { log } from '../../lib/log'
-import { analyzeSession } from '../../telemetry/analyze'
-import { listSessions } from '../../telemetry/store'
-import { restampLock, releaseLock } from '../../telemetry/trigger'
-
-export default {
-  name: 'analyze',
-  description: 'Analyze a recorded session for DX frictions (dry-run: writes report.md)',
-  arguments: [{ name: 'id', description: 'Session id (default: most recent closed, unanalyzed)' }],
-  options: [
-    { flags: '--file', description: 'File cleared findings as issues on the admin tracker' },
-    { flags: '--model <model>', description: 'Model for the analyzer pass' },
-    { flags: '--force', description: 'Re-analyze even if already analyzed' },
-    { flags: '--auto', description: 'Triggered mode: quiet, used by the opportunistic trigger' },
-  ],
-  action: async (
-    id: string | undefined,
-    opts: { file?: boolean; model?: string; force?: boolean; auto?: boolean },
-  ) => {
-    if (opts.auto) restampLock()
-    try {
-      let target = id
-      if (!target) {
-        const candidate = listSessions().find((s) => s.closed && (opts.force || !s.analyzed))
-        if (!candidate) {
-          if (!opts.auto) log.dim('Nothing to analyze — no closed, unanalyzed session.')
-          return
-        }
-        target = candidate.id
-      }
-      if (!opts.auto) log.step(`analyzing session ${target} …`)
-      const outcome = await analyzeSession(target, opts)
-      if (opts.auto) return
-      if (outcome.outcome === 'skipped-quiet') {
-        log.dim(`quiet session (${outcome.note}) — nothing to analyze`)
-      } else if (outcome.outcome === 'error') {
-        log.error(`analyzer failed: ${outcome.note ?? 'unknown'}`)
-      } else {
-        log.success(`${outcome.outcome} (${outcome.note ?? ''})`)
-        if (outcome.reportPath) console.log(chalk.dim(`  ${outcome.reportPath}`))
-      }
-    } finally {
-      if (opts.auto) releaseLock()
-    }
-  },
-} satisfies CommandDefinition

package/src/commands/session/list.ts

@@ -1,36 +0,0 @@
-import chalk from 'chalk'
-
-import type { CommandDefinition } from '../../program/index'
-
-import { log } from '../../lib/log'
-import { isMachine, output, RAW_OUTPUT_OPTIONS } from '../../lib/output'
-import { listSessions } from '../../telemetry/store'
-
-export default {
-  name: 'list',
-  description: 'List locally recorded work sessions and their analysis state',
-  options: [...RAW_OUTPUT_OPTIONS],
-  action: async (opts: { raw?: boolean; json?: boolean }) => {
-    const sessions = listSessions()
-    if (isMachine(opts)) {
-      output(sessions, opts)
-      return
-    }
-    if (sessions.length === 0) {
-      log.dim('No sessions recorded yet. Run any astrale command in a workspace to start one.')
-      return
-    }
-    for (const s of sessions) {
-      const state = s.analyzed
-        ? s.analyzed.outcome === 'error'
-          ? chalk.red(s.analyzed.outcome)
-          : chalk.green(s.analyzed.outcome)
-        : s.closed
-          ? chalk.yellow('closed, unanalyzed')
-          : chalk.cyan('open')
-      const when = s.lastEventAt ? s.lastEventAt.toISOString().slice(0, 16) : 'no events'
-      console.log(`${chalk.bold(s.id)}  ${state}`)
-      console.log(chalk.dim(`  ${s.meta?.root ?? '(unknown root)'} — last activity ${when}`))
-    }
-  },
-} satisfies CommandDefinition

package/src/commands/setup.ts

@@ -1,54 +0,0 @@
-import type { CommandDefinition } from '../program/index'
-
-import { ADMIN_TARGET_OPTIONS } from '../lib/admin-target'
-import { fatal } from '../lib/log'
-import { RAW_OUTPUT_OPTIONS } from '../lib/output'
-import { runSetup, type SetupOpts } from '../setup/engine'
-
-export default {
-  name: 'setup',
-  description: 'Guided first run: sign in, pick an instance, and equip your workspace',
-  arguments: [
-    {
-      name: 'slug',
-      description: 'Instance slug to provision when none is active',
-      required: false,
-    },
-  ],
-  options: [
-    { flags: '--plan', description: 'Print what setup would do (read-only) and exit' },
-    ...ADMIN_TARGET_OPTIONS,
-    ...RAW_OUTPUT_OPTIONS,
-  ],
-  afterHelpText: `
-What it does:
-  Walks you from zero to a working instance, then offers to equip your agent:
-    1. Connect    sign in (WorkOS), confirm the admin control plane, pick or
-                  provision an instance — ending on your live instance URL.
-    2. Equip      the astrale agent skills (cli + domain), agent-browser, and a
-                  first domain (a pre-checked multi-select — toggle off any).
-
-  Idempotent: re-run it anytime; satisfied steps are skipped. Bare \`astrale\`
-  in a terminal launches this when you have no active instance yet.
-
-Agents / CI:
-  Piped, --ci, or --plan → read-only. \`astrale setup --plan --json\` prints each
-  step's state and the exact command to fix it; run those granular commands
-  (auth login / instance create / …) rather than the interactive wizard.
-
-Examples:
-  $ astrale setup                 # the guided flow
-  $ astrale setup my-app          # pre-fill the instance slug
-  $ astrale setup --plan          # what's left to do (no changes)
-  $ astrale setup --plan --json   # machine-readable plan for an agent
-`,
-  action: async (slug: string | undefined, opts: SetupOpts) => {
-    try {
-      await runSetup(opts, slug)
-    } catch (e) {
-      // fatal() exits 130 quietly on Ctrl-C (ExitPromptError); each step's
-      // writes are atomic + idempotent, so nothing half-applied matters.
-      fatal(e)
-    }
-  },
-} satisfies CommandDefinition

package/src/commands/status.ts

@@ -1,60 +0,0 @@
-import chalk from 'chalk'
-
-import type { CommandDefinition } from '../program/index'
-
-import { readLocalStatus } from '../lib/local-status'
-import { log } from '../lib/log'
-import { isMachine, output, RAW_OUTPUT_OPTIONS } from '../lib/output'
-
-export default {
-  name: 'status',
-  description: 'Show local CLI context: active instance, identity, and cached auth state',
-  options: [...RAW_OUTPUT_OPTIONS],
-  action: async (opts: { raw?: boolean; json?: boolean }) => {
-    const status = await readLocalStatus()
-
-    if (isMachine(opts)) {
-      output(status, opts)
-      return
-    }
-
-    console.log(chalk.bold('Admin'))
-    if ('error' in status.admin) {
-      console.log(`  ${chalk.red('invalid')}: ${status.admin.error}`)
-    } else {
-      console.log(`  ${chalk.bold(status.admin.name)} ${chalk.dim(status.admin.url)}`)
-    }
-
-    console.log('')
-    console.log(chalk.bold('Instance'))
-    if (status.instance) {
-      console.log(`  ${chalk.bold(status.instance.active)} ${chalk.dim(status.instance.url)}`)
-      if (status.instance.issuer) console.log(`  issuer: ${chalk.dim(status.instance.issuer)}`)
-      if (status.instance.defaultIdentity) {
-        console.log(`  default identity: ${status.instance.defaultIdentity}`)
-      }
-    } else {
-      log.dim('  No active instance. Run: astrale instance bookmark <name> --url <url> --use')
-    }
-
-    console.log('')
-    console.log(chalk.bold('Identity'))
-    if (status.identity) {
-      const source =
-        status.identity.source === 'idp'
-          ? `idp:${status.identity.idp ?? 'unknown'}`
-          : status.identity.source
-      console.log(`  ${chalk.bold(status.identity.name)} ${chalk.dim(`[${source}]`)}`)
-      console.log(`  subject: ${chalk.dim(status.identity.subject)}`)
-      if (status.identity.session) {
-        const state =
-          !status.identity.session.cached || status.identity.session.requiresLogin
-            ? chalk.yellow('login required')
-            : chalk.green('ready')
-        console.log(`  session: ${state}`)
-      }
-    } else {
-      log.dim('  No default identity. Run: astrale identity create <name>')
-    }
-  },
-} satisfies CommandDefinition