claude-brain 0.17.14 → 0.22.0

package/VERSION

@@ -1 +1 @@
-0.17.14
+0.22.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-brain",
-  "version": "0.17.14",
+  "version": "0.22.0",
   "description": "Local development assistant bridging Obsidian vaults with Claude Code via MCP",
   "type": "module",
   "main": "src/index.ts",
@@ -77,6 +77,8 @@
     "pino": "^10.1.1",
     "pino-pretty": "^13.1.3",
     "prompts": "2.4.2",
+    "tree-sitter-wasms": "0.1.13",
+    "web-tree-sitter": "0.24.7",
     "zod": "^4.3.5"
   }
 }

package/scripts/postinstall.mjs

@@ -5,6 +5,15 @@
  * Runs automatically after `npm install -g claude-brain` or `bun install -g claude-brain`.
  * Pure Node.js — no TypeScript, no path aliases, no Bun APIs.
  * Always exits 0 so it never blocks the install.
+ *
+ * Phase 30: Zero-config — does EVERYTHING automatically:
+ * 1. Create data directory: ~/.claude-brain/data/
+ * 2. Create default config if none exists: ~/.claude-brain/config.yml
+ * 3. Copy hook files to ~/.claude-brain/hooks/
+ * 4. Register hooks in ~/.claude/settings.json (if Claude Code installed)
+ * 5. Print success message with next steps
+ *
+ * No interactive prompts. No setup wizard. Sensible defaults.
  */
 
 import { mkdirSync, writeFileSync, readFileSync, existsSync, renameSync } from 'node:fs'
@@ -56,19 +65,13 @@ function shouldSkip() {
   return null
 }
 
