bazilion 0.0.0

package/apps/cli/src/commands/inbox.ts

@@ -0,0 +1,82 @@
+import type { ListInboxResponse, Message } from '@bazilion/api-types'
+import { defineCommand } from 'citty'
+import { createClient } from '../client.ts'
+import { columnize } from '../columnize.ts'
+
+function decodeText(payload: string): string {
+  try {
+    const obj = JSON.parse(payload) as { text?: unknown }
+    if (typeof obj.text === 'string') return obj.text
+  } catch {}
+  return payload
+}
+
+function messageRow(m: Message): string[] {
+  const when = new Date(m.createdAt).toISOString()
+  const state = m.readAt ? 'read' : 'NEW'
+  const text = decodeText(m.payload)
+  const preview = text.length > 60 ? `${text.slice(0, 60)}…` : text
+  return [m.id, state, when, `from:${m.fromAgentId.slice(0, 8)}`, `"${preview}"`]
+}
+
+const listCmd = defineCommand({
+  meta: { name: 'list', description: 'List messages in an agent inbox' },
+  args: {
+    agent: { type: 'positional', required: true, description: 'Recipient agent id' },
+    unread: { type: 'boolean', description: 'Only show unread messages' },
+  },
+  async run({ args }) {
+    const client = createClient()
+    const qs = args.unread ? '?unread=1' : ''
+    const { messages } = await client.get<ListInboxResponse>(
+      `/api/agents/${args.agent}/messages${qs}`,
+    )
+    if (messages.length === 0) {
+      console.log(args.unread ? '(no unread messages)' : '(inbox empty)')
+      return
+    }
+    for (const line of columnize(messages.map(messageRow))) console.log(line)
+  },
+})
+
+const showCmd = defineCommand({
+  meta: { name: 'show', description: 'Show a single message in full' },
+  args: {
+    id: { type: 'positional', required: true, description: 'Message id' },
+  },
+  async run({ args }) {
+    const client = createClient()
+    const m = await client.get<Message>(`/api/messages/${args.id}`)
+    const when = new Date(m.createdAt).toISOString()
+    const read = m.readAt ? new Date(m.readAt).toISOString() : '(unread)'
+    console.log(`id:        ${m.id}`)
+    console.log(`from:      ${m.fromAgentId}`)
+    console.log(`to:        ${m.toAgentId}`)
+    console.log(`created:   ${when}`)
+    console.log(`read:      ${read}`)
+    if (m.replyTo) console.log(`reply_to:  ${m.replyTo}`)
+    console.log('')
+    console.log(decodeText(m.payload))
+  },
+})
+
+const readCmd = defineCommand({
+  meta: { name: 'read', description: 'Mark a message as read' },
+  args: {
+    id: { type: 'positional', required: true, description: 'Message id' },
+  },
+  async run({ args }) {
+    const client = createClient()
+    await client.patch<Message>(`/api/messages/${args.id}`, { read: true })
+    console.log(`marked read: ${args.id}`)
+  },
+})
+
+export const inboxCommand = defineCommand({
+  meta: { name: 'inbox', description: 'Inspect agent inboxes' },
+  subCommands: {
+    list: listCmd,
+    show: showCmd,
+    read: readCmd,
+  },
+})

package/apps/cli/src/commands/login.ts

