@brainjar/cli 0.3.0 → 0.4.1

package/src/commands/persona.ts

@@ -1,11 +1,12 @@
 import { Cli, z, Errors } from 'incur'
+import { basename } from 'node:path'
 
 const { IncurError } = Errors
-import { readdir, readFile, writeFile, access } from 'node:fs/promises'
-import { join, basename } from 'node:path'
-import { paths } from '../paths.js'
-import { type State, readState, writeState, withStateLock, readLocalState, writeLocalState, withLocalStateLock, readEnvState, mergeState, requireBrainjarDir, parseLayerFrontmatter, stripFrontmatter, normalizeSlug, listAvailableRules } from '../state.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 { ApiPersona, ApiPersonaList, ApiRuleList } from '../api-types.js'
 
 export const persona = Cli.create('persona', {
   description: 'Manage personas — role behavior and workflow for the agent',
@@ -13,53 +14,43 @@ export const persona = Cli.create('persona', {
   .command('create', {
     description: 'Create a new persona',
     args: z.object({
-      name: z.string().describe('Persona name (will be used as filename)'),
+      name: z.string().describe('Persona name'),
     }),
     options: z.object({
       description: z.string().optional().describe('One-line description of the persona'),
       rules: z.array(z.string()).optional().describe('Rules to bundle with this persona'),
     }),
     async run(c) {
-      await requireBrainjarDir()
       const name = normalizeSlug(c.args.name, 'persona name')
-      const dest = join(paths.personas, `${name}.md`)
+      const api = await getApi()
 
+      // Check if it already exists
       try {
-        await access(dest)
-        throw new IncurError({
-          code: 'PERSONA_EXISTS',
-          message: `Persona "${name}" already exists.`,
-          hint: 'Choose a different name or edit the existing file.',
-        })
+        await api.get<ApiPersona>(`/api/v1/personas/${name}`)
+        throw createError(ErrorCode.PERSONA_EXISTS, { params: [name] })
       } catch (e) {
-        if (e instanceof IncurError) throw e
+        if (e instanceof IncurError && e.code === ErrorCode.PERSONA_EXISTS) throw e
+        if (e instanceof IncurError && e.code !== ErrorCode.NOT_FOUND) throw e
       }
 
       const rulesList = c.options.rules ?? []
 
-      // Validate rules exist
-      const availableRules = await listAvailableRules()
-      const invalid = rulesList.filter(r => !availableRules.includes(r))
-      if (invalid.length > 0) {
-        throw new IncurError({
-          code: 'RULES_NOT_FOUND',
-          message: `Rules not found: ${invalid.join(', ')}`,
-          hint: `Available rules: ${availableRules.join(', ')}`,
-        })
+      // Validate rules exist on server
+      if (rulesList.length > 0) {
+        const available = await api.get<ApiRuleList>('/api/v1/rules')
+        const availableSlugs = available.rules.map(r => r.slug)
+        const invalid = rulesList.filter(r => !availableSlugs.includes(r))
+        if (invalid.length > 0) {
+          throw createError(ErrorCode.RULES_NOT_FOUND, {
+            message: `Rules not found: ${invalid.join(', ')}`,
+            hint: `Available rules: ${availableSlugs.join(', ')}`,
+          })
+        }
       }
 
-      const lines: string[] = []
-
-      // Frontmatter — always write it (rules default to [default])
-      const effectiveRules = rulesList.length > 0 ? rulesList : ['default']
-      lines.push('---')
-      lines.push('rules:')
-      for (const rule of effectiveRules) {
-        lines.push(`  - ${rule}`)
-      }
-      lines.push('---')
-      lines.push('')
+      const effectiveRules = rulesList
 
+      const lines: string[] = []
       lines.push(`# ${name}`)
       lines.push('')
       if (c.options.description) {
@@ -77,33 +68,85 @@ export const persona = Cli.create('persona', {
       lines.push('')
 
       const content = lines.join('\n')
-      await writeFile(dest, content)
+      await api.put<ApiPersona>(`/api/v1/personas/${name}`, {
+        content,
+        bundled_rules: effectiveRules,
+      })
 
       if (c.agent || c.formatExplicit) {
-        return {
-          created: dest,
-          name,
-          rules: effectiveRules,
-          template: content,
-        }
+        return { created: name, name, rules: effectiveRules, template: content }
       }
 
       return {
-        created: dest,
+        created: name,
         name,
         rules: effectiveRules,
         template: `\n${content}`,
-        next: `Edit ${dest} to fill in your persona, then run \`brainjar persona use ${name}\` to activate.`,
+        next: `Run \`brainjar persona show ${name}\` to view, then \`brainjar persona use ${name}\` to activate.`,
       }
     },
   })
+  .command('update', {
+    description: 'Update a persona\'s content (reads from stdin)',
+    args: z.object({
+      name: z.string().describe('Persona name'),
+    }),
+    options: z.object({
+      rules: z.array(z.string()).optional().describe('Update bundled rules'),
+    }),
+    async run(c) {
+      const name = normalizeSlug(c.args.name, 'persona name')
+      const api = await getApi()
+
+      // Validate it exists and get current data
+      let existing: ApiPersona
+      try {
+        existing = await api.get<ApiPersona>(`/api/v1/personas/${name}`)
+      } catch (e) {
+        if (e instanceof IncurError && e.code === ErrorCode.NOT_FOUND) {
+          throw createError(ErrorCode.PERSONA_NOT_FOUND, { params: [name] })
+        }
+        throw e
+      }
+
+      const chunks: Uint8Array[] = []
+      for await (const chunk of Bun.stdin.stream()) {
+        chunks.push(chunk)
+      }
+      const content = Buffer.concat(chunks).toString().trim()
+
+      // Validate rules if provided
+      const rulesList = c.options.rules
+      if (rulesList && rulesList.length > 0) {
+        const available = await api.get<ApiRuleList>('/api/v1/rules')
+        const availableSlugs = available.rules.map(r => r.slug)
+        const invalid = rulesList.filter(r => !availableSlugs.includes(r))
+        if (invalid.length > 0) {
+          throw createError(ErrorCode.RULES_NOT_FOUND, {
+            message: `Rules not found: ${invalid.join(', ')}`,
+            hint: `Available rules: ${availableSlugs.join(', ')}`,
+          })
+        }
+      }
+
+      await api.put<ApiPersona>(`/api/v1/personas/${name}`, {
+        content: content || existing.content,
+        bundled_rules: rulesList ?? existing.bundled_rules,
+      })
+
+      // Sync if this persona is active
+      const state = await getEffectiveState(api)
+      if (state.persona === name) await sync({ api })
+
+      return { updated: name, rules: rulesList ?? existing.bundled_rules }
+    },
+  })
   .command('list', {
     description: 'List available personas',
     async run() {
-      await requireBrainjarDir()
-      const entries = await readdir(paths.personas).catch(() => [])
-      const personas = entries.filter(f => f.endsWith('.md')).map(f => basename(f, '.md'))
-      return { personas }
+      const api = await getApi()
+      const result = await api.get<ApiPersonaList>('/api/v1/personas')
+      return { personas: result.personas.map(p => p.slug) }
     },
   })
   .command('show', {
@@ -112,148 +155,112 @@ export const persona = Cli.create('persona', {
       name: z.string().optional().describe('Persona name to show (defaults to active persona)'),
     }),
     options: z.object({
-      local: z.boolean().default(false).describe('Show local persona override (if any)'),
+      project: z.boolean().default(false).describe('Show project persona override (if any)'),
       short: z.boolean().default(false).describe('Print only the active persona name'),
     }),
     async run(c) {
-      await requireBrainjarDir()
+      const api = await getApi()
 
       if (c.options.short) {
         if (c.args.name) return c.args.name
-        const global = await readState()
-        const local = await readLocalState()
-        const env = readEnvState()
-        const effective = mergeState(global, local, env)
-        return effective.persona.value ?? 'none'
+        const state = await getEffectiveState(api)
+        return state.persona ?? 'none'
       }
 
-      // If a specific name was given, show that persona directly
       if (c.args.name) {
         const name = normalizeSlug(c.args.name, 'persona name')
         try {
-          const raw = await readFile(join(paths.personas, `${name}.md`), 'utf-8')
-          const frontmatter = parseLayerFrontmatter(raw)
-          const content = stripFrontmatter(raw)
-          const title = content.split('\n').find(l => l.startsWith('# '))?.replace('# ', '') ?? null
-          return { name, title, content, ...frontmatter }
-        } catch {
-          throw new IncurError({
-            code: 'PERSONA_NOT_FOUND',
-            message: `Persona "${name}" not found.`,
-            hint: 'Run `brainjar persona list` to see available personas.',
-          })
+          const p = await api.get<ApiPersona>(`/api/v1/personas/${name}`)
+          return { name, title: p.title, content: p.content, rules: p.bundled_rules }
+        } catch (e) {
+          if (e instanceof IncurError && e.code === ErrorCode.NOT_FOUND) {
+            throw createError(ErrorCode.PERSONA_NOT_FOUND, { params: [name] })
+          }
+          throw e
         }
       }
 
-      if (c.options.local) {
-        const local = await readLocalState()
-        if (!('persona' in local)) return { active: false, scope: 'local', note: 'No local persona override (cascades from global)' }
-        if (local.persona === null) return { active: false, scope: 'local', name: null, note: 'Explicitly unset at local scope' }
+      if (c.options.project) {
+        const state = await api.get<import('../api-types.js').ApiStateOverride>('/api/v1/state/override', {
+          project: basename(process.cwd()),
+        })
+        if (state.persona_slug === undefined) return { active: false, scope: 'project', note: 'No project persona override (cascades from workspace)' }
+        if (state.persona_slug === null) return { active: false, scope: 'project', name: null, note: 'Explicitly unset at project scope' }
         try {
-          const raw = await readFile(join(paths.personas, `${local.persona}.md`), 'utf-8')
-          const frontmatter = parseLayerFrontmatter(raw)
-          const content = stripFrontmatter(raw)
-          const title = content.split('\n').find(l => l.startsWith('# '))?.replace('# ', '') ?? null
-          return { active: true, scope: 'local', name: local.persona, title, content, ...frontmatter }
+          const p = await api.get<ApiPersona>(`/api/v1/personas/${state.persona_slug}`)
+          return { active: true, scope: 'project', name: state.persona_slug, title: p.title, content: p.content, rules: p.bundled_rules }
         } catch {
-          return { active: false, scope: 'local', name: local.persona, error: 'File not found' }
+          return { active: false, scope: 'project', name: state.persona_slug, error: 'Not found on server' }
         }
       }
 
-      const global = await readState()
-      const local = await readLocalState()
-      const env = readEnvState()
-      const effective = mergeState(global, local, env)
-      if (!effective.persona.value) return { active: false }
+      const state = await getEffectiveState(api)
+      if (!state.persona) return { active: false }
       try {
-        const raw = await readFile(join(paths.personas, `${effective.persona.value}.md`), 'utf-8')
-        const frontmatter = parseLayerFrontmatter(raw)
-        const content = stripFrontmatter(raw)
-        const title = content.split('\n').find(l => l.startsWith('# '))?.replace('# ', '') ?? null
-        return { active: true, name: effective.persona.value, scope: effective.persona.scope, title, content, ...frontmatter }
+        const p = await api.get<ApiPersona>(`/api/v1/personas/${state.persona}`)
+        return { active: true, name: state.persona, title: p.title, content: p.content, rules: p.bundled_rules }
       } catch {
-        return { active: false, name: effective.persona.value, error: 'File not found' }
+        return { active: false, name: state.persona, error: 'Not found on server' }
       }
     },
   })
   .command('use', {
     description: 'Activate a persona',
     args: z.object({
-      name: z.string().describe('Persona name (filename without .md in ~/.brainjar/personas/)'),
+      name: z.string().describe('Persona name'),
     }),
     options: z.object({
-      local: z.boolean().default(false).describe('Write to local .claude/CLAUDE.md instead of global'),
+      project: z.boolean().default(false).describe('Apply at project scope'),
     }),
     async run(c) {
-      await requireBrainjarDir()
       const name = normalizeSlug(c.args.name, 'persona name')
-      const source = join(paths.personas, `${name}.md`)
-      let raw: string
+      const api = await getApi()
+
+      // Validate and get bundled rules
+      let personaData: ApiPersona
       try {
-        raw = await readFile(source, 'utf-8')
-      } catch {
-        throw new IncurError({
-          code: 'PERSONA_NOT_FOUND',
-          message: `Persona "${name}" not found.`,
-          hint: 'Run `brainjar persona list` to see available personas.',
-        })
+        personaData = await api.get<ApiPersona>(`/api/v1/personas/${name}`)
+      } catch (e) {
+        if (e instanceof IncurError && e.code === ErrorCode.NOT_FOUND) {
+          throw createError(ErrorCode.PERSONA_NOT_FOUND, { params: [name] })
+        }
+        throw e
       }
 
-      const frontmatter = parseLayerFrontmatter(raw)
+      const bundledRules = personaData.bundled_rules
 
-      if (c.options.local) {
-        await withLocalStateLock(async () => {
-          const local = await readLocalState()
-          local.persona = name
-          if (frontmatter.rules.length > 0) {
-            local.rules = { ...local.rules, add: frontmatter.rules }
-          }
-          await writeLocalState(local)
-          await sync({ local: true })
-        })
-      } else {
-        await withStateLock(async () => {
-          const state = await readState()
-          state.persona = name
-          if (frontmatter.rules.length > 0) state.rules = frontmatter.rules
-          await writeState(state)
-          await sync()
-        })
-      }
+      const mutationOpts = c.options.project
+        ? { project: basename(process.cwd()) }
+        : undefined
+      await putState(api, {
+        persona_slug: name,
+        rule_slugs: bundledRules.length > 0 ? bundledRules : undefined,
+      }, mutationOpts)
+
+      await sync({ api })
+      if (c.options.project) await sync({ api, project: true })
 
-      const result: Record<string, unknown> = { activated: name, local: c.options.local }
-      if (frontmatter.rules.length > 0) result.rules = frontmatter.rules
+      const result: Record<string, unknown> = { activated: name, project: c.options.project }
+      if (bundledRules.length > 0) result.rules = bundledRules
       return result
     },
   })
   .command('drop', {
     description: 'Deactivate the current persona',
     options: z.object({
-      local: z.boolean().default(false).describe('Remove local persona override or deactivate global persona'),
+      project: z.boolean().default(false).describe('Remove project persona override or deactivate workspace persona'),
     }),
     async run(c) {
-      await requireBrainjarDir()
-      if (c.options.local) {
-        await withLocalStateLock(async () => {
-          const local = await readLocalState()
-          delete local.persona
-          await writeLocalState(local)
-          await sync({ local: true })
-        })
-      } else {
-        await withStateLock(async () => {
-          const state = await readState()
-          if (!state.persona) {
-            throw new IncurError({
-              code: 'NO_ACTIVE_PERSONA',
-              message: 'No active persona to deactivate.',
-            })
-          }
-          state.persona = null
-          await writeState(state)
-          await sync()
-        })
-      }
-      return { deactivated: true, local: c.options.local }
+      const api = await getApi()
+
+      const mutationOpts = c.options.project
+        ? { project: basename(process.cwd()) }
+        : undefined
+      await putState(api, { persona_slug: null }, mutationOpts)
+
+      await sync({ api })
+      if (c.options.project) await sync({ api, project: true })
+
+      return { deactivated: true, project: c.options.project }
     },
   })