-// ── Step 1: Create ~/.claude-brain/ ──────────────────────
+// ── Step 1: Create ~/.claude-brain/ data directory ───────
 
 function setupHomeDirectory() {
-  if (existsSync(join(HOME, 'data'))) {
-    log('Home directory already initialized')
-    return true
-  }
-
-  log(`Setting up ${HOME}/...`)
+  const isAlreadySetup = existsSync(join(HOME, 'data'))
 
   const dirs = [
     join(HOME, 'data'),
-    join(HOME, 'data', 'chroma'),
     join(HOME, 'logs'),
     join(HOME, 'vault'),
     join(HOME, 'vault', 'Projects'),
@@ -80,20 +83,14 @@ function setupHomeDirectory() {
     mkdirSync(dir, { recursive: true })
   }
 
-  // Write default .env if not present
+  // Write default .env if not present (for backward compat)
   const envPath = join(HOME, '.env')
   if (!existsSync(envPath)) {
     writeFileSync(envPath, `# Claude Brain Configuration
 # Generated by postinstall
 VAULT_PATH=${join(HOME, 'vault')}
-LOG_LEVEL=info
+LOG_LEVEL=warn
 NODE_ENV=production
-
-# ChromaDB Configuration
-CHROMA_MODE=client-server
-CHROMA_HOST=localhost
-CHROMA_PORT=8000
-CHROMA_EMBEDDING_PROVIDER=transformers
 `, 'utf-8')
   }
 
@@ -119,96 +116,50 @@ last_updated: ${new Date().toISOString().split('T')[0]}
 `, 'utf-8')
   }
 
-  log('Home directory initialized')
+  if (isAlreadySetup) {
+    log('Data directory already exists')
+  } else {
+    log('Data directory created')
+  }
+
   return true
 }
 
-// ── Step 2: Install ChromaDB via pip ─────────────────────
+// ── Step 2: Create default config.yml ────────────────────
 
-function installChromaDB() {
-  // Check if already installed
-  try {
-    execSync('chroma --version', { stdio: 'pipe', timeout: 5000 })
-    log('ChromaDB already installed')
+function createDefaultConfig() {
+  const configPath = join(HOME, 'config.yml')
+  if (existsSync(configPath)) {
+    log('Config already exists')
     return true
-  } catch {}
-
-  // Check for Python
-  let pythonCmd = null
-  for (const cmd of ['python3', 'python']) {
-    try {
-      const ver = execSync(`${cmd} --version`, { encoding: 'utf-8', stdio: 'pipe', timeout: 5000 })
-      if (ver.includes('3.')) {
-        pythonCmd = cmd
-        break
-      }
-    } catch {}
   }
 
-  if (!pythonCmd) {
-    log('Python 3 not found — skipping ChromaDB install (SQLite fallback will be used)')
-    return false
-  }
-
-  log('Installing ChromaDB...')
-
-  const pipCommands = pythonCmd === 'python3'
-    ? ['pip3 install chromadb', 'python3 -m pip install chromadb']
-    : ['pip install chromadb', 'python -m pip install chromadb']
-
-  for (const cmd of pipCommands) {
-    try {
-      execSync(cmd, { stdio: 'pipe', timeout: 300_000 })
-      log('ChromaDB installed')
-      return true
-    } catch {}
-  }
+  const config = `# Claude Brain Configuration
+# Auto-generated on install — edit as needed
+# Docs: https://github.com/your-org/claude-brain
 
-  log('ChromaDB install failed — SQLite fallback will be used')
-  return false
-}
+storage:
+  dataDir: ~/.claude-brain/data
 
-// ── Step 3: Register MCP server ──────────────────────────
+# ChromaDB is optional. SQLite FTS5 is the default search backend.
+# Enable for semantic/vector search (requires: pip install chromadb)
+chromadb:
+  enabled: false
 
-function registerMcpServer() {
-  // Check if claude CLI exists
-  try {
-    execSync('claude --version', { stdio: 'pipe', timeout: 5000 })
-  } catch {
-    log('Claude CLI not found — skipping MCP registration')
-    log('  Run manually: claude mcp add claude-brain -- claude-brain serve')
-    return false
-  }
+# Code intelligence indexes your project files for smarter context
+codeIntelligence:
+  enabled: true
+  autoIndexOnSessionStart: true
 
-  // Check if already configured
-  try {
-    const result = execSync('claude mcp list', { encoding: 'utf-8', stdio: 'pipe', timeout: 10000 })
-    if (result.includes('claude-brain')) {
-      log('MCP server already registered')
-      return true
-    }
-  } catch {}
+logLevel: warn
+`
 
-  // Register
-  try {
-    execSync('claude mcp add claude-brain -- claude-brain serve', {
-      stdio: 'pipe',
-      timeout: 15000,
-    })
-    log('Registered as MCP server in Claude Code')
-    return true
-  } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err)
-    if (msg.includes('already') || msg.includes('exists')) {
-      log('MCP server already registered')
-      return true
-    }
-    log('MCP registration failed — run manually: claude mcp add claude-brain -- claude-brain serve')
-    return false
-  }
+  writeFileSync(configPath, config, 'utf-8')
+  log('Created default config.yml')
+  return true
 }
 
-// ── Step 4: Install hooks ────────────────────────────────
+// ── Step 3: Copy hook files ──────────────────────────────
 
 /** Files to copy from package src/hooks/ to ~/.claude-brain/hooks/ */
 const HOOK_FILES = [
@@ -236,13 +187,13 @@ function copyHookFiles() {
       copied++
     }
   }
-  log(`Copied ${copied}/${HOOK_FILES.length} hook files to ${destDir}`)
+  log(`Copied ${copied}/${HOOK_FILES.length} hook files`)
+  return copied > 0
 }
 
-function installHooks() {
-  // Copy hook script files first
-  copyHookFiles()
+// ── Step 4: Register hooks in ~/.claude/settings.json ────
 
+function installHooks() {
   // Read existing settings
   let settings = {}
   if (existsSync(CLAUDE_SETTINGS)) {
@@ -322,7 +273,7 @@ function installHooks() {
   writeFileSync(tmpPath, JSON.stringify(settings, null, 2) + '\n', 'utf-8')
   renameSync(tmpPath, CLAUDE_SETTINGS)
 
-  log('Hooks installed')
+  log('Hooks registered in Claude Code')
   return true
 }
 
@@ -372,25 +323,50 @@ async function main() {
     return
   }
 
-  log('Running postinstall setup...')
+  log('Running zero-config setup...')
   console.error('')
 
   const results = {
     home: false,
-    chromadb: false,
-    mcp: false,
+    config: false,
     hooks: false,
+    hookFiles: false,
     claudemd: false,
   }
 
+  // Step 1: Create data directory
   try { results.home = setupHomeDirectory() } catch (e) { log(`Home setup failed: ${e.message}`) }
-  try { results.chromadb = installChromaDB() } catch (e) { log(`ChromaDB install failed: ${e.message}`) }
-  try { results.mcp = registerMcpServer() } catch (e) { log(`MCP registration failed: ${e.message}`) }
-  try { results.hooks = installHooks() } catch (e) { log(`Hook install failed: ${e.message}`) }
+
+  // Step 2: Create default config.yml
+  try { results.config = createDefaultConfig() } catch (e) { log(`Config creation failed: ${e.message}`) }
+
+  // Step 3: Copy hook files
+  try { results.hookFiles = copyHookFiles() } catch (e) { log(`Hook file copy failed: ${e.message}`) }
+
+  // Step 4: Register hooks in Claude Code settings
+  try { results.hooks = installHooks() } catch (e) { log(`Hook registration failed: ${e.message}`) }
+
+  // Step 5: Install CLAUDE.md
   try { results.claudemd = installClaudeMd() } catch (e) { log(`CLAUDE.md install failed: ${e.message}`) }
 
+  // Print success summary
+  console.error('')
+  console.error(`${PREFIX} ────────────────────────────────────────`)
+  console.error(`${PREFIX}`)
+  console.error(`${PREFIX}  Claude Brain installed successfully!`)
+  console.error(`${PREFIX}`)
+  console.error(`${PREFIX}  Next steps:`)
+  console.error(`${PREFIX}    1. Start the server:  claude-brain start`)
+  console.error(`${PREFIX}    2. Restart Claude Code to activate hooks`)
+  console.error(`${PREFIX}`)
+  console.error(`${PREFIX}  Data:   ${HOME}/data/`)
+  console.error(`${PREFIX}  Config: ${HOME}/config.yml`)
+  console.error(`${PREFIX}  Hooks:  ${HOME}/hooks/`)
+  console.error(`${PREFIX}`)
+  console.error(`${PREFIX}  No setup wizard needed — everything works out of the box.`)
+  console.error(`${PREFIX}  ChromaDB is optional (disabled by default, SQLite FTS5 is used).`)
+  console.error(`${PREFIX} ────────────────────────────────────────`)
   console.error('')
-  log('Setup complete! Restart Claude Code to activate.')
 }
 
 main().catch(err => {

package/src/cli/auto-setup.ts

@@ -6,16 +6,8 @@ function getDefaultEnv(vaultPath: string): string {
   return `# Claude Brain Configuration
 # Generated by auto-setup on first run
 VAULT_PATH=${vaultPath}
-LOG_LEVEL=info
+LOG_LEVEL=warn
 NODE_ENV=production
-
-# ChromaDB Configuration
-# Start ChromaDB server: claude-brain chroma start
-# Install ChromaDB: claude-brain chroma install
-CHROMA_MODE=client-server
-CHROMA_HOST=localhost
-CHROMA_PORT=8000
-CHROMA_EMBEDDING_PROVIDER=transformers
 `
 }
 

package/src/cli/bin.ts

@@ -29,7 +29,7 @@ function printHelp() {
   const commands = [
     ['start', 'Start ChromaDB + MCP server'],
     ['serve', 'Start the MCP server (default)'],
-    ['setup', 'Run interactive setup wizard'],
+    ['setup', 'Ensure home directory and config exist'],
     ['install', 'Register as MCP server in Claude Code'],
     ['uninstall', 'Remove MCP server from Claude Code'],
     ['update', 'Update package and refresh CLAUDE.md'],
@@ -40,6 +40,9 @@ function printHelp() {
     ['init', 'Scan a repo and store initial project context'],
     ['capture', 'Capture a hook event (used by Claude Code hooks)'],
     ['pack', 'Manage knowledge packs (list/status/reload)'],
+    ['status', 'Show system overview'],
+    ['reindex', 'Rebuild code intelligence index'],
+    ['export', 'Export observations (--project, --format md|json)'],
     ['health', 'Run health checks'],
     ['diagnose', 'Run diagnostics'],
     ['version', 'Show version'],
@@ -65,7 +68,7 @@ function printHelp() {
     theme.bold('Examples:'),
     `  ${dimText('claude-brain start')}            ${dimText('Start ChromaDB + MCP server')}`,
     `  ${dimText('claude-brain start --chroma-only')} ${dimText('Start only ChromaDB')}`,
-    `  ${dimText('claude-brain setup')}            ${dimText('Configure Claude Brain')}`,
+    `  ${dimText('claude-brain setup')}            ${dimText('Initialize data directory')}`,
     `  ${dimText('claude-brain install')}          ${dimText('Register with Claude Code')}`,
     `  ${dimText('claude-brain health')}           ${dimText('Check system health')}`,
     '',
@@ -184,6 +187,24 @@ async function main() {
       break
     }
 
+    case 'status': {
+      const { runStatus } = await import('./commands/status')
+      await runStatus()
+      break
+    }
+
+    case 'reindex': {
+      const { runReindex } = await import('./commands/reindex')
+      await runReindex()
+      break
+    }
+
+    case 'export': {
+      const { runExport } = await import('./commands/export')
+      await runExport()
+      break
+    }
+
     case 'health': {
       const { runHealthCheck } = await import('@/health')
       await runHealthCheck()

package/src/cli/commands/export.ts

@@ -0,0 +1,130 @@
+/**
+ * Export Command — Phase 30
+ * Export observations for a project in markdown or JSON format.
+ *
+ * Usage:
+ *   claude-brain export --project expense-tracker --format md > decisions.md
+ *   claude-brain export --project expense-tracker --format json > decisions.json
+ *   claude-brain export --project expense-tracker --category decision
+ */
+
+import { join } from 'node:path'
+import { existsSync } from 'node:fs'
+import { parseArgs } from 'citty'
+import { getClaudeBrainHome } from '@/config/home'
+
+export async function runExport() {
+  const args = parseArgs(process.argv.slice(3), {
+    project: { type: 'string', description: 'Project name to export' },
+    format: { type: 'string', default: 'md', description: 'Output format: md or json' },
+    category: { type: 'string', description: 'Filter by category: decision, pattern, correction' },
+    limit: { type: 'string', default: '1000', description: 'Max observations to export' },
+  })
+
+  const project = args.project
+  const format = args.format || 'md'
+  const category = args.category
+  const limit = parseInt(args.limit || '1000', 10)
+
+  if (!project) {
+    console.error('Error: --project is required')
+    console.error('Usage: claude-brain export --project <name> [--format md|json] [--category decision|pattern|correction]')
+    process.exit(1)
+  }
+
+  const dbPath = join(getClaudeBrainHome(), 'data', 'memory.db')
+  if (!existsSync(dbPath)) {
+    console.error('Error: No database found. Run claude-brain first to initialize.')
+    process.exit(1)
+  }
+
+  const { Database } = await import('bun:sqlite')
+  const db = new Database(dbPath, { readonly: true })
+
+  let sql = 'SELECT * FROM observations WHERE project = ? AND archived = 0'
+  const params: any[] = [project]
+
+  if (category) {
+    sql += ' AND category = ?'
+    params.push(category)
+  }
+
+  sql += ' ORDER BY created_at DESC LIMIT ?'
+  params.push(limit)
+
+  const rows = db.prepare(sql).all(...params) as any[]
+  db.close()
+
+  if (rows.length === 0) {
+    console.error(`No observations found for project "${project}"${category ? ` with category "${category}"` : ''}.`)
+    process.exit(0)
+  }
+
+  if (format === 'json') {
+    const output = rows.map(row => ({
+      id: row.id,
+      project: row.project,
+      category: row.category,
+      content: row.content,
+      reasoning: row.reasoning || null,
+      context: row.context || null,
+      confidence: row.confidence,
+      source: row.source,
+      tags: parseTags(row.tags),
+      created_at: row.created_at,
+      updated_at: row.updated_at,
+    }))
+    console.log(JSON.stringify(output, null, 2))
+  } else {
+    // Markdown format
+    const lines: string[] = []
+    lines.push(`# ${project} — Observations Export`)
+    lines.push('')
+    lines.push(`> Exported ${rows.length} observation(s) on ${new Date().toISOString().split('T')[0]}`)
+    lines.push('')
+
+    // Group by category
+    const grouped: Record<string, any[]> = {}
+    for (const row of rows) {
+      const cat = row.category || 'other'
+      if (!grouped[cat]) grouped[cat] = []
+      grouped[cat].push(row)
+    }
+
+    for (const [cat, items] of Object.entries(grouped)) {
+      lines.push(`## ${capitalize(cat)}s (${items.length})`)
+      lines.push('')
+
+      for (const item of items) {
+        const date = item.created_at ? item.created_at.split('T')[0] : 'unknown'
+        lines.push(`### ${(item.content as string).slice(0, 80)}`)
+        lines.push('')
+        lines.push(`- **Date:** ${date}`)
+        lines.push(`- **Content:** ${item.content}`)
+        if (item.reasoning) lines.push(`- **Reasoning:** ${item.reasoning}`)
+        if (item.context) lines.push(`- **Context:** ${item.context}`)
+        const tags = parseTags(item.tags)
+        if (tags.length > 0) lines.push(`- **Tags:** ${tags.join(', ')}`)
+        lines.push('')
+        lines.push('---')
+        lines.push('')
+      }
+    }
+
+    console.log(lines.join('\n'))
+  }
+}
+
+function parseTags(value: string | null): string[] {
+  if (!value) return []
+  try {
+    const parsed = JSON.parse(value)
+    return Array.isArray(parsed) ? parsed : []
+  } catch {
+    return value.split(',').map(s => s.trim()).filter(Boolean)
+  }
+}
+
+function capitalize(s: string): string {
+  return s.charAt(0).toUpperCase() + s.slice(1)
+}

