@brainjar/cli 0.4.0 → 0.4.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@brainjar/cli",
-  "version": "0.4.0",
+  "version": "0.4.1",
   "description": "Shape how your AI thinks — composable soul, persona, and rules for AI agents",
   "type": "module",
   "license": "MIT",

package/src/commands/persona.ts

@@ -86,6 +86,61 @@ export const persona = Cli.create('persona', {
       }
     },
   })
+  .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() {

package/src/commands/rules.ts

@@ -18,7 +18,6 @@ export const rules = Cli.create('rules', {
     }),
     options: z.object({
       description: z.string().optional().describe('One-line description of the rule'),
-      pack: z.boolean().default(false).describe('Create as a rule pack (multiple entries)'),
     }),
     async run(c) {
       const name = normalizeSlug(c.args.name, 'rule name')
@@ -48,18 +47,60 @@ export const rules = Cli.create('rules', {
       })
 
       if (c.agent || c.formatExplicit) {
-        return { created: name, name, pack: c.options.pack, template: scaffold }
+        return { created: name, name, template: scaffold }
       }
 
       return {
         created: name,
         name,
-        pack: c.options.pack,
         template: `\n${scaffold}`,
         next: `Run \`brainjar rules show ${name}\` to view, then \`brainjar rules add ${name}\` to activate.`,
       }
     },
   })
+  .command('update', {
+    description: 'Update a rule\'s content (reads from stdin)',
+    args: z.object({
+      name: z.string().describe('Rule name'),
+    }),
+    async run(c) {
+      const name = normalizeSlug(c.args.name, 'rule name')
+      const api = await getApi()
+
+      // Validate it exists
+      try {
+        await api.get<ApiRule>(`/api/v1/rules/${name}`)
+      } catch (e) {
+        if (e instanceof IncurError && e.code === ErrorCode.NOT_FOUND) {
+          throw createError(ErrorCode.RULE_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()
+
+      if (!content) {
+        throw createError(ErrorCode.MISSING_ARG, {
+          message: 'No content provided. Pipe content via stdin.',
+          hint: `echo "# ${name}\\n..." | brainjar rules update ${name}`,
+        })
+      }
+
+      await api.put<ApiRule>(`/api/v1/rules/${name}`, {
+        entries: [{ name: `${name}.md`, content }],
+      })
+
+      // Sync if this rule is active
+      const state = await getEffectiveState(api)
+      if (state.rules.includes(name)) await sync({ api })
+
+      return { updated: name }
+    },
+  })
   .command('list', {
     description: 'List available and active rules',
     options: z.object({

package/src/commands/soul.ts

@@ -39,6 +39,15 @@ export const soul = Cli.create('soul', {
         lines.push(c.options.description)
         lines.push('')
       }
+      lines.push('## Voice')
+      lines.push('- ')
+      lines.push('')
+      lines.push('## Character')
+      lines.push('- ')
+      lines.push('')
+      lines.push('## Standards')
+      lines.push('- ')
+      lines.push('')
 
       const content = lines.join('\n')
       await api.put<ApiSoul>(`/api/v1/souls/${name}`, { content })
@@ -55,6 +64,47 @@ export const soul = Cli.create('soul', {
       }
     },
   })
+  .command('update', {
+    description: 'Update a soul\'s content (reads from stdin)',
+    args: z.object({
+      name: z.string().describe('Soul name'),
+    }),
+    async run(c) {
+      const name = normalizeSlug(c.args.name, 'soul name')
+      const api = await getApi()
+
+      // Validate it exists
+      try {
+        await api.get<ApiSoul>(`/api/v1/souls/${name}`)
+      } catch (e) {
+        if (e instanceof IncurError && e.code === ErrorCode.NOT_FOUND) {
+          throw createError(ErrorCode.SOUL_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()
+
+      if (!content) {
+        throw createError(ErrorCode.MISSING_ARG, {
+          message: 'No content provided. Pipe content via stdin.',
+          hint: `echo "# ${name}\\n..." | brainjar soul update ${name}`,
+        })
+      }
+
+      await api.put<ApiSoul>(`/api/v1/souls/${name}`, { content })
+
+      // Sync if this soul is active
+      const state = await getEffectiveState(api)
+      if (state.soul === name) await sync({ api })
+
+      return { updated: name }
+    },
+  })
   .command('list', {
     description: 'List available souls',
     async run() {