@brainjar/cli 0.2.3 → 0.4.0

package/src/sync.ts

@@ -1,57 +1,19 @@
-import { readFile, writeFile, copyFile, mkdir, access } from 'node:fs/promises'
-import { join } from 'node:path'
-import { type Backend, getBackendConfig, paths } from './paths.js'
-import { type State, readState, readLocalState, readEnvState, mergeState, requireBrainjarDir, stripFrontmatter, resolveRuleContent } from './state.js'
+import { readFile, writeFile, copyFile, mkdir } from 'node:fs/promises'
+import { type Backend, getBackendConfig } from './paths.js'
+import { getEffectiveState } from './state.js'
+import { getApi, type BrainjarClient } from './client.js'
+import type { ApiEffectiveState, ApiSoul, ApiPersona, ApiRule } from './api-types.js'
 
 export const MARKER_START = '<!-- brainjar:start -->'
 export const MARKER_END = '<!-- brainjar:end -->'
 
 export interface SyncOptions {
   backend?: Backend
-  local?: boolean
-  envOverrides?: Record<string, string>
+  project?: boolean
+  api?: BrainjarClient
 }
 
-async function inlineSoul(name: string, sections: string[]) {
-  const raw = await readFile(join(paths.souls, `${name}.md`), 'utf-8')
-  const content = stripFrontmatter(raw)
-  sections.push('')
-  sections.push('## Soul')
-  sections.push('')
-  sections.push(content)
-}
-
-async function inlinePersona(name: string, sections: string[]) {
-  const raw = await readFile(join(paths.personas, `${name}.md`), 'utf-8')
-  const content = stripFrontmatter(raw)
-  sections.push('')
-  sections.push('## Persona')
-  sections.push('')
-  sections.push(content)
-}
-
-async function inlineRules(rules: string[], sections: string[], warnings: string[]) {
-  for (const rule of rules) {
-    const contents = await resolveRuleContent(rule, warnings)
-    for (const content of contents) {
-      sections.push('')
-      sections.push(content)
-    }
-  }
-}
-
-async function inlineIdentity(name: string, sections: string[]) {
-  try {
-    await access(join(paths.identities, `${name}.yaml`))
-    sections.push('')
-    sections.push('## Identity')
-    sections.push('')
-    sections.push(`See ~/.brainjar/identities/${name}.yaml for active identity.`)
-    sections.push('Manage with `brainjar identity [list|use|show]`.')
-  } catch {}
-}
-
-/** Extract content before, inside, and after brainjar markers. */
+/** Extract content before and after brainjar markers. */
 function parseMarkers(content: string): { before: string; after: string } | null {
   const startIdx = content.indexOf(MARKER_START)
   const endIdx = content.indexOf(MARKER_END)
@@ -62,18 +24,59 @@ function parseMarkers(content: string): { before: string; after: string } | null
   return { before, after }
 }
 