package/src/cli/commands/reindex.ts

@@ -0,0 +1,107 @@
+/**
+ * Reindex Command — Phase 30
+ * Triggers a code intelligence reindex for a project.
+ *
+ * Usage:
+ *   claude-brain reindex                    # reindex current directory
+ *   claude-brain reindex /path/to/project   # reindex specific project
+ *   claude-brain reindex --force            # ignore hashes, reparse everything
+ */
+
+import path from 'path'
+import { parseArgs } from 'citty'
+import { renderLogo, theme, heading, successText, warningText, dimText, box } from '@/cli/ui/index.js'
+
+export async function runReindex() {
+  console.log()
+  console.log(renderLogo())
+  console.log()
+  console.log(heading('Reindex Project'))
+  console.log()
+
+  const args = parseArgs(process.argv.slice(3), {
+    path: { type: 'positional', required: false, description: 'Path to project directory' },
+    force: { type: 'boolean', default: false, description: 'Ignore hashes, reparse everything' },
+  })
+
+  const projectPath = path.resolve(args.path || process.cwd())
+  const projectName = path.basename(projectPath)
+  const force = args.force
+
+  console.log(`  ${theme.bold('Project:')} ${dimText(projectName)}`)
+  console.log(`  ${theme.bold('Path:')}    ${dimText(projectPath)}`)
+  if (force) {
+    console.log(`  ${theme.bold('Mode:')}    ${dimText('Force reindex (ignore hashes)')}`)
+  }
+  console.log()
+
+  // Try via HTTP API first (server may be running)
+  const port = process.env.CLAUDE_BRAIN_PORT || '3000'
+  const url = `http://localhost:${port}/api/code/index`
+
+  try {
+    const res = await fetch(url, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ projectPath, projectName, force }),
+      signal: AbortSignal.timeout(30000)
+    })
+
+    if (res.ok) {
+      const data = await res.json() as { data?: { filesIndexed?: number; symbolsFound?: number } }
+      const files = data.data?.filesIndexed ?? 0
+      const symbols = data.data?.symbolsFound ?? 0
+      console.log(successText(`  Reindex complete: ${files} files, ${symbols} symbols`))
+      console.log()
+      return
+    }
+
+    console.log(warningText(`  Server returned ${res.status}, trying direct indexing...`))
+  } catch {
+    console.log(dimText('  Server not reachable, indexing directly...'))
+  }
+
+  // Direct indexing (no server)
+  try {
+    const { Database } = await import('bun:sqlite')
+    const { resolve, join } = await import('node:path')
+    const { mkdirSync, existsSync } = await import('node:fs')
+    const { getClaudeBrainHome } = await import('@/config/home')
+
+    const codeDbDir = resolve(getClaudeBrainHome(), 'data')
+    if (!existsSync(codeDbDir)) {
+      mkdirSync(codeDbDir, { recursive: true })
+    }
+    const codeDbPath = join(codeDbDir, 'code.db')
+    const codeDb = new Database(codeDbPath)
+    codeDb.exec('PRAGMA journal_mode=WAL')
+
+    const { CodeParser } = await import('@/code-intelligence/parser')
+    const { CodeIndexer } = await import('@/code-intelligence/indexer')
+    const pino = await import('pino')
+    const logger = pino.default({ level: 'warn' })
+
+    const parser = new CodeParser()
+    await parser.initialize()
+
+    const indexer = new CodeIndexer(codeDb, parser, logger)
+    await indexer.initialize()
+
+    if (force) {
+      // Clear existing index for this project
+      codeDb.run('DELETE FROM code_files WHERE project = ?', projectName)
+      codeDb.run('DELETE FROM code_symbols WHERE project = ?', projectName)
+    }
+
+    const result = await indexer.indexProject(projectPath, projectName)
+    console.log(successText(`  Reindex complete: ${result.filesIndexed ?? 0} files, ${result.symbolsFound ?? 0} symbols`))
+    codeDb.close()
+  } catch (error) {
+    console.log(box(
+      warningText(`Failed to reindex: ${error instanceof Error ? error.message : String(error)}`),
+      'Error'
+    ))
+  }
+
+  console.log()
+}

