@astrale-os/cli 0.4.0-alpha.13 → 0.6.0-alpha.0

package/src/commands/call.ts

@@ -3,7 +3,14 @@ import { K } from '@astrale-os/kernel-core'
 import type { CommandDefinition } from '../command'
 import type { CallCommandOpts, ClientContext, SelfExpansionMeta } from '../kernel'
 
-import { buildSelfContext, resolveSelfIdLazy, runKernelCommand, withSelfHint } from '../kernel'
+import {
+  bindGraph,
+  buildSelfContext,
+  nodeProp,
+  resolveSelfIdLazy,
+  runKernelCommand,
+  withSelfHint,
+} from '../kernel'
 import { presentBinary, type BinaryLike } from '../lib/binary'
 import { log } from '../lib/log'
 import { output, present } from '../lib/output'
@@ -19,12 +26,8 @@ export async function callCommand(
   rawParams: string[],
   opts: CallOpts,
 ): Promise<void> {
-  // ── Expand `@self` in path + raw param strings ──────────
-  // Local resolution, with ONE lazy whoami round-trip for IdP identities
-  // missing a cached registration (persisted, so it's local afterwards).
-  // Throws a typed SelfRefusalError (manager, instance-signed, …) which we
-  // surface as a fatal CLI error. Runs BEFORE `--describe` so users get the
-  // typed refusal instead of a generic NotFoundError from the kernel.
+  // Expand @self before describe/execute so refusals are typed and stale IdP
+  // registrations can refresh through whoami.
   let expandedPath = path
   let expandedRaw = rawParams
   let selfMeta: SelfExpansionMeta | undefined
@@ -35,9 +38,7 @@ export async function callCommand(
       const selfId = await resolveSelfIdLazy(selfCtx, opts)
       expandedPath = expandSelfReferences(path, selfId)
       expandedRaw = rawParams.map((p) => expandSelfReferences(p, selfId))
-      // Stamp metadata whenever ANY input mutated — the stale-registration
-      // hint in `formatKernelError` is just as useful when `@self` lived in
-      // a param (`node=@self`) as when it was in the path head.
+      // Stale-registration hints apply when @self appears in either path or params.
       const rawMutated = expandedRaw.some((p, i) => p !== rawParams[i])
       if (expandedPath !== path || rawMutated) {
         selfMeta = {
@@ -80,14 +81,7 @@ export async function callCommand(
     opts,
     label: expandedPath,
     fn: async (ctx): Promise<CallResult> => {
-      // Remote-bound functions live on an external worker. The kernel resolves
-      // the call to a redirect carrying the worker's URL + `iss`; the session
-      // follows it, minting a worker-scoped delegation for that `iss` (the
-      // delegation cache wired in `client.ts`). No client-side binding lookup.
-      //
-      // The one thing the reactive path can't discover after dispatch is a
-      // binary output mode (a JSON decode would corrupt the bytes), so detect
-      // it up front and route to the binary transport — which also auto-follows.
+      // Binary outputs must be routed before dispatch; JSON decoding would corrupt bytes.
       if (await isBinaryOutput(ctx, expandedPath)) {
         const response = await withSelfHint(() => ctx.client.binary(expandedPath, params), selfMeta)
         return { kind: 'binary', response }
@@ -106,26 +100,15 @@ export async function callCommand(
 }
 
 /**
- * Best-effort pre-flight: does the target Function declare a binary output?
- * A binary method must use the binary transport (the value path would JSON-
- * decode and corrupt the bytes), and the client can't discover that after
- * dispatch. For a static path the path IS the Function node — read `output`
- * off it via `::get`. For an instance-method path (`<node>::method`) the
- * Function node isn't addressable that way: resolve the instance's class
- * first, then probe the class's method node (`<classPath>:method`). An
- * interface-hosted instance method still escapes the probe (its Function node
- * hangs off the interface, not the class) — that and any other failure returns
- * false and falls through to the value path, letting the kernel surface the
- * real error. `::get` is a kernel syscall (same origin) so it neither
- * redirects nor triggers delegation.
+ * Best-effort binary preflight. Static paths read the Function node directly;
+ * instance paths probe the class method node and fall back to value transport on miss.
  */
 async function isBinaryOutput(ctx: ClientContext, path: string): Promise<boolean> {
   try {
     const target = path.includes('::') ? await instanceMethodNodePath(ctx, path) : path
     if (!target) return false
-    const node = (await ctx.client.call(`${target}::get`, {})) as {
-      props?: Record<string, unknown>
-    } | null
+    const node = await bindGraph(ctx).get(target)
+    // Props travel under fully-qualified keys; `output.key` IS that key.
     return node?.props?.[K.$.i('Function').output.key] === 'binary'
   } catch {
     return false
@@ -141,22 +124,23 @@ async function instanceMethodNodePath(
   const source = path.slice(0, sep)
   const method = path.slice(sep + 2)
   if (!source || !method) return undefined
-  const node = (await ctx.client.call(`${source}::get`, {})) as { class?: string } | null
-  // node.class is a ClassPath (`/:domain:class.Name`); appending `:<method>`
-  // forms the MethodPath of the class-owned Function node.
-  return node?.class ? `${node.class}:${method}` : undefined
+  const node = await bindGraph(ctx).get(source)
+  // ClassPath + method name forms the class-owned Function MethodPath.
+  return node?.class ? `${node.class.raw}:${method}` : undefined
 }
 
 async function describeOperation(path: string, opts: CallOpts): Promise<void> {
-  await runKernelCommand<Record<string, unknown>>({
+  await runKernelCommand({
     opts,
     label: `Schema for ${path}`,
-    fn: (ctx) => ctx.client.call(`${path}::get`, {}) as Promise<Record<string, unknown>>,
+    // The Function node carries the schemas as props (function.get depth:0).
+    fn: async (ctx) => await bindGraph(ctx).get(path),
     format: (node, fmtOpts) => {
-      const props = (node.properties ?? node) as Record<string, unknown>
+      const input = nodeProp(node, 'inputSchema')
+      const outputSchema = nodeProp(node, 'outputSchema')
       const schema: Record<string, unknown> = {}
-      if (props.inputSchema) schema.input = tryParseJson(props.inputSchema)
-      if (props.outputSchema) schema.output = tryParseJson(props.outputSchema)
+      if (input) schema.input = tryParseJson(input)
+      if (outputSchema) schema.output = tryParseJson(outputSchema)
       output(Object.keys(schema).length > 0 ? schema : node, fmtOpts)
     },
   })
@@ -277,8 +261,7 @@ Examples:
   $ astrale call /:host.astrale.ai:class.KernelInstance:list
   $ astrale call /:blog.acme.com:class.Author:list limit=10
   $ astrale call '@self::deactivate'
-  $ astrale call /:dist.astrale.ai:class.Domain:install --creds "$TOKEN" \\
-      -d "$(cat spec.json)"
+  $ astrale call /:shell.astrale.ai:class.Application:available --json
 `,
   arguments: [
     {

package/src/commands/describe.ts

@@ -2,20 +2,21 @@ import { ClassPath } from '@astrale-os/kernel-core/domain'
 import chalk from 'chalk'
 
 import type { CommandDefinition } from '../command'
-import type { KernelCommandOpts } from '../kernel'
-
-import { expandSelfInPath, extractItems, runKernelCommand, withSelfHint } from '../kernel'
+import type { GraphNode, KernelCommandOpts } from '../kernel'
+
+import {
+  bindGraph,
+  expandSelfInPath,
+  nodeProp,
+  runKernelCommand,
+  splitRoot,
+  unqualifyKey,
+  withSelfHint,
+} from '../kernel'
 import { log } from '../lib/log'
 import { output } from '../lib/output'
 
-type NodeItem = {
-  id?: string
-  slug?: string
-  class?: string
-  properties?: Record<string, unknown>
-}
-
-type DescribeResult = { node: NodeItem; children: NodeItem[] }
+type DescribeResult = { node: GraphNode | undefined; children: GraphNode[] }
 
 // Commander turns `--no-schema` into `schema: false`.
 type DescribeOpts = KernelCommandOpts & { schema?: boolean }
@@ -32,27 +33,18 @@ export async function describeCommand(path: string, opts: DescribeOpts): Promise
   await runKernelCommand<DescribeResult>({
     opts,
     label: expandedPath,
+    // One function.get depth:1 = the node AND its children (was ::get +
+    // ::listChildren). Function-class children are the node's operations.
     fn: async (ctx) => {
-      const node = (await withSelfHint(
-        () => ctx.client.call(`${expandedPath}::get`, {}),
+      const result = await withSelfHint(
+        () => bindGraph(ctx).query((q) => q.from(expandedPath).children()),
         meta,
-      )) as NodeItem
-
-      let children: NodeItem[] = []
-      try {
-        const result = await withSelfHint(
-          () => ctx.client.call(`${expandedPath}::listChildren`, {}),
-          meta,
-        )
-        children = extractItems<NodeItem>(result)
-      } catch {
-        // Node may have no children (leaf node)
-      }
-
-      return { node, children }
+      )
+      const { root, children } = splitRoot(result.wire.nodes, expandedPath)
+      return { node: root, children }
     },
     format: (result, fmtOpts, isRaw) => {
-      const shown = opts.schema === false ? stripSchemaProp(result) : result
+      const shown = opts.schema === false ? stripSchema(result) : result
       if (isRaw) {
         output(shown, fmtOpts)
         return
@@ -62,23 +54,21 @@ export async function describeCommand(path: string, opts: DescribeOpts): Promise
   })
 }
 
-function stripSchemaProp(result: DescribeResult): DescribeResult {
-  const props = result.node.properties
-  if (!props || !('schema' in props)) return result
-  const { schema: _omitted, ...rest } = props
-  return { ...result, node: { ...result.node, properties: rest } }
+function stripSchema(result: DescribeResult): DescribeResult {
+  if (!result.node) return result
+  const entries = Object.entries(result.node.props).filter(([k]) => unqualifyKey(k) !== 'schema')
+  return { ...result, node: { ...result.node, props: Object.fromEntries(entries) } }
 }
 
 // ── Pretty-print ────────────────────────────────────────────
 
 function printDescribe({ node, children }: DescribeResult, path: string): void {
   const kind = classNameOf(node) ?? 'Node'
-  const slug = node.properties?.slug ?? node.slug ?? path.split('/').pop()
-  console.log(`  ${chalk.bold.cyan(String(slug))} ${chalk.dim(`(${kind})`)}`)
+  const name = basename(path) || path
+  console.log(`  ${chalk.bold.cyan(name)} ${chalk.dim(`(${kind})`)}`)
 
-  if (node.properties?.description) {
-    console.log(`  ${chalk.dim(String(node.properties.description))}`)
-  }
+  const description = nodeProp(node, 'description')
+  if (description) console.log(`  ${chalk.dim(String(description))}`)
   console.log('')
 
   const operations = children.filter(isFunction)
@@ -86,12 +76,13 @@ function printDescribe({ node, children }: DescribeResult, path: string): void {
 
   if (operations.length > 0) {
     console.log(`  ${chalk.bold('Operations:')}`)
-    const slugW = Math.max(4, ...operations.map((o) => (o.slug ?? '').length))
-    for (const op of operations) {
-      const opSlug = (op.slug ?? '?').padEnd(slugW)
-      const schema = formatInputSchema(op.properties)
-      console.log(`    ${chalk.green(opSlug)}  ${chalk.dim(schema)}`)
-    }
+    const names = operations.map((o) => basename(o.path))
+    const slugW = Math.max(4, ...names.map((n) => n.length))
+    operations.forEach((op, i) => {
+      const opName = names[i].padEnd(slugW)
+      const schema = formatInputSchema(op)
+      console.log(`    ${chalk.green(opName)}  ${chalk.dim(schema)}`)
+    })
     console.log('')
   }
 
@@ -99,7 +90,7 @@ function printDescribe({ node, children }: DescribeResult, path: string): void {
     console.log(`  ${chalk.bold('Children:')}`)
     for (const child of otherChildren) {
       const childKind = classNameOf(child) ?? '?'
-      console.log(`    ${chalk.cyan(child.slug ?? '?')}  ${chalk.dim(childKind)}`)
+      console.log(`    ${chalk.cyan(basename(child.path) || '?')}  ${chalk.dim(childKind)}`)
     }
     console.log('')
   }
@@ -109,18 +100,26 @@ function printDescribe({ node, children }: DescribeResult, path: string): void {
   }
 }
 
+/** `/a/b/c` → `c`; `/` → `/`. */
+function basename(path?: string): string {
+  if (!path || path === '/') return path ?? ''
+  return path.slice(path.lastIndexOf('/') + 1)
+}
+
 /** Short class name from the contract field `class` (a serialized ClassPath). */
-function classNameOf(item: NodeItem): string | undefined {
-  return item.class ? (ClassPath.tryParse(item.class)?.className ?? undefined) : undefined
+function classNameOf(item: GraphNode | undefined): string | undefined {
+  return item?.class ? (ClassPath.tryParse(item.class)?.className ?? undefined) : undefined
 }
 
-function isFunction(item: NodeItem): boolean {
+function isFunction(item: GraphNode): boolean {
   return classNameOf(item) === 'Function'
 }
 
-function printProperties(node: NodeItem): void {
-  const props = node.properties ?? (node as Record<string, unknown>)
-  const entries = Object.entries(props).filter(([k]) => k !== '__labels' && k !== 'id')
+function printProperties(node: GraphNode | undefined): void {
+  if (!node) return
+  const entries = Object.entries(node.props)
+    .map(([k, v]) => [unqualifyKey(k), v] as const)
+    .filter(([k]) => k !== '__labels' && k !== 'id')
   if (entries.length === 0) return
 
   console.log(`  ${chalk.bold('Properties:')}`)
@@ -130,9 +129,8 @@ function printProperties(node: NodeItem): void {
   }
 }
 
-function formatInputSchema(properties?: Record<string, unknown>): string {
-  if (!properties) return '{}'
-  const raw = properties.inputSchema
+function formatInputSchema(node: GraphNode): string {
+  const raw = nodeProp(node, 'inputSchema')
   if (!raw) return '{}'
 
   try {
@@ -160,9 +158,10 @@ export default {
   description: 'Describe a node: its kind, operations, children, and schemas',
   afterHelpText: `
 Behavior:
-  Raw node dump: full properties + children. For Domain nodes this
-  includes a multi-kB serialized 'schema' — use --no-schema, and pipe
-  to jq rather than reading by eye (it is not a curated summary).
+  One function.get depth:1 — the node plus its children (Function-class
+  children are shown as Operations). Raw dump: full properties + children.
+  For Domain nodes the properties include a multi-kB serialized 'schema' —
+  use --no-schema, and pipe to jq rather than reading by eye.
 
 Examples:
   $ astrale describe /kernel.astrale.ai
@@ -177,6 +176,6 @@ Examples:
     },
   ],
   action: async (path, opts) => {
-    await describeCommand(path as string, opts as Parameters<typeof describeCommand>[1])
+    await describeCommand(path as string, opts as DescribeOpts)
   },
 } satisfies CommandDefinition

package/src/commands/domain/install.ts

@@ -7,8 +7,8 @@ import type { KernelCommandOpts } from '../../kernel'
 import { AstraleError } from '../../errors'
 import { runKernelCommand } from '../../kernel'
 import { withAdminKernelClient } from '../../kernel/client'
-import { ADMIN_DOMAIN, type DomainInfo } from '../../lib/admin-domain'
-import { ADMIN_INSTANCE, type InstanceInfo } from '../../lib/admin-instance'
+import { adminDomainMethod, type DomainInfo } from '../../lib/admin-domain'
+import { adminInstanceMethod, type InstanceInfo } from '../../lib/admin-instance'
 import { ADMIN_TARGET_OPTIONS, type AdminTargetCommandOpts } from '../../lib/admin-target'
 import { getActive } from '../../lib/instance'
 import { fatal, log, withSpinner } from '../../lib/log'
@@ -26,7 +26,7 @@ type DomainInstallResult = {
   error?: string | null
 }
 
-/** Mirrors the kernel's `Root.installDomain` return. */
+/** Mirrors the kernel's `Domain.install` return. */
 type DirectInstallResult = { domainId: string; origin: string }
 
 type InstallOpts = KernelCommandOpts &
@@ -50,7 +50,7 @@ Behavior:
   interactively. The target instance is the active one, or -i <slug>; it must be
   admin-managed (otherwise the command fails loudly and points you at --direct).
 
-  --direct: installs a url STRAIGHT onto the instance kernel (Root.installDomain),
+  --direct: installs a url STRAIGHT onto the instance kernel (Domain.install),
   bypassing the admin/catalog. Works on any instance you can authenticate to
   (managed, bookmarked, or local), using your own authority. This is the only
   mode that runs the identity-override consent gate: when the domain's declared
@@ -125,7 +125,7 @@ async function installViaAdmin(target: string | undefined, opts: InstallOpts): P
 
   try {
     await withAdminKernelClient(adminOpts, async (ctx) => {
-      const instances = (await ctx.client.call(`${ADMIN_INSTANCE}/list`, {})) as InstanceInfo[]
+      const instances = (await ctx.client.call(adminInstanceMethod('list'), {})) as InstanceInfo[]
 
       const ref = await resolveDomainRef(ctx, target, interactive)
       const slug = await resolveTargetSlug(opts, target, interactive, instances)
@@ -145,7 +145,7 @@ async function installViaAdmin(target: string | undefined, opts: InstallOpts): P
         `Installing ${label} on ${match.slug}`,
         !isMachine(opts),
         () =>
-          ctx.client.call(`${ADMIN_DOMAIN}/install`, {
+          ctx.client.call(adminDomainMethod('install'), {
             instanceId: match.slug,
             ...ref,
           }) as Promise<DomainInstallResult>,
@@ -190,7 +190,7 @@ async function resolveDomainRef(
   if (target) return domainRefFromTarget(target)
   if (!interactive) throw new AstraleError('MISSING_ARG', 'No domain given.')
 
-  const catalog = (await ctx.client.call(`${ADMIN_DOMAIN}/list`, {})) as DomainInfo[]
+  const catalog = (await ctx.client.call(adminDomainMethod('list'), {})) as DomainInfo[]
   const installable = catalog.filter((d) => d.url)
   if (installable.length === 0) {
     throw new AstraleError(
@@ -260,7 +260,7 @@ async function activeSlug(): Promise<string | undefined> {
 // ── Direct path (--direct) ────────────────────────────────────────────────────
 
 /**
- * Install a url straight onto the instance kernel (`Root.installDomain`),
+ * Install a url straight onto the instance kernel (`Domain.install`),
  * bypassing the admin/catalog — the classic path, with the §5 identity-override
  * consent gate. Works on any instance the caller can authenticate to.
  */
@@ -290,7 +290,7 @@ async function installDirect(target: string | undefined, opts: InstallOpts): Pro
     opts,
     label: `Installing domain from ${url}`,
     fn: async (ctx) =>
-      (await ctx.client.call(K.Root.installDomain.path.method.raw, {
+      (await ctx.client.call(K.Domain.install.path.method.raw, {
         url,
         ...(opts.token ? { token: opts.token } : {}),
       })) as DirectInstallResult,

package/src/commands/domain/list.ts

@@ -5,7 +5,7 @@ import type { KernelCommandOpts } from '../../kernel'
 import type { ListProjection, RawOutputOpts } from '../../lib/output'
 
 import { withAdminKernelClient } from '../../kernel/client'
-import { ADMIN_DOMAIN, type DomainInfo } from '../../lib/admin-domain'
+import { adminDomainMethod, type DomainInfo } from '../../lib/admin-domain'
 import { ADMIN_TARGET_OPTIONS, type AdminTargetCommandOpts } from '../../lib/admin-target'
 import { fatal, withSpinner } from '../../lib/log'
 import { isMachine, presentList } from '../../lib/output'
@@ -102,7 +102,7 @@ Examples:
         async (): Promise<DomainRow[]> => {
           const list = await withAdminKernelClient(
             opts,
-            async (ctx) => (await ctx.client.call(`${ADMIN_DOMAIN}/list`, {})) as DomainInfo[],
+            async (ctx) => (await ctx.client.call(adminDomainMethod('list'), {})) as DomainInfo[],
           )
           const filtered = opts.defaultOnly ? list.filter((d) => d.installByDefault) : list
           filtered.sort(byDefaultThenName)

package/src/commands/domain/publish.ts

@@ -4,7 +4,7 @@ import type { CommandDefinition } from '../../command'
 import type { KernelCommandOpts } from '../../kernel'
 
 import { withAdminKernelClient } from '../../kernel/client'
-import { ADMIN_DOMAIN, type DomainInfo } from '../../lib/admin-domain'
+import { adminDomainMethod, type DomainInfo } from '../../lib/admin-domain'
 import { ADMIN_TARGET_OPTIONS, type AdminTargetCommandOpts } from '../../lib/admin-target'
 import { fatal, withSpinner } from '../../lib/log'
 import { isMachine, output } from '../../lib/output'
@@ -115,7 +115,7 @@ Examples:
             // silently bumping `updatedAt`. `info` throws when absent → treat as
             // a fresh publish.
             const existing = (await ctx.client
-              .call(`${ADMIN_DOMAIN}/info`, { origin })
+              .call(adminDomainMethod('info'), { origin })
               .catch(() => null)) as DomainInfo | null
             if (
               existing &&
@@ -127,7 +127,7 @@ Examples:
             ) {
               return { entry: existing, changed: false as const, isNew: false }
             }
-            const entry = (await ctx.client.call(`${ADMIN_DOMAIN}/publish`, {
+            const entry = (await ctx.client.call(adminDomainMethod('publish'), {
               origin,
               name,
               url: publicUrl,

package/src/commands/get.ts

@@ -1,29 +1,46 @@
 import type { CommandDefinition } from '../command'
 import type { KernelCommandOpts } from '../kernel'
 
-import { expandSelfInPath, runKernelCommand, withSelfHint } from '../kernel'
+import { bindGraph, expandSelfInPath, runKernelCommand, withSelfHint } from '../kernel'
 import { log } from '../lib/log'
 import { output } from '../lib/output'
 
-type GetOpts = KernelCommandOpts & { long?: boolean }
+type GetOpts = KernelCommandOpts & {
+  long?: boolean
+}
 
 const INTERNAL_KEYS = new Set(['__labels', 'classId'])
 
-export async function getCommand(path: string, opts: GetOpts): Promise<void> {
-  let expandedPath: string
+export async function getCommand(pathArg: string, opts: GetOpts): Promise<void> {
+  if (!pathArg) {
+    log.error('Usage: astrale get <path>')
+    process.exit(1)
+    return
+  }
+
+  let path: string
   let meta
   try {
-    ;({ path: expandedPath, meta } = await expandSelfInPath(path, opts))
+    ;({ path, meta } = await expandSelfInPath(pathArg, opts))
   } catch (e) {
     log.error(e instanceof Error ? e.message : 'Invalid @self expansion')
     process.exit(1)
+    return
   }
+
   await runKernelCommand({
     opts,
-    label: `Node ${expandedPath}`,
-    fn: (ctx) => withSelfHint(() => ctx.client.call(`${expandedPath}::get`, {}), meta),
-    format: (result, fmtOpts) => {
-      output(opts.long ? result : cleanNode(result), fmtOpts)
+    label: 'Node ' + path,
+    fn: async (ctx) => {
+      const node = await withSelfHint(() => bindGraph(ctx).get(path), meta)
+      if (node === null) {
+        log.error('node "' + path + '" not found or not visible')
+        process.exit(1)
+      }
+      return node
+    },
+    format: (node, fmtOpts) => {
+      output(opts.long ? node : cleanNode(node), fmtOpts)
     },
   })
 }
@@ -40,21 +57,29 @@ function cleanNode(data: unknown): unknown {
 
 export default {
   name: 'get',
-  description: 'Get a node by path or ID',
-  afterHelpText: `
-Behavior:
-  Accepts a tree path (/domain/class.Name) or an id (@nodeId). -l adds
-  the internal fields (__labels, classId) hidden in the summary view.
-
-Examples:
-  $ astrale get /kernel.astrale.ai/class.Root
-  $ astrale get @abc123 -l
-`,
+  description: 'Get one node by path or id',
+  afterHelpText: [
+    '',
+    'Behavior:',
+    '  Point read through the kernel-client GraphApi.get shorthand. Accepts exactly',
+    '  one node path (tree path /domain/class.Name, or an id @nodeId). @self is',
+    '  expanded before dispatch. Missing and masked nodes share one opaque error:',
+    '  node "<path>" not found or not visible.',
+    '',
+    '  Output is the historical flat wire node projection { id, class, path, props }.',
+    '  Add -l to keep the internal fields (__labels, classId). Richer reads -',
+    '  multiple roots, child expansion, edge expansion, cursors, or full GraphData -',
+    '  live on astrale query.',
+    '',
+    'Examples:',
+    '  $ astrale get /kernel.astrale.ai/class.Root',
+    '  $ astrale get @abc123 -l',
+    '  $ astrale get @self --json',
+    '',
+  ].join('\n'),
   arguments: [{ name: 'path', description: 'Node path (/domain/Class) or ID (@nodeId)' }],
-  options: [
-    { flags: '-l, --long', description: 'Include all internal fields (__labels, classId)' },
-  ],
+  options: [{ flags: '-l, --long', description: 'Include internal fields (__labels, classId)' }],
   action: async (path, opts) => {
-    await getCommand(path as string, opts as Parameters<typeof getCommand>[1])
+    await getCommand(path as string, opts as GetOpts)
   },
 } satisfies CommandDefinition