-export async function sync(options?: Backend | SyncOptions) {
-  await requireBrainjarDir()
+/** Fetch content from server and assemble the brainjar markdown sections. */
+async function assembleFromServer(api: BrainjarClient, state: ApiEffectiveState): Promise<{ sections: string[]; warnings: string[] }> {
+  const sections: string[] = []
+  const warnings: string[] = []
 
-  // Normalize legacy call signature: sync('claude') → sync({ backend: 'claude' })
-  const opts: SyncOptions = typeof options === 'string' ? { backend: options } : options ?? {}
+  if (state.soul) {
+    try {
+      const soul = await api.get<ApiSoul>(`/api/v1/souls/${state.soul}`)
+      sections.push('')
+      sections.push('## Soul')
+      sections.push('')
+      sections.push(soul.content.trim())
+    } catch {
+      warnings.push(`Could not fetch soul "${state.soul}"`)
+    }
+  }
 
-  const globalState = await readState()
-  const backend: Backend = opts.backend ?? (globalState.backend as Backend) ?? 'claude'
-  const config = getBackendConfig(backend, { local: opts.local })
+  if (state.persona) {
+    try {
+      const persona = await api.get<ApiPersona>(`/api/v1/personas/${state.persona}`)
+      sections.push('')
+      sections.push('## Persona')
+      sections.push('')
+      sections.push(persona.content.trim())
+    } catch {
+      warnings.push(`Could not fetch persona "${state.persona}"`)
+    }
+  }
 
-  const envState = readEnvState(opts.envOverrides)
-  const warnings: string[] = []
+  for (const ruleSlug of state.rules) {
+    try {
+      const ruleData = await api.get<ApiRule>(`/api/v1/rules/${ruleSlug}`)
+      for (const entry of ruleData.entries) {
+        sections.push('')
+        sections.push(entry.content.trim())
+      }
+    } catch {
+      warnings.push(`Could not fetch rule "${ruleSlug}"`)
+    }
+  }
+
+  return { sections, warnings }
+}
+
+export async function sync(options?: SyncOptions) {
+  const opts = options ?? {}
+  const api = opts.api ?? await getApi()
+
+  const state = await getEffectiveState(api)
+  const backend: Backend = opts.backend ?? 'claude'
+  const config = getBackendConfig(backend, { local: opts.project })
+
+  const { sections, warnings } = await assembleFromServer(api, state)
 
   // Read existing config file
   let existingContent: string | null = null
@@ -92,46 +95,8 @@ export async function sync(options?: Backend | SyncOptions) {
     }
   }
 
-  // Build the brainjar section content
-  const sections: string[] = []
-
-  if (opts.local) {
-    // Local mode: read local state + env, only write overridden layers.
-    // Everything else falls back to the global config (Claude Code merges both files).
-    const localState = await readLocalState()
-    const effective = mergeState(globalState, localState, envState)
-
-    if ('soul' in localState && effective.soul.value) {
-      await inlineSoul(effective.soul.value, sections)
-    }
-    if ('persona' in localState && effective.persona.value) {
-      await inlinePersona(effective.persona.value, sections)
-    }
-    if (localState.rules) {
-      // Inline the effective rules that are active (not removed)
-      const activeRules = effective.rules
-        .filter(r => !r.scope.startsWith('-'))
-        .map(r => r.value)
-      // But only write rules section if local state has rules overrides
-      await inlineRules(activeRules, sections, warnings)
-    }
-    if ('identity' in localState && effective.identity.value) {
-      await inlineIdentity(effective.identity.value, sections)
-    }
-  } else {
-    // Global mode: apply env overrides on top of global state, write all layers
-    const effective = mergeState(globalState, {}, envState)
-    const effectiveSoul = effective.soul.value
-    const effectivePersona = effective.persona.value
-    const effectiveRules = effective.rules.filter(r => !r.scope.startsWith('-')).map(r => r.value)
-    const effectiveIdentity = effective.identity.value
-
-    if (effectiveSoul) await inlineSoul(effectiveSoul, sections)
-    if (effectivePersona) await inlinePersona(effectivePersona, sections)
-    await inlineRules(effectiveRules, sections, warnings)
-    if (effectiveIdentity) await inlineIdentity(effectiveIdentity, sections)
-
-    // Local Overrides note (only for global config)
+  // Add project-level overrides note for global config
+  if (!opts.project) {
     sections.push('')
     sections.push('## Project-Level Overrides')
     sections.push('')
@@ -152,8 +117,6 @@ export async function sync(options?: Backend | SyncOptions) {
   const parsed = existingContent ? parseMarkers(existingContent) : null
 
   if (parsed) {
-    // Existing file with markers — replace the brainjar section, preserve the rest
-    // Discard legacy brainjar content that ended up outside markers during migration
     const before = parsed.before
     const after = parsed.after?.includes('# Managed by brainjar') ? '' : parsed.after
     const parts: string[] = []
@@ -162,16 +125,12 @@ export async function sync(options?: Backend | SyncOptions) {
     if (after) parts.push('', after)
     output = parts.join('\n')
   } else if (existingContent && !existingContent.includes(MARKER_START)) {
-    // Existing file without markers (first sync)
     if (existingContent.includes('# Managed by brainjar')) {
-      // Legacy brainjar-managed file — replace entirely
       output = brainjarBlock + '\n'
     } else {
-      // User-owned file — prepend brainjar section, preserve user content
       output = brainjarBlock + '\n\n' + existingContent
     }
   } else {
-    // No existing file
     output = brainjarBlock + '\n'
   }
 
@@ -181,7 +140,7 @@ export async function sync(options?: Backend | SyncOptions) {
   return {
     backend,
     written: config.configFile,
-    local: opts.local ?? false,
+    project: opts.project ?? false,
     ...(warnings.length ? { warnings } : {}),
   }
 }

package/src/version-check.ts

@@ -0,0 +1,137 @@
+import { readFile, writeFile, mkdir } from 'node:fs/promises'
+import { join } from 'node:path'
+import { getBrainjarDir } from './paths.js'
+import { fetchLatestVersion, DIST_BASE } from './daemon.js'
+
+const CHECK_INTERVAL_MS = 60 * 60 * 1000 // 1 hour
+const NPM_REGISTRY = 'https://registry.npmjs.org'
+
+interface VersionCache {
+  checkedAt: number
+  cli?: string
+  server?: string
+}
+
+function cachePath(): string {
+  return join(getBrainjarDir(), 'version-cache.json')
+}
+
+export function installedVersionPath(): string {
+  return join(getBrainjarDir(), 'server-version')
+}
+
+/** Read the installed server version, or null if not tracked. */
+export async function getInstalledServerVersion(): Promise<string | null> {
+  try {
+    return (await readFile(installedVersionPath(), 'utf-8')).trim()
+  } catch {
+    return null
+  }
+}
+
+/** Write the installed server version after a successful download. */
+export async function setInstalledServerVersion(version: string): Promise<void> {
+  await mkdir(getBrainjarDir(), { recursive: true })
+  await writeFile(installedVersionPath(), version)
+}
+
+/** Read the cached version check result. */
+async function readCache(): Promise<VersionCache | null> {
+  try {
+    const raw = await readFile(cachePath(), 'utf-8')
+    return JSON.parse(raw) as VersionCache
+  } catch {
+    return null
+  }
+}
+
+/** Write the version check cache. */
+async function writeCache(cache: VersionCache): Promise<void> {
+  await mkdir(getBrainjarDir(), { recursive: true })
+  await writeFile(cachePath(), JSON.stringify(cache))
+}
+
+/** Fetch the latest CLI version from npm registry. */
+async function fetchLatestCliVersion(): Promise<string | null> {
+  try {
+    const response = await fetch(`${NPM_REGISTRY}/-/package/@brainjar/cli/dist-tags`, {
+      signal: AbortSignal.timeout(3000),
+    })
+    if (!response.ok) return null
+    const tags = (await response.json()) as Record<string, string>
+    return tags.latest ?? null
+  } catch {
+    return null
+  }
+}
+
+export interface UpdateInfo {
+  cli?: { current: string; latest: string }
+  server?: { current: string; latest: string }
+}
+
+/**
+ * Check for available updates. Results are cached for 1 hour.
+ * Never throws — returns null on any failure.
+ */
+export async function checkForUpdates(currentCliVersion: string): Promise<UpdateInfo | null> {
+  try {
+    const cache = await readCache()
+    const now = Date.now()
+
+    let latestCli: string | undefined
+    let latestServer: string | undefined
+
+    if (cache && (now - cache.checkedAt) < CHECK_INTERVAL_MS) {
+      latestCli = cache.cli
+      latestServer = cache.server
+    } else {
+      const [cli, server] = await Promise.all([
+        fetchLatestCliVersion(),
+        fetchLatestVersion(DIST_BASE).catch(() => null),
+      ])
+
+      latestCli = cli ?? undefined
+      latestServer = server ?? undefined
+
+      await writeCache({ checkedAt: now, cli: latestCli, server: latestServer }).catch(() => {})
+    }
+
+    const info: UpdateInfo = {}
+
+    if (latestCli && latestCli !== currentCliVersion) {
+      info.cli = { current: currentCliVersion, latest: latestCli }
+    }
+
+    const installedServer = await getInstalledServerVersion()
+    if (latestServer && installedServer && latestServer !== installedServer) {
+      info.server = { current: installedServer, latest: latestServer }
+    }
+
+    if (info.cli || info.server) return info
+    return null
+  } catch {
+    return null
+  }
+}
+
+/**
+ * Render update banner text. Returns undefined if no updates available.
+ * Ready to wire into incur's `banner` option.
+ */
+export async function renderUpdateBanner(currentCliVersion: string): Promise<string | undefined> {
+  const updates = await checkForUpdates(currentCliVersion)
+  if (!updates) return undefined
+
+  const lines: string[] = []
+
+  if (updates.cli) {
+    lines.push(`  ⬆ brainjar ${updates.cli.latest} available (current: ${updates.cli.current}) — npm update -g @brainjar/cli`)
+  }
+
+  if (updates.server) {
+    lines.push(`  ⬆ server ${updates.server.latest} available (current: ${updates.server.current}) — brainjar server upgrade`)
+  }
+
+  return lines.length > 0 ? lines.join('\n') : undefined
+}

package/src/brain.ts

@@ -1,69 +0,0 @@
-import { Errors } from 'incur'
-import { readFile } from 'node:fs/promises'
-import { join } from 'node:path'
-import { parse as parseYaml } from 'yaml'
-import { paths } from './paths.js'
-import { normalizeSlug } from './state.js'
-
-const { IncurError } = Errors
-
-/** Brain YAML schema: soul + persona + rules */
-export interface BrainConfig {
-  soul: string
-  persona: string
-  rules: string[]
-}
-
-/** Read and validate a brain YAML file. */
-export async function readBrain(name: string): Promise<BrainConfig> {
-  const slug = normalizeSlug(name, 'brain name')
-  const file = join(paths.brains, `${slug}.yaml`)
-
-  let raw: string
-  try {
-    raw = await readFile(file, 'utf-8')
-  } catch {
-    throw new IncurError({
-      code: 'BRAIN_NOT_FOUND',
-      message: `Brain "${slug}" not found.`,
-      hint: 'Run `brainjar brain list` to see available brains.',
-    })
-  }
-
-  let parsed: unknown
-  try {
-    parsed = parseYaml(raw)
-  } catch (e) {
-    throw new IncurError({
-      code: 'BRAIN_CORRUPT',
-      message: `Brain "${slug}" has invalid YAML: ${(e as Error).message}`,
-    })
-  }
-
-  if (!parsed || typeof parsed !== 'object') {
-    throw new IncurError({
-      code: 'BRAIN_CORRUPT',
-      message: `Brain "${slug}" is empty or invalid.`,
-    })
-  }
-
-  const p = parsed as Record<string, unknown>
-
-  if (typeof p.soul !== 'string' || !p.soul) {
-    throw new IncurError({
-      code: 'BRAIN_INVALID',
-      message: `Brain "${slug}" is missing required field "soul".`,
-    })
-  }
-
-  if (typeof p.persona !== 'string' || !p.persona) {
-    throw new IncurError({
-      code: 'BRAIN_INVALID',
-      message: `Brain "${slug}" is missing required field "persona".`,
-    })
-  }
-
-  const rules = Array.isArray(p.rules) ? p.rules.map(String) : []
-
-  return { soul: p.soul, persona: p.persona, rules }
-}

package/src/commands/identity.ts

@@ -1,276 +0,0 @@
-import { Cli, z, Errors } from 'incur'
-import { stringify as stringifyYaml } from 'yaml'
-
-const { IncurError } = Errors
-import { readdir, readFile, writeFile, mkdir, rm } from 'node:fs/promises'
-import { join, basename } from 'node:path'
-import { paths } from '../paths.js'
-import { readState, writeState, withStateLock, readLocalState, writeLocalState, withLocalStateLock, readEnvState, mergeState, loadIdentity, parseIdentity, requireBrainjarDir, normalizeSlug } from '../state.js'
-import { getEngine } from '../engines/index.js'
-import { sync } from '../sync.js'
-
-function redactSession(status: Record<string, unknown>) {
-  const { session: _, ...safe } = status as any
-  return safe
-}
-
-async function requireActiveIdentity() {
-  await requireBrainjarDir()
-  const state = await readState()
-  if (!state.identity) {
-    throw new IncurError({
-      code: 'NO_ACTIVE_IDENTITY',
-      message: 'No active identity.',
-      hint: 'Run `brainjar identity use <slug>` to activate one.',
-    })
-  }
-  return loadIdentity(state.identity)
-}
-
-function requireEngine(engineName: string | undefined) {
-  if (!engineName) {
-    throw new IncurError({
-      code: 'NO_ENGINE',
-      message: 'Active identity has no engine configured.',
-    })
-  }
-  const engine = getEngine(engineName)
-  if (!engine) {
-    throw new IncurError({
-      code: 'UNKNOWN_ENGINE',
-      message: `Unknown engine: ${engineName}`,
-      hint: 'Supported engines: bitwarden',
-    })
-  }
-  return engine
-}
-
-export const identity = Cli.create('identity', {
-  description: 'Manage digital identity — one active at a time',
-})
-  .command('create', {
-    description: 'Create a new identity',
-    args: z.object({
-      slug: z.string().describe('Identity slug (e.g. personal, work)'),
-    }),
-    options: z.object({
-      name: z.string().describe('Full display name'),
-      email: z.string().describe('Email address'),
-      engine: z.literal('bitwarden').default('bitwarden').describe('Credential engine'),
-    }),
-    async run(c) {
-      await requireBrainjarDir()
-      const slug = normalizeSlug(c.args.slug, 'identity slug')
-      await mkdir(paths.identities, { recursive: true })
-
-      const content = stringifyYaml({ name: c.options.name, email: c.options.email, engine: c.options.engine })
-
-      const filePath = join(paths.identities, `${slug}.yaml`)
-      await writeFile(filePath, content)
-
-      return {
-        created: filePath,
-        identity: { slug, name: c.options.name, email: c.options.email, engine: c.options.engine },
-        next: `Run \`brainjar identity use ${slug}\` to activate.`,
-      }
-    },
-  })
-  .command('list', {
-    description: 'List available identities',
-    async run() {
-      const entries = await readdir(paths.identities).catch(() => [])
-      const identities = []
-
-      for (const file of entries.filter(f => f.endsWith('.yaml'))) {
-        const slug = basename(file, '.yaml')
-        const content = await readFile(join(paths.identities, file), 'utf-8')
-        identities.push({ slug, ...parseIdentity(content) })
-      }
-
-      return { identities }
-    },
-  })
-  .command('show', {
-    description: 'Show the active identity',
-    options: z.object({
-      local: z.boolean().default(false).describe('Show local identity override (if any)'),
-      short: z.boolean().default(false).describe('Print only the active identity slug'),
-    }),
-    async run(c) {
-      if (c.options.short) {
-        const global = await readState()
-        const local = await readLocalState()
-        const env = readEnvState()
-        const effective = mergeState(global, local, env)
-        return effective.identity.value ?? 'none'
-      }
-
-      if (c.options.local) {
-        const local = await readLocalState()
-        if (!('identity' in local)) return { active: false, scope: 'local', note: 'No local identity override (cascades from global)' }
-        if (local.identity === null) return { active: false, scope: 'local', slug: null, note: 'Explicitly unset at local scope' }
-        try {
-          const content = await readFile(join(paths.identities, `${local.identity}.yaml`), 'utf-8')
-          return { active: true, scope: 'local', slug: local.identity, ...parseIdentity(content) }
-        } catch {
-          return { active: false, scope: 'local', slug: local.identity, error: 'File not found' }
-        }
-      }
-
-      const global = await readState()
-      const local = await readLocalState()
-      const env = readEnvState()
-      const effective = mergeState(global, local, env)
-      if (!effective.identity.value) return { active: false }
-      try {
-        const content = await readFile(join(paths.identities, `${effective.identity.value}.yaml`), 'utf-8')
-        return { active: true, slug: effective.identity.value, scope: effective.identity.scope, ...parseIdentity(content) }
-      } catch {
-        return { active: false, slug: effective.identity.value, error: 'File not found' }
-      }
-    },
-  })
-  .command('use', {
-    description: 'Activate an identity',
-    args: z.object({
-      slug: z.string().describe('Identity slug to activate'),
-    }),
-    options: z.object({
-      local: z.boolean().default(false).describe('Write to local .claude/CLAUDE.md instead of global'),
-    }),
-    async run(c) {
-      await requireBrainjarDir()
-      const slug = normalizeSlug(c.args.slug, 'identity slug')
-      const source = join(paths.identities, `${slug}.yaml`)
-      try {
-        await readFile(source, 'utf-8')
-      } catch {
-        throw new IncurError({
-          code: 'IDENTITY_NOT_FOUND',
-          message: `Identity "${slug}" not found.`,
-          hint: 'Run `brainjar identity list` to see available identities.',
-        })
-      }
-
-      if (c.options.local) {
-        await withLocalStateLock(async () => {
-          const local = await readLocalState()
-          local.identity = slug
-          await writeLocalState(local)
-          await sync({ local: true })
-        })
-      } else {
-        await withStateLock(async () => {
-          const state = await readState()
-          state.identity = slug
-          await writeState(state)
-          await sync()
-        })
-      }
-
-      return { activated: slug, local: c.options.local }
-    },
-  })
-  .command('drop', {
-    description: 'Deactivate the current identity',
-    options: z.object({
-      local: z.boolean().default(false).describe('Remove local identity override or deactivate global identity'),
-    }),
-    async run(c) {
-      await requireBrainjarDir()
-      if (c.options.local) {
-        await withLocalStateLock(async () => {
-          const local = await readLocalState()
-          delete local.identity
-          await writeLocalState(local)
-          await sync({ local: true })
-        })
-      } else {
-        await withStateLock(async () => {
-          const state = await readState()
-          if (!state.identity) {
-            throw new IncurError({
-              code: 'NO_ACTIVE_IDENTITY',
-              message: 'No active identity to deactivate.',
-            })
-          }
-          state.identity = null
-          await writeState(state)
-          await sync()
-        })
-      }
-      return { deactivated: true, local: c.options.local }
-    },
-  })
-  .command('unlock', {
-    description: 'Store the credential engine session token',
-    args: z.object({
-      session: z.string().optional().describe('Session token (reads from stdin if omitted)'),
-    }),
-    async run(c) {
-      let session = c.args.session
-      if (!session) {
-        if (process.stdin.isTTY) {
-          throw new IncurError({
-            code: 'NO_SESSION',
-            message: 'No session token provided.',
-            hint: 'Pipe it in: bw unlock --raw | brainjar identity unlock',
-          })
-        }
-        let data = ''
-        for await (const chunk of process.stdin) {
-          data += typeof chunk === 'string' ? chunk : chunk.toString('utf-8')
-        }
-        session = data.trim()
-      }
-      if (!session) {
-        throw new IncurError({
-          code: 'EMPTY_SESSION',
-          message: 'Session token is empty.',
-        })
-      }
-      await writeFile(paths.session, session, { mode: 0o600 })
-      return { unlocked: true, stored: paths.session }
-    },
-  })
-  .command('get', {
-    description: 'Retrieve a credential from the active identity engine',
-    args: z.object({
-      item: z.string().describe('Item name or ID to retrieve from the vault'),
-    }),
-    async run(c) {
-      const { engine: engineName } = await requireActiveIdentity()
-      const engine = requireEngine(engineName)
-
-      const status = await engine.status()
-      if (status.state !== 'unlocked') {
-        throw new IncurError({
-          code: 'ENGINE_LOCKED',
-          message: 'Credential engine is not unlocked.',
-          hint: 'operator_action' in status ? status.operator_action : undefined,
-          retryable: true,
-        })
-      }
-
-      return engine.get(c.args.item, status.session)
-    },
-  })
-  .command('status', {
-    description: 'Check if the credential engine session is active',
-    async run() {
-      const { name, email, engine: engineName } = await requireActiveIdentity()
-      const engine = requireEngine(engineName)
-      const engineStatus = await engine.status()
-      return { identity: { name, email, engine: engineName }, ...redactSession(engineStatus) }
-    },
-  })
-  .command('lock', {
-    description: 'Lock the credential engine session',
-    async run() {
-      const { engine: engineName } = await requireActiveIdentity()
-      const engine = requireEngine(engineName)
-      await engine.lock()
-      await rm(paths.session, { force: true })
-      return { locked: true }
-    },
-  })