package/src/cli/commands/serve.ts

@@ -131,6 +131,60 @@ export async function runServe() {
     }
   }
 
+  // Phase 28: Wire code intelligence to HTTP server
+  {
+    const { getCodeIndexer, getCodeQuery } = await import('@/server/services')
+    const codeIndexer = getCodeIndexer()
+    const codeQuery = getCodeQuery()
+    if (codeIndexer && codeQuery) {
+      httpServer.setCodeIntelligence(codeIndexer, codeQuery)
+      mainLogger.info('Code intelligence wired to HTTP server')
+    }
+  }
+
+  // Phase 29: Wire code linker to HTTP server
+  {
+    const { getCodeLinker } = await import('@/server/services')
+    const codeLinker = getCodeLinker()
+    if (codeLinker) {
+      httpServer.setCodeLinker(codeLinker)
+      mainLogger.info('Code linker wired to HTTP server')
+    }
+  }
+
+  // Phase 30: Activity log pruning on startup + periodic cleanup
+  {
+    const memory = getMemoryService()
+    if (memory?.isInitialized()) {
+      try {
+        const { startPeriodicPruning } = await import('@/memory/pruning')
+        const db = memory.database.getDb()
+        const stopPruning = startPeriodicPruning(db, logger, 30)
+        cleanup.register(async () => {
+          stopPruning()
+          mainLogger.info('Activity log pruning stopped')
+        })
+        mainLogger.info('Activity log pruning initialized')
+      } catch (error) {
+        mainLogger.warn({ error }, 'Failed to initialize activity log pruning')
+      }
+    }
+  }
+
+  // Phase 30: Optional LLM compression
+  if (config.compression?.enabled) {
+    try {
+      const { ObservationCompressor } = await import('@/memory/compression')
+      const { getBrainRouter } = await import('@/routing/router')
+      const compressor = new ObservationCompressor(config.compression, logger)
+      const router = getBrainRouter(logger)
+      router.setCompressor(compressor)
+      mainLogger.info({ provider: config.compression.provider, model: config.compression.model }, 'LLM compression enabled')
+    } catch (error) {
+      mainLogger.warn({ error }, 'Failed to initialize LLM compression')
+    }
+  }
+
   // Start HTTP server after MCP server is ready
   setTimeout(async () => {
     try {