@brainjar/cli 0.3.0 → 0.4.1

package/src/commands/rules.ts

@@ -1,11 +1,12 @@
 import { Cli, z, Errors } from 'incur'
+import { basename } from 'node:path'
 
 const { IncurError } = Errors
-import { access, readFile, readdir, stat, writeFile, mkdir } from 'node:fs/promises'
-import { join } from 'node:path'
-import { paths } from '../paths.js'
-import { readState, writeState, withStateLock, readLocalState, writeLocalState, withLocalStateLock, readEnvState, mergeState, requireBrainjarDir, 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 { ApiRule, ApiRuleList } from '../api-types.js'
 
 export const rules = Cli.create('rules', {
   description: 'Manage rules — behavioral constraints for the agent',
@@ -13,66 +14,22 @@ export const rules = Cli.create('rules', {
   .command('create', {
     description: 'Create a new rule',
     args: z.object({
-      name: z.string().describe('Rule name (will be used as filename)'),
+      name: z.string().describe('Rule name'),
     }),
     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 (directory of .md files)'),
     }),
     async run(c) {
-      await requireBrainjarDir()
       const name = normalizeSlug(c.args.name, 'rule name')
+      const api = await getApi()
 
-      if (c.options.pack) {
-        const dirPath = join(paths.rules, name)
-        try {
-          await access(dirPath)
-          throw new IncurError({
-            code: 'RULE_EXISTS',
-            message: `Rule "${name}" already exists.`,
-            hint: 'Choose a different name or edit the existing files.',
-          })
-        } catch (e) {
-          if (e instanceof IncurError) throw e
-        }
-
-        await mkdir(dirPath, { recursive: true })
-
-        const scaffold = [
-          `# ${name}`,
-          '',
-          c.options.description ?? 'Describe what this rule enforces and why.',
-          '',
-          '## Constraints',
-          '- ',
-          '',
-        ].join('\n')
-
-        await writeFile(join(dirPath, `${name}.md`), scaffold)
-
-        if (c.agent || c.formatExplicit) {
-          return { created: dirPath, name, pack: true, template: scaffold }
-        }
-
-        return {
-          created: dirPath,
-          name,
-          pack: true,
-          template: `\n${scaffold}`,
-          next: `Edit ${join(dirPath, `${name}.md`)} to define your rule, then run \`brainjar rules add ${name}\` to activate.`,
-        }
-      }
-
-      const dest = join(paths.rules, `${name}.md`)
+      // Check if it already exists
       try {
-        await access(dest)
-        throw new IncurError({
-          code: 'RULE_EXISTS',
-          message: `Rule "${name}" already exists.`,
-          hint: 'Choose a different name or edit the existing file.',
-        })
+        await api.get<ApiRule>(`/api/v1/rules/${name}`)
+        throw createError(ErrorCode.RULE_EXISTS, { params: [name] })
       } catch (e) {
-        if (e instanceof IncurError) throw e
+        if (e instanceof IncurError && e.code === ErrorCode.RULE_EXISTS) throw e
+        if (e instanceof IncurError && e.code !== ErrorCode.NOT_FOUND) throw e
       }
 
       const scaffold = [
@@ -85,44 +42,90 @@ export const rules = Cli.create('rules', {
         '',
       ].join('\n')
 
-      await writeFile(dest, scaffold)
+      await api.put<ApiRule>(`/api/v1/rules/${name}`, {
+        entries: [{ name: `${name}.md`, content: scaffold }],
+      })
 
       if (c.agent || c.formatExplicit) {
-        return { created: dest, name, template: scaffold }
+        return { created: name, name, template: scaffold }
       }
 
       return {
-        created: dest,
+        created: name,
         name,
         template: `\n${scaffold}`,
-        next: `Edit ${dest} to define your rule, then run \`brainjar rules add ${name}\` to activate.`,
+        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({
-      local: z.boolean().default(false).describe('Show local rules delta only'),
+      project: z.boolean().default(false).describe('Show project rules delta only'),
     }),
     async run(c) {
-      await requireBrainjarDir()
+      const api = await getApi()
+      const available = await api.get<ApiRuleList>('/api/v1/rules')
+      const availableSlugs = available.rules.map(r => r.slug)
 
-      if (c.options.local) {
-        const local = await readLocalState()
-        const available = await listAvailableRules()
+      if (c.options.project) {
+        const override = await api.get<import('../api-types.js').ApiStateOverride>('/api/v1/state/override', {
+          project: basename(process.cwd()),
+        })
         return {
-          add: local.rules?.add ?? [],
-          remove: local.rules?.remove ?? [],
-          available,
-          scope: 'local',
+          add: override.rules_to_add ?? [],
+          remove: override.rules_to_remove ?? [],
+          available: availableSlugs,
+          scope: 'project',
         }
       }
 
-      const [global, local, available] = await Promise.all([readState(), readLocalState(), listAvailableRules()])
-      const env = readEnvState()
-      const effective = mergeState(global, local, env)
-      const active = effective.rules.filter(r => !r.scope.startsWith('-')).map(r => r.value)
-      return { active, available, rules: effective.rules }
+      const state = await getEffectiveState(api)
+      const active = state.rules
+      return { active, available: availableSlugs, rules: state.rules }
     },
   })
   .command('show', {
@@ -131,98 +134,52 @@ export const rules = Cli.create('rules', {
       name: z.string().describe('Rule name to show'),
     }),
     async run(c) {
-      await requireBrainjarDir()
       const name = normalizeSlug(c.args.name, 'rule name')
-      const dirPath = join(paths.rules, name)
-      const filePath = join(paths.rules, `${name}.md`)
+      const api = await getApi()
 
-      // Try directory of .md files first
       try {
-        const s = await stat(dirPath)
-        if (s.isDirectory()) {
-          const files = await readdir(dirPath)
-          const mdFiles = files.filter(f => f.endsWith('.md')).sort()
-          const sections: string[] = []
-          for (const file of mdFiles) {
-            const content = await readFile(join(dirPath, file), 'utf-8')
-            sections.push(content.trim())
-          }
-          return { name, content: sections.join('\n\n') }
+        const rule = await api.get<ApiRule>(`/api/v1/rules/${name}`)
+        const content = rule.entries.map(e => e.content.trim()).join('\n\n')
+        return { name, content }
+      } catch (e) {
+        if (e instanceof IncurError && e.code === ErrorCode.NOT_FOUND) {
+          throw createError(ErrorCode.RULE_NOT_FOUND, { params: [name] })
         }
-      } catch {}
-
-      // Try single .md file
-      try {
-        const content = await readFile(filePath, 'utf-8')
-        return { name, content: content.trim() }
-      } catch {}
-
-      throw new IncurError({
-        code: 'RULE_NOT_FOUND',
-        message: `Rule "${name}" not found.`,
-        hint: 'Run `brainjar rules list` to see available rules.',
-      })
+        throw e
+      }
     },
   })
   .command('add', {
     description: 'Activate a rule or rule pack',
     args: z.object({
-      name: z.string().describe('Rule name or directory name in ~/.brainjar/rules/'),
+      name: z.string().describe('Rule name to activate'),
     }),
     options: z.object({
-      local: z.boolean().default(false).describe('Add rule as a local override (delta, not snapshot)'),
+      project: z.boolean().default(false).describe('Add rule at project scope'),
     }),
     async run(c) {
-      await requireBrainjarDir()
       const name = normalizeSlug(c.args.name, 'rule name')
-      // Verify it exists as a directory or .md file
-      const dirPath = join(paths.rules, name)
-      const filePath = join(paths.rules, `${name}.md`)
-      let found = false
+      const api = await getApi()
 
+      // Validate it exists on server
       try {
-        const s = await stat(dirPath)
-        if (s.isDirectory()) found = true
-      } catch {}
-
-      if (!found) {
-        try {
-          await readFile(filePath, 'utf-8')
-          found = true
-        } catch {}
+        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
       }
 
-      if (!found) {
-        throw new IncurError({
-          code: 'RULE_NOT_FOUND',
-          message: `Rule "${name}" not found in ${paths.rules}`,
-          hint: 'Place .md files or directories in ~/.brainjar/rules/',
-        })
-      }
+      const mutationOpts = c.options.project
+        ? { project: basename(process.cwd()) }
+        : undefined
+      await putState(api, { rules_to_add: [name] }, mutationOpts)
 
-      if (c.options.local) {
-        await withLocalStateLock(async () => {
-          const local = await readLocalState()
-          const adds = local.rules?.add ?? []
-          if (!adds.includes(name)) adds.push(name)
-          // Also remove from local removes if present
-          const removes = (local.rules?.remove ?? []).filter(r => r !== name)
-          local.rules = { add: adds, ...(removes.length ? { remove: removes } : {}) }
-          await writeLocalState(local)
-          await sync({ local: true })
-        })
-      } else {
-        await withStateLock(async () => {
-          const state = await readState()
-          if (!state.rules.includes(name)) {
-            state.rules.push(name)
-            await writeState(state)
-          }
-          await sync()
-        })
-      }
+      await sync({ api })
+      if (c.options.project) await sync({ api, project: true })
 
-      return { activated: name, local: c.options.local }
+      return { activated: name, project: c.options.project }
     },
   })
   .command('remove', {
@@ -231,39 +188,20 @@ export const rules = Cli.create('rules', {
       name: z.string().describe('Rule name to remove'),
     }),
     options: z.object({
-      local: z.boolean().default(false).describe('Remove rule as a local override (delta, not snapshot)'),
+      project: z.boolean().default(false).describe('Remove rule at project scope'),
     }),
     async run(c) {
-      await requireBrainjarDir()
       const name = normalizeSlug(c.args.name, 'rule name')
+      const api = await getApi()
 
-      if (c.options.local) {
-        await withLocalStateLock(async () => {
-          const local = await readLocalState()
-          const removes = local.rules?.remove ?? []
-          if (!removes.includes(name)) removes.push(name)
-          // Also remove from local adds if present
-          const adds = (local.rules?.add ?? []).filter(r => r !== name)
-          local.rules = { ...(adds.length ? { add: adds } : {}), remove: removes }
-          await writeLocalState(local)
-          await sync({ local: true })
-        })
-      } else {
-        await withStateLock(async () => {
-          const state = await readState()
-          if (!state.rules.includes(name)) {
-            throw new IncurError({
-              code: 'RULE_NOT_ACTIVE',
-              message: `Rule "${name}" is not active.`,
-              hint: 'Run `brainjar rules list` to see active rules.',
-            })
-          }
-          state.rules = state.rules.filter(r => r !== name)
-          await writeState(state)
-          await sync()
-        })
-      }
+      const mutationOpts = c.options.project
+        ? { project: basename(process.cwd()) }
+        : undefined
+      await putState(api, { rules_to_remove: [name] }, mutationOpts)
+
+      await sync({ api })
+      if (c.options.project) await sync({ api, project: true })
 
-      return { removed: name, local: c.options.local }
+      return { removed: name, project: c.options.project }
     },
   })

package/src/commands/server.ts

@@ -0,0 +1,212 @@
+import { Cli, z, Errors } from 'incur'
+import { spawn } from 'node:child_process'
+import {
+  healthCheck,
+  start,
+  stop,
+  status as daemonStatus,
+  ensureRunning,
+  readLogFile,
+  upgradeServer,
+} from '../daemon.js'
+import { readConfig, writeConfig } from '../config.js'
+import { getApi } from '../client.js'
+import { sync } from '../sync.js'
+
+const { IncurError } = Errors
+import { ErrorCode, createError } from '../errors.js'
+
+function assertLocalMode(config: { server: { mode: string } }, action: string) {
+  if (config.server.mode === 'remote') {
+    throw createError(ErrorCode.INVALID_MODE, {
+      message: `Server is in remote mode. Cannot ${action}.`,
+    })
+  }
+}
+
+const statusCmd = Cli.create('status', {
+  description: 'Show server status',
+  async run() {
+    const s = await daemonStatus()
+    const health = await healthCheck({ timeout: 2000 })
+    return {
+      mode: s.mode,
+      url: s.url,
+      healthy: s.healthy,
+      running: s.running,
+      pid: s.pid,
+      latencyMs: health.latencyMs ?? null,
+    }
+  },
+})
+
+const startCmd = Cli.create('start', {
+  description: 'Start the local server daemon',
+  async run() {
+    const config = await readConfig()
+    assertLocalMode(config, 'start')
+
+    const health = await healthCheck({ timeout: 2000 })
+    if (health.healthy) {
+      const s = await daemonStatus()
+      return { already_running: true, pid: s.pid, url: config.server.url }
+    }
+
+    const { pid } = await start()
+
+    const deadline = Date.now() + 10_000
+    while (Date.now() < deadline) {
+      await new Promise(r => setTimeout(r, 200))
+      const check = await healthCheck({ timeout: 2000 })
+      if (check.healthy) return { started: true, pid, url: config.server.url }
+    }
+
+    throw createError(ErrorCode.SERVER_START_FAILED, {
+      message: 'Server started but failed health check after 10s.',
+    })
+  },
+})
+
+const stopCmd = Cli.create('stop', {
+  description: 'Stop the local server daemon',
+  async run() {
+    const config = await readConfig()
+    assertLocalMode(config, 'stop')
+
+    const result = await stop()
+    if (!result.stopped) {
+      return { stopped: false, reason: 'not running' }
+    }
+    return { stopped: true }
+  },
+})
+
+const logsCmd = Cli.create('logs', {
+  description: 'Show server logs',
+  options: z.object({
+    lines: z.number().default(50).describe('Number of lines to show'),
+    follow: z.boolean().default(false).describe('Follow log output'),
+  }),
+  async run(c) {
+    const config = await readConfig()
+
+    if (c.options.follow) {
+      const child = spawn('tail', ['-f', '-n', String(c.options.lines), config.server.log_file], {
+        stdio: 'inherit',
+      })
+      await new Promise<void>((resolve) => {
+        child.on('close', () => resolve())
+      })
+      return
+    }
+
+    const content = await readLogFile({ lines: c.options.lines })
+    return content || 'No logs found.'
+  },
+})
+
+const localCmd = Cli.create('local', {
+  description: 'Switch to managed local server',
+  async run() {
+    const config = await readConfig()
+    config.server.url = 'http://localhost:7742'
+    config.server.mode = 'local'
+    await writeConfig(config)
+
+    await ensureRunning()
+
+    const api = await getApi()
+
+    // 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
+    }
+
+    await sync({ api })
+
+    return { mode: 'local', url: config.server.url }
+  },
+})
+
+const remoteCmd = Cli.create('remote', {
+  description: 'Switch to a remote server',
+  args: z.object({
+    url: z.string().describe('Remote server URL'),
+  }),
+  async run(c) {
+    const url = c.args.url.replace(/\/$/, '')
+
+    const health = await healthCheck({ url, timeout: 5000 })
+    if (!health.healthy) {
+      throw createError(ErrorCode.SERVER_UNREACHABLE, { params: [url] })
+    }
+
+    const config = await readConfig()
+    config.server.url = url
+    config.server.mode = 'remote'
+    await writeConfig(config)
+
+    const api = await getApi()
+
+    // 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
+    }
+
+    await sync({ api })
+
+    return { mode: 'remote', url }
+  },
+})
+
+const upgradeCmd = Cli.create('upgrade', {
+  description: 'Upgrade the server binary to the latest version',
+  async run() {
+    const config = await readConfig()
+    assertLocalMode(config, 'upgrade')
+
+    // Stop server if running before replacing binary
+    const s = await daemonStatus()
+    const wasRunning = s.running
+
+    if (wasRunning) {
+      await stop()
+    }
+
+    const result = await upgradeServer()
+
+    if (result.alreadyLatest) {
+      if (wasRunning) await start()
+      return { upgraded: false, version: result.version, message: 'Already on latest version' }
+    }
+
+    // Restart if it was running
+    if (wasRunning) {
+      const { pid } = await start()
+      const deadline = Date.now() + 10_000
+      while (Date.now() < deadline) {
+        await new Promise(r => setTimeout(r, 200))
+        const check = await healthCheck({ timeout: 2000 })
+        if (check.healthy) return { upgraded: true, version: result.version, pid, restarted: true }
+      }
+      return { upgraded: true, version: result.version, restarted: false, warning: 'Server upgraded but failed health check after restart' }
+    }
+
+    return { upgraded: true, version: result.version }
+  },
+})
+
+export const server = Cli.create('server', {
+  description: 'Manage the brainjar server',
+})
+  .command(statusCmd)
+  .command(startCmd)
+  .command(stopCmd)
+  .command(logsCmd)
+  .command(localCmd)
+  .command(remoteCmd)
+  .command(upgradeCmd)