@brainjar/cli 0.2.3 → 0.4.0

package/src/commands/brain.ts

@@ -1,24 +1,12 @@
 import { Cli, z, Errors } from 'incur'
+import { basename } from 'node:path'
 
 const { IncurError } = Errors
-import { readdir, readFile, writeFile, access, rm } from 'node:fs/promises'
-import { join, basename } from 'node:path'
-import { stringify as stringifyYaml } from 'yaml'
-import { paths } from '../paths.js'
-import {
-  readState,
-  writeState,
-  withStateLock,
-  readLocalState,
-  writeLocalState,
-  withLocalStateLock,
-  readEnvState,
-  mergeState,
-  requireBrainjarDir,
-  normalizeSlug,
-} from '../state.js'
-import { readBrain, type BrainConfig } from '../brain.js'
+import { ErrorCode, createError } from '../errors.js'
+import { normalizeSlug, getEffectiveState, putState } from '../state.js'
 import { sync } from '../sync.js'
+import { getApi } from '../client.js'
+import type { ApiBrain, ApiBrainList, ApiSoul, ApiPersona } from '../api-types.js'
 
 export const brain = Cli.create('brain', {
   description: 'Manage brains — full-stack configuration snapshots (soul + persona + rules)',
@@ -26,65 +14,50 @@ export const brain = Cli.create('brain', {
   .command('save', {
     description: 'Snapshot current effective state as a named brain',
     args: z.object({
-      name: z.string().describe('Brain name (will be used as filename)'),
+      name: z.string().describe('Brain name'),
     }),
     options: z.object({
-      overwrite: z.boolean().default(false).describe('Overwrite existing brain file'),
+      overwrite: z.boolean().default(false).describe('Overwrite existing brain'),
     }),
     async run(c) {
-      await requireBrainjarDir()
       const name = normalizeSlug(c.args.name, 'brain name')
-      const dest = join(paths.brains, `${name}.yaml`)
+      const api = await getApi()
 
       // Check for existing brain
       if (!c.options.overwrite) {
         try {
-          await access(dest)
-          throw new IncurError({
-            code: 'BRAIN_EXISTS',
-            message: `Brain "${name}" already exists.`,
-            hint: 'Use --overwrite to replace it, or choose a different name.',
-          })
+          await api.get<ApiBrain>(`/api/v1/brains/${name}`)
+          throw createError(ErrorCode.BRAIN_EXISTS, { params: [name] })
         } catch (e) {
-          if (e instanceof IncurError) throw e
+          if (e instanceof IncurError && e.code === ErrorCode.BRAIN_EXISTS) throw e
+          if (e instanceof IncurError && e.code !== ErrorCode.NOT_FOUND) throw e
         }
       }
 
-      // Read effective state
-      const globalState = await readState()
-      const localState = await readLocalState()
-      const envState = readEnvState()
-      const effective = mergeState(globalState, localState, envState)
-
-      if (!effective.soul.value) {
-        throw new IncurError({
-          code: 'NO_ACTIVE_SOUL',
-          message: 'Cannot save brain: no active soul.',
-          hint: 'Activate a soul first with `brainjar soul use <name>`.',
-        })
+      const effective = await getEffectiveState(api)
+
+      if (!effective.soul) {
+        throw createError(ErrorCode.NO_ACTIVE_SOUL)
       }
 
-      if (!effective.persona.value) {
-        throw new IncurError({
-          code: 'NO_ACTIVE_PERSONA',
-          message: 'Cannot save brain: no active persona.',
-          hint: 'Activate a persona first with `brainjar persona use <name>`.',
-        })
+      if (!effective.persona) {
+        throw createError(ErrorCode.NO_ACTIVE_PERSONA)
       }
 
       const activeRules = effective.rules
-        .filter(r => !r.scope.startsWith('-'))
-        .map(r => r.value)
 
-      const config: BrainConfig = {
-        soul: effective.soul.value,
-        persona: effective.persona.value,
+      await api.put<ApiBrain>(`/api/v1/brains/${name}`, {
+        soul_slug: effective.soul,
+        persona_slug: effective.persona,
+        rule_slugs: activeRules,
+      })
+
+      return {
+        saved: name,
+        soul: effective.soul,
+        persona: effective.persona,
         rules: activeRules,
       }
-
-      await writeFile(dest, stringifyYaml(config))
-
-      return { saved: name, ...config }
     },
   })
   .command('use', {
@@ -93,68 +66,77 @@ export const brain = Cli.create('brain', {
       name: z.string().describe('Brain name to activate'),
     }),
     options: z.object({
-      local: z.boolean().default(false).describe('Apply brain at project scope'),
+      project: z.boolean().default(false).describe('Apply brain at project scope'),
     }),
     async run(c) {
-      await requireBrainjarDir()
       const name = normalizeSlug(c.args.name, 'brain name')
-      const config = await readBrain(name)
+      const api = await getApi()
+
+      let config: ApiBrain
+      try {
+        config = await api.get<ApiBrain>(`/api/v1/brains/${name}`)
+      } catch (e) {
+        if (e instanceof IncurError && e.code === ErrorCode.NOT_FOUND) {
+          throw createError(ErrorCode.BRAIN_NOT_FOUND, { params: [name] })
+        }
+        throw e
+      }
 
       // Validate soul exists
       try {
-        await readFile(join(paths.souls, `${config.soul}.md`), 'utf-8')
-      } catch {
-        throw new IncurError({
-          code: 'SOUL_NOT_FOUND',
-          message: `Brain "${name}" references soul "${config.soul}" which does not exist.`,
-          hint: 'Create the soul first or update the brain file.',
-        })
+        await api.get<ApiSoul>(`/api/v1/souls/${config.soul_slug}`)
+      } catch (e) {
+        if (e instanceof IncurError && e.code === ErrorCode.NOT_FOUND) {
+          throw createError(ErrorCode.SOUL_NOT_FOUND, {
+            params: [config.soul_slug],
+            message: `Brain "${name}" references soul "${config.soul_slug}" which does not exist.`,
+            hint: 'Create the soul first or update the brain.',
+          })
+        }
+        throw e
       }
 
       // Validate persona exists
       try {
-        await readFile(join(paths.personas, `${config.persona}.md`), 'utf-8')
-      } catch {
-        throw new IncurError({
-          code: 'PERSONA_NOT_FOUND',
-          message: `Brain "${name}" references persona "${config.persona}" which does not exist.`,
-          hint: 'Create the persona first or update the brain file.',
-        })
+        await api.get<ApiPersona>(`/api/v1/personas/${config.persona_slug}`)
+      } catch (e) {
+        if (e instanceof IncurError && e.code === ErrorCode.NOT_FOUND) {
+          throw createError(ErrorCode.PERSONA_NOT_FOUND, {
+            params: [config.persona_slug],
+            message: `Brain "${name}" references persona "${config.persona_slug}" which does not exist.`,
+            hint: 'Create the persona first or update the brain.',
+          })
+        }
+        throw e
       }
 
-      if (c.options.local) {
-        await withLocalStateLock(async () => {
-          const local = await readLocalState()
-          local.soul = config.soul
-          local.persona = config.persona
-          // Replace rules entirely — brain is a complete snapshot
-          local.rules = { add: config.rules, remove: [] }
-          await writeLocalState(local)
-          await sync({ local: true })
-        })
-      } else {
-        await withStateLock(async () => {
-          const state = await readState()
-          state.soul = config.soul
-          state.persona = config.persona
-          state.rules = config.rules
-          await writeState(state)
-          await sync()
-        })
+      const mutationOpts = c.options.project
+        ? { project: basename(process.cwd()) }
+        : undefined
+      await putState(api, {
+        soul_slug: config.soul_slug,
+        persona_slug: config.persona_slug,
+        rule_slugs: config.rule_slugs,
+      }, mutationOpts)
+
+      await sync({ api })
+      if (c.options.project) await sync({ api, project: true })
+
+      return {
+        activated: name,
+        project: c.options.project,
+        soul: config.soul_slug,
+        persona: config.persona_slug,
+        rules: config.rule_slugs,
       }
-
-      return { activated: name, local: c.options.local, ...config }
     },
   })
   .command('list', {
     description: 'List available brains',
     async run() {
-      await requireBrainjarDir()
-      const entries = await readdir(paths.brains).catch(() => [])
-      const brains = entries
-        .filter(f => f.endsWith('.yaml'))
-        .map(f => basename(f, '.yaml'))
-      return { brains }
+      const api = await getApi()
+      const result = await api.get<ApiBrainList>('/api/v1/brains')
+      return { brains: result.brains.map(b => b.slug) }
     },
   })
   .command('show', {
@@ -163,10 +145,18 @@ export const brain = Cli.create('brain', {
       name: z.string().describe('Brain name to show'),
     }),
     async run(c) {
-      await requireBrainjarDir()
       const name = normalizeSlug(c.args.name, 'brain name')
-      const config = await readBrain(name)
-      return { name, ...config }
+      const api = await getApi()
+
+      try {
+        const config = await api.get<ApiBrain>(`/api/v1/brains/${name}`)
+        return { name, soul: config.soul_slug, persona: config.persona_slug, rules: config.rule_slugs }
+      } catch (e) {
+        if (e instanceof IncurError && e.code === ErrorCode.NOT_FOUND) {
+          throw createError(ErrorCode.BRAIN_NOT_FOUND, { params: [name] })
+        }
+        throw e
+      }
     },
   })
   .command('drop', {
@@ -175,22 +165,18 @@ export const brain = Cli.create('brain', {
       name: z.string().describe('Brain name to delete'),
     }),
     async run(c) {
-      await requireBrainjarDir()
       const name = normalizeSlug(c.args.name, 'brain name')
-      const file = join(paths.brains, `${name}.yaml`)
+      const api = await getApi()
 
       try {
-        await access(file)
-      } catch {
-        throw new IncurError({
-          code: 'BRAIN_NOT_FOUND',
-          message: `Brain "${name}" not found.`,
-          hint: 'Run `brainjar brain list` to see available brains.',
-        })
+        await api.delete(`/api/v1/brains/${name}`)
+      } catch (e) {
+        if (e instanceof IncurError && e.code === ErrorCode.NOT_FOUND) {
+          throw createError(ErrorCode.BRAIN_NOT_FOUND, { params: [name] })
+        }
+        throw e
       }
 
-      await rm(file)
-
       return { dropped: name }
     },
   })

package/src/commands/compose.ts

@@ -1,21 +1,9 @@
 import { Cli, z, Errors } from 'incur'
 
 const { IncurError } = Errors
-import { readFile } from 'node:fs/promises'
-import { join } from 'node:path'
-import { paths } from '../paths.js'
-import {
-  readState,
-  readLocalState,
-  readEnvState,
-  mergeState,
-  requireBrainjarDir,
-  normalizeSlug,
-  parseLayerFrontmatter,
-  stripFrontmatter,
-  resolveRuleContent,
-} from '../state.js'
-import { readBrain } from '../brain.js'
+import { ErrorCode, createError } from '../errors.js'
+import { getApi } from '../client.js'
+import type { ApiComposeResult } from '../api-types.js'
 
 export const compose = Cli.create('compose', {
   description: 'Assemble a full subagent prompt from a brain or ad-hoc persona',
@@ -27,129 +15,42 @@ export const compose = Cli.create('compose', {
     task: z.string().optional().describe('Task description to append to the prompt'),
   }),
   async run(c) {
-    await requireBrainjarDir()
-
     const brainName = c.args.brain
     const personaFlag = c.options.persona
 
     // Mutual exclusivity
     if (brainName && personaFlag) {
-      throw new IncurError({
-        code: 'MUTUALLY_EXCLUSIVE',
+      throw createError(ErrorCode.MUTUALLY_EXCLUSIVE, {
         message: 'Cannot specify both a brain name and --persona.',
         hint: 'Use `brainjar compose <brain>` or `brainjar compose --persona <name>`, not both.',
       })
     }
 
     if (!brainName && !personaFlag) {
-      throw new IncurError({
-        code: 'MISSING_ARG',
+      throw createError(ErrorCode.MISSING_ARG, {
         message: 'Provide a brain name or --persona.',
         hint: 'Usage: `brainjar compose <brain>` or `brainjar compose --persona <name>`.',
       })
     }
 
-    const sections: string[] = []
-    const warnings: string[] = []
-    let soulName: string | null = null
-    let personaName: string
-    let rulesList: string[]
-
-    if (brainName) {
-      // === Primary path: brain-driven ===
-      const config = await readBrain(brainName)
-      soulName = config.soul
-      personaName = config.persona
-      rulesList = config.rules
-
-      // Soul — from brain
-      try {
-        const raw = await readFile(join(paths.souls, `${soulName}.md`), 'utf-8')
-        sections.push(stripFrontmatter(raw))
-      } catch {
-        warnings.push(`Soul "${soulName}" not found — skipped`)
-        soulName = null
-      }
-
-      // Persona — from brain
-      let personaRaw: string
-      try {
-        personaRaw = await readFile(join(paths.personas, `${personaName}.md`), 'utf-8')
-      } catch {
-        throw new IncurError({
-          code: 'PERSONA_NOT_FOUND',
-          message: `Brain "${brainName}" references persona "${personaName}" which does not exist.`,
-          hint: 'Create the persona first or update the brain file.',
-        })
-      }
-      sections.push(stripFrontmatter(personaRaw))
-
-      // Rules — from brain (overrides persona frontmatter)
-      for (const rule of rulesList) {
-        const resolved = await resolveRuleContent(rule, warnings)
-        sections.push(...resolved)
-      }
-    } else {
-      // === Ad-hoc path: --persona flag ===
-      const personaSlug = normalizeSlug(personaFlag!, 'persona name')
-      personaName = personaSlug
-
-      let personaRaw: string
-      try {
-        personaRaw = await readFile(join(paths.personas, `${personaSlug}.md`), 'utf-8')
-      } catch {
-        throw new IncurError({
-          code: 'PERSONA_NOT_FOUND',
-          message: `Persona "${personaSlug}" not found.`,
-          hint: 'Run `brainjar persona list` to see available personas.',
-        })
-      }
-
-      const frontmatter = parseLayerFrontmatter(personaRaw)
-      rulesList = frontmatter.rules
+    const api = await getApi()
 
-      // Soul — from active state cascade
-      const globalState = await readState()
-      const localState = await readLocalState()
-      const envState = readEnvState()
-      const effective = mergeState(globalState, localState, envState)
-
-      if (effective.soul.value) {
-        soulName = effective.soul.value
-        try {
-          const raw = await readFile(join(paths.souls, `${soulName}.md`), 'utf-8')
-          sections.push(stripFrontmatter(raw))
-        } catch {
-          warnings.push(`Soul "${soulName}" not found — skipped`)
-          soulName = null
-        }
-      }
-
-      // Persona content
-      sections.push(stripFrontmatter(personaRaw))
-
-      // Rules — from persona frontmatter
-      for (const rule of rulesList) {
-        const resolved = await resolveRuleContent(rule, warnings)
-        sections.push(...resolved)
-      }
-    }
-
-    // Task section
-    if (c.options.task) {
-      sections.push(`# Task\n\n${c.options.task}`)
-    }
+    const body: Record<string, unknown> = {}
+    if (brainName) body.brain = brainName
+    if (personaFlag) body.persona = personaFlag
+    if (c.options.task) body.task = c.options.task
 
-    const prompt = sections.join('\n\n')
+    const composed = await api.post<ApiComposeResult>('/api/v1/compose', body)
 
     const result: Record<string, unknown> = {
-      persona: personaName,
-      rules: rulesList,
-      prompt,
+      persona: composed.persona,
+      rules: composed.rules,
+      prompt: composed.prompt,
     }
     if (brainName) result.brain = brainName
-    if (soulName) result.soul = soulName
-    if (warnings.length) result.warnings = warnings
+    if (composed.soul) result.soul = composed.soul
+    if (composed.token_estimate) result.token_estimate = composed.token_estimate
+    if (composed.warnings?.length) result.warnings = composed.warnings
 
     return result
   },

package/src/commands/init.ts

@@ -1,76 +1,100 @@
 import { Cli, z } from 'incur'
-import { mkdir, writeFile } from 'node:fs/promises'
-import { join } from 'node:path'
+import { mkdir, access } from 'node:fs/promises'
 import { getBrainjarDir, paths, type Backend } from '../paths.js'
-import { seedDefaultRule, seedDefaults, initObsidian } from '../seeds.js'
-import { readState, writeState, withStateLock } from '../state.js'
+import { buildSeedBundle } from '../seeds.js'
+import { putState } from '../state.js'
 import { sync } from '../sync.js'
+import { getApi } from '../client.js'
+import { readConfig, writeConfig, type Config } from '../config.js'
+import { ensureBinary, upgradeServer } from '../daemon.js'
+import type { ApiImportResult } from '../api-types.js'
 
 export const init = Cli.create('init', {
-  description: 'Bootstrap ~/.brainjar/ directory structure',
+  description: 'Initialize brainjar: config, server, and optional seed content',
   options: z.object({
     backend: z.enum(['claude', 'codex']).default('claude').describe('Agent backend to target'),
     default: z.boolean().default(false).describe('Seed starter soul, personas, and rules'),
-    obsidian: z.boolean().default(false).describe('Set up ~/.brainjar/ as an Obsidian vault'),
   }),
   async run(c) {
     const brainjarDir = getBrainjarDir()
+    const binDir = `${brainjarDir}/bin`
 
-    await Promise.all([
-      mkdir(paths.souls, { recursive: true }),
-      mkdir(paths.personas, { recursive: true }),
-      mkdir(paths.rules, { recursive: true }),
-      mkdir(paths.brains, { recursive: true }),
-      mkdir(paths.identities, { recursive: true }),
-    ])
+    // 1. Create directories
+    await mkdir(brainjarDir, { recursive: true })
+    await mkdir(binDir, { recursive: true })
 
-    // Seed the default rule pack
-    await seedDefaultRule(paths.rules)
+    // 2. Write config.yaml if missing
+    let configExists = false
+    try {
+      await access(paths.config)
+      configExists = true
+    } catch {}
 
-    // Build .gitignore — always exclude private files, add .obsidian if vault enabled
-    const gitignoreLines = ['identities/', '.session', 'state.yaml']
-    if (c.options.obsidian) {
-      gitignoreLines.push('.obsidian/', 'templates/')
+    if (!configExists) {
+      const config: Config = {
+        server: {
+          url: 'http://localhost:7742',
+          mode: 'local',
+          bin: `${brainjarDir}/bin/brainjar-server`,
+          pid_file: `${brainjarDir}/server.pid`,
+          log_file: `${brainjarDir}/server.log`,
+        },
+        workspace: 'default',
+        backend: c.options.backend as Backend,
+      }
+      await writeConfig(config)
+    }
+
+    // 3. Ensure server binary exists and is up to date
+    await ensureBinary()
+    const config = await readConfig()
+    if (config.server.mode === 'local') {
+      // Only upgrade if server isn't already running (can't overwrite a running binary)
+      const health = await (await import('../daemon.js')).healthCheck({ timeout: 1000, url: config.server.url })
+      if (!health.healthy) {
+        await upgradeServer()
+      }
     }
-    await writeFile(join(brainjarDir, '.gitignore'), gitignoreLines.join('\n') + '\n')
 
+    // 4. Start server and get API client
+    const api = await getApi()
+
+    // 5. Ensure workspace exists (ignore conflict if already created)
+    try {
+      await api.post('/api/v1/workspaces', { name: config.workspace }, { headers: { 'X-Brainjar-Workspace': '' } })
+    } catch (e: any) {
+      if (e.code !== 'CONFLICT') throw e
+    }
+
+    // 6. Seed defaults if requested
     if (c.options.default) {
-      await seedDefaults()
+      const bundle = await buildSeedBundle()
+      await api.post<ApiImportResult>('/api/v1/import', bundle)
+
+      await putState(api, {
+        soul_slug: 'craftsman',
+        persona_slug: 'engineer',
+        rule_slugs: ['boundaries', 'context-recovery', 'task-completion', 'git-discipline', 'security'],
+      })
     }
 
-    await withStateLock(async () => {
-      const state = await readState()
-      state.backend = c.options.backend
-      if (c.options.default) {
-        state.soul = 'craftsman'
-        state.persona = 'engineer'
-        state.rules = ['default', 'git-discipline', 'security']
-      }
-      await writeState(state)
-      await sync(c.options.backend as Backend)
-    })
+    // 7. Sync to write CLAUDE.md / AGENTS.md
+    await sync({ api, backend: c.options.backend as Backend })
 
+    // 8. Build result
     const result: Record<string, unknown> = {
       created: brainjarDir,
       backend: c.options.backend,
-      directories: ['souls/', 'personas/', 'rules/', 'brains/', 'identities/'],
     }
 
     if (c.options.default) {
       result.soul = 'craftsman'
       result.persona = 'engineer'
-      result.rules = ['default', 'git-discipline', 'security']
+      result.rules = ['boundaries', 'context-recovery', 'task-completion', 'git-discipline', 'security']
       result.personas = ['engineer', 'planner', 'reviewer']
       result.next = 'Ready to go. Run `brainjar status` to see your config.'
     } else {
-      result.next = 'Run `brainjar identity create <slug> --name <name> --email <email>` to set up your first identity.'
-    }
-
-    if (c.options.obsidian) {
-      await initObsidian(brainjarDir)
-      result.obsidian = true
-      result.vault = brainjarDir
-      result.hint = `Open "${brainjarDir}" as a vault in Obsidian.`
+      result.next = 'Run `brainjar soul create <name>` to create your first soul.'
     }
 
     return result

package/src/commands/migrate.ts

@@ -0,0 +1,61 @@
+import { Cli, z } from 'incur'
+import { getBrainjarDir } from '../paths.js'
+import { buildMigrationBundle, backupContentDirs } from '../migrate.js'
+import { getApi } from '../client.js'
+import { putState } from '../state.js'
+import { sync } from '../sync.js'
+import type { ApiImportResult } from '../api-types.js'
+
+export const migrate = Cli.create('migrate', {
+  description: 'Import file-based content into the server',
+  options: z.object({
+    dryRun: z.boolean().default(false).describe('Preview what would be imported without making changes'),
+    skipBackup: z.boolean().default(false).describe('Skip renaming source directories to .bak'),
+  }),
+  async run(c) {
+    const brainjarDir = getBrainjarDir()
+    const { bundle, state, counts, warnings: scanWarnings } = await buildMigrationBundle(brainjarDir)
+
+    const total = counts.souls + counts.personas + counts.rules + counts.brains
+    if (total === 0) {
+      return { migrated: false, reason: 'No file-based content found to migrate.' }
+    }
+
+    if (c.options.dryRun) {
+      return {
+        dry_run: true,
+        would_import: counts,
+        would_restore_state: state !== null,
+        warnings: scanWarnings,
+      }
+    }
+
+    const api = await getApi()
+    const result = await api.post<ApiImportResult>('/api/v1/import', bundle)
+
+    let stateRestored = false
+    if (state && (state.soul || state.persona || state.rules.length > 0)) {
+      await putState(api, {
+        soul_slug: state.soul || undefined,
+        persona_slug: state.persona || undefined,
+        rule_slugs: state.rules.length > 0 ? state.rules : undefined,
+      })
+      stateRestored = true
+    }
+
+    await sync({ api })
+
+    let backedUp: string[] = []
+    if (!c.options.skipBackup) {
+      backedUp = await backupContentDirs(brainjarDir)
+    }
+
+    return {
+      migrated: true,
+      imported: result.imported,
+      state_restored: stateRestored,
+      backed_up: backedUp,
+      warnings: [...scanWarnings, ...result.warnings],
+    }
+  },
+})