@brainjar/cli 0.3.0 → 0.4.0

package/src/sync.ts

@@ -1,46 +1,19 @@
 import { readFile, writeFile, copyFile, mkdir } 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 { 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)
-    }
-  }
-}
-
-/** 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)
@@ -51,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
@@ -81,41 +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)
-    }
-  } 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)
-
-    if (effectiveSoul) await inlineSoul(effectiveSoul, sections)
-    if (effectivePersona) await inlinePersona(effectivePersona, sections)
-    await inlineRules(effectiveRules, sections, warnings)
-
-    // 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('')
@@ -136,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[] = []
@@ -146,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'
   }
 
@@ -165,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/hooks.test.ts

@@ -1,132 +0,0 @@
-import { describe, test, expect, beforeEach, afterEach } from 'bun:test'
-import { readFile, rm, mkdir, writeFile } from 'node:fs/promises'
-import { join } from 'node:path'
-import { installHooks, removeHooks, getHooksStatus } from './hooks.js'
-
-const TEST_HOME = join(import.meta.dir, '..', '.test-home-hooks')
-const SETTINGS_PATH = join(TEST_HOME, '.claude', 'settings.json')
-
-beforeEach(async () => {
-  process.env.BRAINJAR_TEST_HOME = TEST_HOME
-  await mkdir(join(TEST_HOME, '.claude'), { recursive: true })
-})
-
-afterEach(async () => {
-  delete process.env.BRAINJAR_TEST_HOME
-  await rm(TEST_HOME, { recursive: true, force: true })
-})
-
-describe('hooks install', () => {
-  test('creates hooks in empty settings', async () => {
-    const result = await installHooks()
-    expect(result.installed).toContain('SessionStart')
-
-    const settings = JSON.parse(await readFile(SETTINGS_PATH, 'utf-8'))
-    expect(settings.hooks.SessionStart).toHaveLength(1)
-    expect(settings.hooks.SessionStart[0].matcher).toBe('startup')
-    expect(settings.hooks.SessionStart[0].hooks[0].command).toBe('brainjar sync --quiet')
-    expect(settings.hooks.SessionStart[0].hooks[0]._brainjar).toBe(true)
-  })
-
-  test('preserves existing settings', async () => {
-    await writeFile(SETTINGS_PATH, JSON.stringify({
-      statusLine: { type: 'command', command: 'echo hi' },
-      enabledPlugins: { foo: true },
-    }))
-
-    await installHooks()
-
-    const settings = JSON.parse(await readFile(SETTINGS_PATH, 'utf-8'))
-    expect(settings.statusLine.command).toBe('echo hi')
-    expect(settings.enabledPlugins.foo).toBe(true)
-    expect(settings.hooks.SessionStart).toHaveLength(1)
-  })
-
-  test('preserves existing non-brainjar hooks', async () => {
-    await writeFile(SETTINGS_PATH, JSON.stringify({
-      hooks: {
-        SessionStart: [
-          { matcher: 'startup', hooks: [{ type: 'command', command: 'echo hello' }] },
-        ],
-        PreToolUse: [
-          { matcher: 'Edit', hooks: [{ type: 'command', command: 'lint.sh' }] },
-        ],
-      },
-    }))
-
-    await installHooks()
-
-    const settings = JSON.parse(await readFile(SETTINGS_PATH, 'utf-8'))
-    // Existing non-brainjar SessionStart hook preserved
-    expect(settings.hooks.SessionStart).toHaveLength(2)
-    // PreToolUse untouched
-    expect(settings.hooks.PreToolUse).toHaveLength(1)
-    expect(settings.hooks.PreToolUse[0].hooks[0].command).toBe('lint.sh')
-  })
-
-  test('is idempotent — no duplicates on re-install', async () => {
-    await installHooks()
-    await installHooks()
-
-    const settings = JSON.parse(await readFile(SETTINGS_PATH, 'utf-8'))
-    const brainjarEntries = settings.hooks.SessionStart.filter(
-      (m: any) => m.hooks.some((h: any) => h._brainjar)
-    )
-    expect(brainjarEntries).toHaveLength(1)
-  })
-})
-
-describe('hooks remove', () => {
-  test('removes brainjar hooks', async () => {
-    await installHooks()
-    const result = await removeHooks()
-
-    expect(result.removed).toContain('SessionStart')
-
-    const settings = JSON.parse(await readFile(SETTINGS_PATH, 'utf-8'))
-    expect(settings.hooks).toBeUndefined()
-  })
-
-  test('preserves non-brainjar hooks', async () => {
-    await writeFile(SETTINGS_PATH, JSON.stringify({
-      hooks: {
-        SessionStart: [
-          { matcher: 'startup', hooks: [{ type: 'command', command: 'echo hello' }] },
-        ],
-      },
-    }))
-
-    await installHooks()
-    await removeHooks()
-
-    const settings = JSON.parse(await readFile(SETTINGS_PATH, 'utf-8'))
-    expect(settings.hooks.SessionStart).toHaveLength(1)
-    expect(settings.hooks.SessionStart[0].hooks[0].command).toBe('echo hello')
-  })
-
-  test('no-op when no brainjar hooks exist', async () => {
-    await writeFile(SETTINGS_PATH, JSON.stringify({ statusLine: { command: 'echo' } }))
-
-    const result = await removeHooks()
-    expect(result.removed).toHaveLength(0)
-  })
-})
-
-describe('hooks status', () => {
-  test('reports not installed when no hooks', async () => {
-    await writeFile(SETTINGS_PATH, JSON.stringify({}))
-    const result = await getHooksStatus()
-    expect(Object.keys(result.hooks)).toHaveLength(0)
-  })
-
-  test('reports installed hooks', async () => {
-    await installHooks()
-    const result = await getHooksStatus()
-    expect(result.hooks.SessionStart).toBe('brainjar sync --quiet')
-  })
-
-  test('handles missing settings file', async () => {
-    const result = await getHooksStatus()
-    expect(Object.keys(result.hooks)).toHaveLength(0)
-  })
-})