@@ -0,0 +1,73 @@
+import { existsSync, readFileSync, writeFileSync } from 'node:fs'
+import { defineCommand } from 'citty'
+import type { AuthFile } from '../auth-file.ts'
+import { resolveCliPaths } from '../paths.ts'
+
+function normalizeServer(raw: string): string {
+  let url: URL
+  try {
+    url = new URL(raw)
+  } catch {
+    throw new Error(`invalid --server URL: ${raw}`)
+  }
+  if (!/^https?:$/.test(url.protocol)) {
+    throw new Error(`--server must be http(s), got ${url.protocol}`)
+  }
+  // Strip trailing slash so `${serverUrl}${path}` never produces `//`.
+  return `${url.origin}${url.pathname.replace(/\/$/, '')}`
+}
+
+async function verifyToken(server: string, token: string): Promise<void> {
+  const res = await fetch(`${server}/api/health`, {
+    headers: { authorization: `Bearer ${token}`, origin: server },
+  })
+  if (res.status === 401) throw new Error('server rejected token (401)')
+  if (!res.ok) throw new Error(`server returned ${res.status} from /api/health`)
+}
+
+export const loginCommand = defineCommand({
+  meta: {
+    name: 'login',
+    description: 'Save a remote bazilion server + token pair to auth.json',
+  },
+  args: {
+    server: { type: 'string', description: 'Remote server URL (http[s]://...)' },
+    token: { type: 'string', description: 'Token issued by `bazilion token create`' },
+    skipVerify: { type: 'boolean', description: "Don't probe /api/health before saving" },
+    clear: { type: 'boolean', description: 'Remove the stored remote instead of setting one' },
+  },
+  async run({ args }) {
+    const paths = resolveCliPaths()
+    if (!existsSync(paths.authFile)) {
+      throw new Error(
+        `${paths.authFile} not found. Start the daemon with "bazilion serve" first — login stores the remote there.`,
+      )
+    }
+    const auth = JSON.parse(readFileSync(paths.authFile, 'utf8')) as AuthFile
+
+    if (args.clear) {
+      if (!auth.remote) {
+        console.log('no remote stored — nothing to clear')
+        return
+      }
+      delete auth.remote
+      writeFileSync(paths.authFile, `${JSON.stringify(auth, null, 2)}\n`, { mode: 0o600 })
+      console.log('cleared stored remote; CLI will fall back to the local daemon')
+      return
+    }
+
+    if (!args.server || !args.token) {
+      throw new Error(
+        '--server and --token are required (or pass --clear to remove the stored remote)',
+      )
+    }
+    const server = normalizeServer(args.server)
+    if (!args.skipVerify) {
+      await verifyToken(server, args.token)
+    }
+    auth.remote = { server, token: args.token }
+    writeFileSync(paths.authFile, `${JSON.stringify(auth, null, 2)}\n`, { mode: 0o600 })
+    console.log(`saved remote: ${server}`)
+    console.log('CLI will now target this server unless BAZILION_SERVER is set in the env.')
+  },
+})

package/apps/cli/src/commands/memory.ts

@@ -0,0 +1,106 @@
+import type { MemoryEntry, MemoryHit } from '@bazilion/api-types'
+import { defineCommand } from 'citty'
+import { createClient } from '../client.ts'
+
+function encodeKey(key: string): string {
+  return key.split('/').map(encodeURIComponent).join('/')
+}
+
+const writeCmd = defineCommand({
+  meta: { name: 'write', description: "Write an entry into a group's shared memory" },
+  args: {
+    group: { type: 'positional', required: true, description: 'Group slug' },
+    key: { type: 'positional', required: true, description: 'Memory key (path under memory/)' },
+    content: { type: 'positional', required: true, description: 'Content to write' },
+  },
+  async run({ args }) {
+    const client = createClient()
+    const entry = await client.put<MemoryEntry>(
+      `/api/groups/${args.group}/memory/${encodeKey(args.key)}`,
+      { content: args.content },
+    )
+    console.log(`wrote ${entry.key} (${entry.content.length} bytes)`)
+  },
+})
+
+const readCmd = defineCommand({
+  meta: { name: 'read', description: "Read an entry from a group's shared memory" },
+  args: {
+    group: { type: 'positional', required: true, description: 'Group slug' },
+    key: { type: 'positional', required: true },
+  },
+  async run({ args }) {
+    const client = createClient()
+    const entry = await client.get<MemoryEntry>(
+      `/api/groups/${args.group}/memory/${encodeKey(args.key)}`,
+    )
+    console.log(entry.content)
+  },
+})
+
+const searchCmd = defineCommand({
+  meta: { name: 'search', description: "Search a group's shared memory" },
+  args: {
+    group: { type: 'positional', required: true, description: 'Group slug' },
+    query: { type: 'positional', required: true },
+    limit: { type: 'string', description: 'Max results (default 10)' },
+  },
+  async run({ args }) {
+    const client = createClient()
+    const limit = args.limit ? Number.parseInt(args.limit, 10) : 10
+    const params = new URLSearchParams({ q: args.query, limit: String(limit) })
+    const hits = await client.get<MemoryHit[]>(`/api/groups/${args.group}/memory/search?${params}`)
+    if (hits.length === 0) {
+      console.log('(no matches)')
+      return
+    }
+    for (const h of hits) {
+      console.log(`${h.key}\t${h.snippet.replaceAll('\n', ' ')}`)
+    }
+  },
+})
+
+const listCmd = defineCommand({
+  meta: { name: 'list', description: "List all entries in a group's shared memory" },
+  args: {
+    group: { type: 'positional', required: true, description: 'Group slug' },
+  },
+  async run({ args }) {
+    const client = createClient()
+    const all = await client.get<MemoryEntry[]>(`/api/groups/${args.group}/memory`)
+    if (all.length === 0) {
+      console.log('(no memory entries)')
+      return
+    }
+    for (const e of all) {
+      console.log(`${e.key}\t${e.content.length}b`)
+    }
+  },
+})
+
+const rmCmd = defineCommand({
+  meta: { name: 'rm', description: "Remove an entry from a group's shared memory" },
+  args: {
+    group: { type: 'positional', required: true, description: 'Group slug' },
+    key: { type: 'positional', required: true },
+  },
+  async run({ args }) {
+    const client = createClient()
+    await client.del(`/api/groups/${args.group}/memory/${encodeKey(args.key)}`)
+    console.log(`removed ${args.key}`)
+  },
+})
+
+export const memoryCommand = defineCommand({
+  meta: {
+    name: 'memory',
+    description: "Manage a group's shared memory (BM25-indexed markdown notes)",
+  },
+  subCommands: {
+    write: writeCmd,
+    read: readCmd,
+    search: searchCmd,
+    list: listCmd,
+    rm: rmCmd,
+  },
+})

