@brainjar/cli 0.3.0 → 0.4.0

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,77 +1,102 @@
 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 }),
-    ])
+    // 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 = ['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/'],
     }
 
     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 soul create <name>` to create your first soul.'
     }
 
-    if (c.options.obsidian) {
-      await initObsidian(brainjarDir)
-      result.obsidian = true
-      result.vault = brainjarDir
-      result.hint = `Open "${brainjarDir}" as a vault in Obsidian.`
-    }
-
     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],
+    }
+  },
+})

package/src/commands/pack.ts

@@ -24,19 +24,15 @@ const exportCmd = Cli.create('export', {
 })
 
 const importCmd = Cli.create('import', {
-  description: 'Import a pack directory into ~/.brainjar/',
+  description: 'Import a pack directory into the server',
   args: z.object({
     path: z.string().describe('Path to pack directory'),
   }),
   options: z.object({
-    force: z.boolean().default(false).describe('Overwrite existing files on conflict'),
-    merge: z.boolean().default(false).describe('Rename incoming files on conflict as <name>-from-<packname>'),
     activate: z.boolean().default(false).describe('Activate the brain after successful import'),
   }),
   async run(c) {
     return importPack(resolve(c.args.path), {
-      force: c.options.force,
-      merge: c.options.merge,
       activate: c.options.activate,
     })
   },