package/apps/cli/src/commands/profile.ts

@@ -0,0 +1,259 @@
+import { spawn } from 'node:child_process'
+import { randomBytes } from 'node:crypto'
+import { readFileSync, rmSync, writeFileSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import type {
+  CreateProfileRequest,
+  FileContentResponse,
+  LoadedProfile,
+  Profile,
+  ProfileFileName,
+  PutFileRequest,
+  SkillsMode,
+  UpdateProfileRequest,
+} from '@bazilion/api-types'
+import { PROFILE_FILES } from '@bazilion/api-types'
+import { defineCommand } from 'citty'
+import { createClient } from '../client.ts'
+import { columnize } from '../columnize.ts'
+
+function splitCsv(v: string | undefined): string[] | undefined {
+  if (!v) return undefined
+  const out = v
+    .split(',')
+    .map((s) => s.trim())
+    .filter(Boolean)
+  return out.length > 0 ? out : undefined
+}
+
+function parseSkillsMode(v: string | undefined): SkillsMode | undefined {
+  if (v === undefined) return undefined
+  if (v === 'all' || v === 'selected') return v
+  throw new Error(`--skills-mode must be 'all' or 'selected', got '${v}'`)
+}
+
+const createCmd = defineCommand({
+  meta: { name: 'create', description: 'Create a new profile' },
+  args: {
+    id: { type: 'positional', required: true, description: 'Profile slug' },
+    name: { type: 'string', description: 'Display name (defaults to slug)' },
+    model: {
+      type: 'string',
+      required: true,
+      description: 'Default model, e.g. anthropic:claude-opus-4-6',
+    },
+    'skills-mode': {
+      type: 'string',
+      description: "'all' (attach every discovered skill) or 'selected' (default)",
+    },
+    skills: {
+      type: 'string',
+      description: 'Default skills, comma-separated (skills-mode=selected)',
+    },
+    'soul-file': {
+      type: 'string',
+      description: 'Path to custom SOUL.md content (defaults to the built-in template)',
+    },
+    'identity-file': {
+      type: 'string',
+      description: 'Path to custom IDENTITY.md content (defaults to the built-in template)',
+    },
+    'bootstrap-file': {
+      type: 'string',
+      description: 'Path to custom BOOTSTRAP.md content (defaults to the built-in template)',
+    },
+    'skip-bootstrap': {
+      type: 'boolean',
+      description: 'Skip the bootstrap file entirely (no first-run intro)',
+    },
+    'agents-file': {
+      type: 'string',
+      description: 'Path to AGENTS.md content (optional; omit to skip)',
+    },
+    'tools-file': {
+      type: 'string',
+      description: 'Path to TOOLS.md content (optional; omit to skip)',
+    },
+    'heartbeat-file': {
+      type: 'string',
+      description: 'Path to HEARTBEAT.md content (optional; omit to skip)',
+    },
+  },
+  async run({ args }) {
+    const skillsMode = parseSkillsMode(args['skills-mode'])
+    const readTemplate = (path: string | undefined): string | undefined =>
+      path ? readFileSync(path, 'utf8') : undefined
+    const body: CreateProfileRequest = {
+      id: args.id,
+      name: args.name,
+      defaultModel: args.model,
+      skillsMode,
+      defaultSkills: splitCsv(args.skills),
+      soul: readTemplate(args['soul-file']),
+      identity: readTemplate(args['identity-file']),
+      bootstrap: args['skip-bootstrap']
+        ? null
+        : (readTemplate(args['bootstrap-file']) ?? undefined),
+      agents: readTemplate(args['agents-file']),
+      tools: readTemplate(args['tools-file']),
+      heartbeat: readTemplate(args['heartbeat-file']),
+    }
+    const client = createClient()
+    const profile = await client.post<Profile>('/api/profiles', body)
+    console.log(`created profile ${profile.id} at ${profile.dir}`)
+  },
+})
+
+const listCmd = defineCommand({
+  meta: { name: 'list', description: 'List profiles' },
+  async run() {
+    const client = createClient()
+    const list = await client.get<Profile[]>('/api/profiles')
+    if (list.length === 0) {
+      console.log('(no profiles)')
+      return
+    }
+    const rows = list.map((p) => [p.id, p.defaultModel, p.name])
+    for (const line of columnize(rows)) console.log(line)
+  },
+})
+
+const showCmd = defineCommand({
+  meta: { name: 'show', description: 'Show profile details' },
+  args: {
+    id: { type: 'positional', required: true },
+  },
+  async run({ args }) {
+    const client = createClient()
+    const loaded = await client.get<LoadedProfile>(`/api/profiles/${args.id}`)
+    console.log(`# ${loaded.profile.id}`)
+    console.log(`name:           ${loaded.profile.name}`)
+    console.log(`dir:            ${loaded.profile.dir}`)
+    console.log(`default model:  ${loaded.profile.defaultModel}`)
+    console.log(`skills mode:    ${loaded.profile.skillsMode}`)
+    console.log(
+      `default skills: ${
+        loaded.defaultSkills.length === 0 ? '(none)' : loaded.defaultSkills.join(', ')
+      }`,
+    )
+    console.log(`bootstrap: ${loaded.files.bootstrap !== null ? 'yes' : 'no'}`)
+    console.log(`agents:    ${loaded.files.agents !== null ? 'yes' : 'no'}`)
+    console.log(`tools:     ${loaded.files.tools !== null ? 'yes' : 'no'}`)
+    console.log(`heartbeat: ${loaded.files.heartbeat !== null ? 'yes' : 'no'}`)
+    if (loaded.identity) {
+      const fields = Object.entries(loaded.identity)
+        .filter(([, v]) => typeof v === 'string' && v.length > 0)
+        .map(([k, v]) => `${k}=${v}`)
+        .join(', ')
+      if (fields) console.log(`identity:  ${fields}`)
+    }
+  },
+})
+
+const editCmd = defineCommand({
+  meta: { name: 'edit', description: 'Open a profile file in $EDITOR' },
+  args: {
+    id: { type: 'positional', required: true },
+    file: {
+      type: 'string',
+      default: 'profile.json',
+      description: `File: ${PROFILE_FILES.join(', ')}`,
+    },
+  },
+  async run({ args }) {
+    if (!(PROFILE_FILES as readonly string[]).includes(args.file)) {
+      throw new Error(`unsupported file: ${args.file}. Allowed: ${PROFILE_FILES.join(', ')}`)
+    }
+    const file = args.file as ProfileFileName
+    const client = createClient()
+    const { content } = await client.get<FileContentResponse>(
+      `/api/profiles/${args.id}/files/${file}`,
+    )
+    const tmpPath = join(tmpdir(), `bazilion-${args.id}-${file}-${randomBytes(4).toString('hex')}`)
+    writeFileSync(tmpPath, content)
+    try {
+      const editor = process.env.EDITOR ?? process.env.VISUAL ?? 'vi'
+      const code: number = await new Promise((resolve, reject) => {
+        const child = spawn(editor, [tmpPath], { stdio: 'inherit' })
+        child.on('error', reject)
+        child.on('close', (c) => resolve(c ?? 0))
+      })
+      if (code !== 0) throw new Error(`editor exited with code ${code}`)
+      const updated = readFileSync(tmpPath, 'utf8')
+      if (updated === content) {
+        console.log('(no changes)')
+        return
+      }
+      const body: PutFileRequest = { content: updated }
+      await client.put(`/api/profiles/${args.id}/files/${file}`, body)
+      console.log(`saved ${file}`)
+    } finally {
+      try {
+        rmSync(tmpPath, { force: true })
+      } catch {}
+    }
+  },
+})
+
+const updateCmd = defineCommand({
+  meta: {
+    name: 'update',
+    description: 'Update profile settings (name, model, skills-mode, skills)',
+  },
+  args: {
+    id: { type: 'positional', required: true },
+    name: { type: 'string', description: 'New display name' },
+    model: { type: 'string', description: 'New default model' },
+    'skills-mode': {
+      type: 'string',
+      description: "Switch to 'all' or 'selected'",
+    },
+    skills: { type: 'string', description: 'Replacement default skills, comma-separated' },
+  },
+  async run({ args }) {
+    const body: UpdateProfileRequest = {}
+    if (args.name !== undefined) body.name = args.name
+    if (args.model !== undefined) body.defaultModel = args.model
+    const mode = parseSkillsMode(args['skills-mode'])
+    if (mode !== undefined) body.skillsMode = mode
+    if (args.skills !== undefined) {
+      body.defaultSkills = args.skills
+        .split(',')
+        .map((s) => s.trim())
+        .filter(Boolean)
+    }
+    if (Object.keys(body).length === 0) {
+      throw new Error(
+        'nothing to update — pass at least one of --name/--model/--skills-mode/--skills',
+      )
+    }
+    const client = createClient()
+    const profile = await client.patch<Profile>(`/api/profiles/${args.id}`, body)
+    console.log(`updated profile ${profile.id}`)
+  },
+})
+
+const deleteCmd = defineCommand({
+  meta: { name: 'delete', description: 'Permanently delete a profile and its files' },
+  args: {
+    id: { type: 'positional', required: true },
+  },
+  async run({ args }) {
+    const client = createClient()
+    await client.del(`/api/profiles/${args.id}`)
+    console.log(`deleted profile ${args.id}`)
+  },
+})
+
+export const profileCommand = defineCommand({
+  meta: { name: 'profile', description: 'Manage profiles' },
+  subCommands: {
+    create: createCmd,
+    list: listCmd,
+    show: showCmd,
+    edit: editCmd,
+    update: updateCmd,
+    delete: deleteCmd,
+  },
+})

package/apps/cli/src/commands/provider.ts

@@ -0,0 +1,170 @@
+import type {
+  ProviderConfigResponse,
+  ProviderTestRequest,
+  ProviderTestResponse,
+  SetProviderEnabledResponse,
+  SetProviderModelsRequest,
+  SetProviderModelsResponse,
+} from '@bazilion/api-types'
+import { defineCommand } from 'citty'
+import { createClient } from '../client.ts'
+import { columnize } from '../columnize.ts'
+
+const listCmd = defineCommand({
+  meta: {
+    name: 'list',
+    description: 'List all providers with enabled/disabled state and curated model counts',
+  },
+  args: {
+    enabled: { type: 'boolean', description: 'Show only enabled providers' },
+  },
+  async run({ args }) {
+    const client = createClient()
+    const { providers } = await client.get<ProviderConfigResponse>('/api/config/providers')
+    const filtered = args.enabled ? providers.filter((p) => p.enabled) : providers
+    if (filtered.length === 0) {
+      console.log('(no providers to show)')
+      return
+    }
+    const rows = filtered.map((p) => [
+      p.id,
+      p.enabled ? 'enabled' : 'disabled',
+      `${p.curated.length} curated`,
+      `${p.catalog.length} catalog`,
+      p.enabled ? '' : `(set ${p.envHint})`,
+    ])
+    for (const line of columnize(rows)) console.log(line)
+  },
+})
+
+const modelsCmd = defineCommand({
+  meta: {
+    name: 'models',
+    description: 'Show curated + catalog + live models for one provider',
+  },
+  args: {
+    name: { type: 'positional', required: true, description: 'Provider name' },
+  },
+  async run({ args }) {
+    const client = createClient()
+    const { providers } = await client.get<ProviderConfigResponse>('/api/config/providers')
+    const p = providers.find((x) => x.id === args.name)
+    if (!p) {
+      console.error(`unknown provider: ${args.name}`)
+      process.exit(1)
+    }
+    console.log(`# ${p.id} (${p.enabled ? 'enabled' : 'disabled'})`)
+    if (!p.enabled) console.log(`  (set ${p.envHint} to enable)`)
+
+    console.log('\n## curated')
+    if (p.curated.length === 0) console.log('  (none — use `provider models-set` to pin some)')
+    else for (const m of p.curated) console.log(`  ${m}`)
+
+    console.log('\n## catalog (from pi-ai)')
+    if (p.catalog.length === 0) console.log('  (empty)')
+    else for (const m of p.catalog) console.log(`  ${m}`)
+
+    if (p.live) {
+      console.log('\n## live (from upstream /v1/models)')
+      if (p.live.error) console.log(`  (error: ${p.live.error})`)
+      else if (p.live.models.length === 0) console.log('  (empty)')
+      else for (const m of p.live.models) console.log(`  ${m}`)
+    }
+  },
+})
+
+const modelsSetCmd = defineCommand({
+  meta: {
+    name: 'models-set',
+    description: 'Replace the curated model list for a provider (comma-separated)',
+  },
+  args: {
+    name: { type: 'positional', required: true, description: 'Provider name' },
+    models: {
+      type: 'positional',
+      required: true,
+      description: 'Comma-separated model list (empty string clears the list)',
+    },
+  },
+  async run({ args }) {
+    const client = createClient()
+    const models = args.models
+      .split(',')
+      .map((s) => s.trim())
+      .filter(Boolean)
+    const body: SetProviderModelsRequest = { models }
+    const saved = await client.put<SetProviderModelsResponse>(
+      `/api/config/providers/${encodeURIComponent(args.name)}/models`,
+      body,
+    )
+    console.log(`saved ${saved.models.length} curated model(s) for ${args.name}`)
+    for (const m of saved.models) console.log(`  ${m}`)
+  },
+})
+
+const enableCmd = defineCommand({
+  meta: { name: 'enable', description: 'Toggle a provider on so agents can use it' },
+  args: {
+    name: { type: 'positional', required: true, description: 'Provider id (e.g. anthropic)' },
+  },
+  async run({ args }) {
+    const client = createClient()
+    const res = await client.put<SetProviderEnabledResponse>(
+      `/api/config/providers/${encodeURIComponent(args.name)}/enabled`,
+      { enabled: true },
+    )
+    console.log(`${res.name}: enabled`)
+  },
+})
+
+const disableCmd = defineCommand({
+  meta: {
+    name: 'disable',
+    description: 'Toggle a provider off — agents will refuse its model strings',
+  },
+  args: {
+    name: { type: 'positional', required: true, description: 'Provider id' },
+  },
+  async run({ args }) {
+    const client = createClient()
+    const res = await client.put<SetProviderEnabledResponse>(
+      `/api/config/providers/${encodeURIComponent(args.name)}/enabled`,
+      { enabled: false },
+    )
+    console.log(`${res.name}: disabled`)
+  },
+})
+
+const testCmd = defineCommand({
+  meta: { name: 'test', description: 'Send a single chat to a model and print the reply' },
+  args: {
+    model: {
+      type: 'positional',
+      required: true,
+      description: 'Model string, e.g. anthropic:claude-opus-4-6',
+    },
+    message: { type: 'string', description: 'Message text (default "say hi briefly")' },
+  },
+  async run({ args }) {
+    const client = createClient()
+    const body: ProviderTestRequest = { model: args.model, message: args.message }
+    console.log(`-> ${args.model}: ${args.message ?? 'say hi briefly'}`)
+    const res = await client.post<ProviderTestResponse>('/api/providers/test', body)
+    console.log(`<- ${res.content}`)
+    if (res.usage) {
+      console.log(`(${res.usage.promptTokens} in, ${res.usage.completionTokens} out)`)
+    }
+  },
+})
+
+export const providerCommand = defineCommand({
+  meta: { name: 'provider', description: 'Manage and test LLM providers' },
+  subCommands: {
+    list: listCmd,
+    enable: enableCmd,
+    disable: disableCmd,
+    models: modelsCmd,
+    'models-set': modelsSetCmd,
+    test: testCmd,
+  },
+})