claude-brain 0.4.1 → 0.5.0

package/VERSION

@@ -1 +1 @@
-0.4.1
+0.5.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-brain",
-  "version": "0.4.1",
+  "version": "0.5.0",
   "description": "Local development assistant bridging Obsidian vaults with Claude Code via MCP",
   "type": "module",
   "main": "src/index.ts",

package/src/cli/bin.ts

@@ -26,6 +26,7 @@ function printHelp() {
   console.log()
 
   const commands = [
+    ['start', 'Start ChromaDB + MCP server'],
     ['serve', 'Start the MCP server (default)'],
     ['setup', 'Run interactive setup wizard'],
     ['install', 'Register as MCP server in Claude Code'],
@@ -55,12 +56,11 @@ function printHelp() {
     `  ${theme.primary('-h'.padEnd(12))} ${dimText('Show help')}`,
     '',
     theme.bold('Examples:'),
-    `  ${dimText('claude-brain')}                 ${dimText('Start MCP server')}`,
-    `  ${dimText('claude-brain setup')}           ${dimText('Configure Claude Brain')}`,
-    `  ${dimText('claude-brain install')}         ${dimText('Register with Claude Code')}`,
-    `  ${dimText('claude-brain update')}          ${dimText('Update to latest version')}`,
-    `  ${dimText('claude-brain chroma start')}    ${dimText('Start ChromaDB server')}`,
-    `  ${dimText('claude-brain health')}          ${dimText('Check system health')}`,
+    `  ${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 install')}          ${dimText('Register with Claude Code')}`,
+    `  ${dimText('claude-brain health')}           ${dimText('Check system health')}`,
     '',
     theme.bold('Environment:'),
     `  ${theme.primary('CLAUDE_BRAIN_HOME')}   ${dimText('Override home directory (default: ~/.claude-brain/')}`,
@@ -74,6 +74,12 @@ async function main() {
   const command = process.argv[2] || 'serve'
 
   switch (command) {
+    case 'start': {
+      const { runStart } = await import('./commands/start')
+      await runStart()
+      break
+    }
+
     case 'serve': {
       const { runServe } = await import('./commands/serve')
       await runServe()

package/src/cli/commands/chroma.ts

@@ -25,18 +25,75 @@ function getChromaDataPath(): string {
   return paths.chroma
 }
 
-function isChromaCliInstalled(): boolean {
+/**
+ * Find the chroma binary - checks PATH first, then common pip install locations
+ */
+function findChromaBinary(): string | null {
+  // Try bare 'chroma' first (on PATH)
   try {
     execSync('chroma --version', { stdio: 'pipe', timeout: 5000 })
-    return true
-  } catch {
-    return false
+    return 'chroma'
+  } catch {}
+
+  // Search common pip install locations
+  const { homedir } = require('os')
+  const home = homedir()
+  const candidates = [
+    join(home, 'Library', 'Python', '3.9', 'bin', 'chroma'),
+    join(home, 'Library', 'Python', '3.10', 'bin', 'chroma'),
+    join(home, 'Library', 'Python', '3.11', 'bin', 'chroma'),
+    join(home, 'Library', 'Python', '3.12', 'bin', 'chroma'),
+    join(home, 'Library', 'Python', '3.13', 'bin', 'chroma'),
+    join(home, '.local', 'bin', 'chroma'),
+    '/usr/local/bin/chroma',
+    '/opt/homebrew/bin/chroma',
+  ]
+
+  for (const candidate of candidates) {
+    try {
+      if (existsSync(candidate)) {
+        execSync(`"${candidate}" --version`, { stdio: 'pipe', timeout: 5000 })
+        return candidate
+      }
+    } catch {}
+  }
+
+  // Try finding via python -m site
+  try {
+    const sitePackages = execSync('python3 -c "import site; print(site.getusersitepackages())"', {
+      encoding: 'utf-8', stdio: 'pipe', timeout: 5000
+    }).trim()
+    // User site-packages is like /Users/x/Library/Python/3.9/lib/python/site-packages
+    // The bin is at the same level as lib
+    const binDir = sitePackages.replace(/\/lib\/.*/, '/bin')
+    const chromaPath = join(binDir, 'chroma')
+    if (existsSync(chromaPath)) {
+      execSync(`"${chromaPath}" --version`, { stdio: 'pipe', timeout: 5000 })
+      return chromaPath
+    }
+  } catch {}
+
+  return null
+}
+
+let _cachedChromaBinary: string | null | undefined = undefined
+
+function getChromaBinary(): string | null {
+  if (_cachedChromaBinary === undefined) {
+    _cachedChromaBinary = findChromaBinary()
   }
+  return _cachedChromaBinary
+}
+
+function isChromaCliInstalled(): boolean {
+  return getChromaBinary() !== null
 }
 
 function getChromaVersion(): string {
+  const binary = getChromaBinary()
+  if (!binary) return 'unknown'
   try {
-    return execSync('chroma --version', { encoding: 'utf-8', stdio: 'pipe', timeout: 5000 }).trim()
+    return execSync(`"${binary}" --version`, { encoding: 'utf-8', stdio: 'pipe', timeout: 5000 }).trim()
   } catch {
     return 'unknown'
   }
@@ -75,15 +132,17 @@ function getRunningPid(): number | null {
 }
 
 function isChromaReachable(): boolean {
-  try {
-    execSync(`curl -sf http://localhost:${DEFAULT_PORT}/api/v1/heartbeat`, {
-      stdio: 'pipe',
-      timeout: 3000
-    })
-    return true
-  } catch {
-    return false
+  // Try v2 API first (ChromaDB 1.x server), then v1 (older servers)
+  for (const apiVersion of ['v2', 'v1']) {
+    try {
+      execSync(`curl -sf http://localhost:${DEFAULT_PORT}/api/${apiVersion}/heartbeat`, {
+        stdio: 'pipe',
+        timeout: 3000
+      })
+      return true
+    } catch {}
   }
+  return false
 }
 
 async function sleep(ms: number): Promise<void> {
@@ -112,8 +171,9 @@ async function chromaStart(): Promise<void> {
   }
 
   // Check if chroma CLI is installed
-  if (!isChromaCliInstalled()) {
-    console.log(errorText('ChromaDB CLI is not installed.'))
+  const chromaBinary = getChromaBinary()
+  if (!chromaBinary) {
+    console.log(errorText('ChromaDB CLI is not installed or not found on PATH.'))
     console.log()
     console.log(dimText('Install it with:'))
     console.log(`  ${theme.primary('pip install chromadb')}`)
@@ -126,12 +186,13 @@ async function chromaStart(): Promise<void> {
 
   const dataPath = getChromaDataPath()
 
+  console.log(dimText(`Binary: ${chromaBinary}`))
   console.log(dimText(`Data path: ${dataPath}`))
   console.log(dimText(`Port: ${DEFAULT_PORT}`))
   console.log()
 
   // Start ChromaDB server in background
-  const child = spawn('chroma', ['run', '--path', dataPath, '--port', DEFAULT_PORT], {
+  const child = spawn(chromaBinary, ['run', '--path', dataPath, '--port', DEFAULT_PORT], {
     detached: true,
     stdio: ['ignore', 'pipe', 'pipe'],
     env: { ...process.env }
@@ -375,6 +436,75 @@ function printChromaHelp(): void {
   console.log()
 }
 
+// ── Auto-start for serve command ──────────────────────────
+
+/**
+ * Ensures ChromaDB is running before the MCP server starts.
+ * Returns true if ChromaDB is reachable after this call, false otherwise.
+ * Designed to be called from serve.ts — does not call process.exit().
+ */
+export async function ensureChromaRunning(options?: { silent?: boolean }): Promise<boolean> {
+  const log = options?.silent ? () => {} : console.error.bind(console)
+
+  // Already running? Great.
+  if (isChromaReachable()) {
+    return true
+  }
+
+  // Already managed by us but not responding? Clean up stale PID.
+  const stalePid = getRunningPid()
+  if (stalePid) {
+    try {
+      process.kill(stalePid, 'SIGTERM')
+      await sleep(1000)
+    } catch {}
+    try { unlinkSync(getPidFilePath()) } catch {}
+  }
+
+  const chromaBinary = getChromaBinary()
+  if (!chromaBinary) {
+    log('[ChromaDB] Not installed — running with SQLite fallback.')
+    log('[ChromaDB] Install with: claude-brain chroma install')
+    return false
+  }
+
+  const dataPath = getChromaDataPath()
+  log(`[ChromaDB] Starting server (port ${DEFAULT_PORT})...`)
+
+  const child = spawn(chromaBinary, ['run', '--path', dataPath, '--port', DEFAULT_PORT], {
+    detached: true,
+    stdio: ['ignore', 'pipe', 'pipe'],
+    env: { ...process.env }
+  })
+
+  const pid = child.pid
+  if (!pid) {
+    log('[ChromaDB] Failed to spawn server process.')
+    return false
+  }
+
+  child.unref()
+  writeFileSync(getPidFilePath(), String(pid), 'utf-8')
+
+  // Wait for server to become reachable (up to 15 seconds)
+  for (let i = 0; i < 30; i++) {
+    await sleep(500)
+    if (isChromaReachable()) {
+      log(`[ChromaDB] Server started (PID: ${pid})`)
+      return true
+    }
+    // Check if process died
+    try {
+      process.kill(pid, 0)
+    } catch {
+      break
+    }
+  }
+
+  log('[ChromaDB] Server started but not yet responding — will retry connection during initialization.')
+  return isChromaReachable()
+}
+
 // ── Entry Point ───────────────────────────────────────────
 
 export async function runChroma(): Promise<void> {

package/src/cli/commands/serve.ts

@@ -5,6 +5,7 @@ import { ClaudeBrainMCPServer } from '@/server'
 import { initializeServices, shutdownServices, getVaultService, getMemoryService } from '@/server/services'
 import { createOrchestrator, type Orchestrator } from '@/orchestrator'
 import { ensureHomeDirectory } from '@/cli/auto-setup'
+import { ensureChromaRunning } from '@/cli/commands/chroma'
 
 const BANNER = `
 ╔═══════════════════════════════════════════════════════╗
@@ -42,6 +43,11 @@ export async function runServe() {
     cacheSize: config.cacheSize
   }, 'Configuration loaded')
 
+  // Auto-start ChromaDB if not already running
+  mainLogger.info('Ensuring ChromaDB is available...')
+  const chromaReady = await ensureChromaRunning({ silent: process.env.NODE_ENV === 'production' })
+  mainLogger.info({ chromaReady }, chromaReady ? 'ChromaDB is ready' : 'ChromaDB not available, using SQLite fallback')
+
   mainLogger.info('Initializing services...')
   await initializeServices(config, logger)
   mainLogger.info('Services initialized successfully')

package/src/cli/commands/start.ts

@@ -0,0 +1,42 @@
+/**
+ * Start Command
+ * Starts ChromaDB + MCP server together, or just ChromaDB with --chroma-only
+ *
+ * Usage:
+ *   claude-brain start              Start ChromaDB + MCP server
+ *   claude-brain start --chroma-only  Start only ChromaDB server
+ */
+
+import {
+  heading, successText, warningText, dimText,
+} from '@/cli/ui/index.js'
+import { ensureChromaRunning } from '@/cli/commands/chroma'
+
+export async function runStart(): Promise<void> {
+  const chromaOnly = process.argv.includes('--chroma-only')
+
+  if (chromaOnly) {
+    console.log()
+    console.log(heading('Starting ChromaDB'))
+    console.log()
+
+    const chromaReady = await ensureChromaRunning()
+    console.log()
+
+    if (chromaReady) {
+      console.log(successText('ChromaDB is running and ready.'))
+    } else {
+      console.log(warningText('ChromaDB could not be started. Check installation with: claude-brain chroma status'))
+    }
+    console.log()
+    return
+  }
+
+  // Full start: ChromaDB + MCP server
+  // serve.ts already calls ensureChromaRunning(), so just delegate
+  console.error(dimText('Starting ChromaDB + MCP server...'))
+  console.error()
+
+  const { runServe } = await import('./serve')
+  await runServe()
+}

package/src/config/defaults.ts

@@ -3,7 +3,7 @@ import type { PartialConfig } from './schema'
 /** Default configuration values for Claude Brain */
 export const defaultConfig: PartialConfig = {
   serverName: 'claude-brain',
-  serverVersion: '0.4.1',
+  serverVersion: '0.5.0',
   logLevel: 'info',
   logFilePath: './logs/claude-brain.log',
   dbPath: './data/memory.db',

package/src/config/schema.ts

@@ -196,7 +196,7 @@ export const ConfigSchema = z.object({
   serverName: z.string().default('claude-brain'),
 
   /** Server version in semver format */
-  serverVersion: z.string().regex(/^\d+\.\d+\.\d+$/, 'Version must be semver format').default('0.4.1'),
+  serverVersion: z.string().regex(/^\d+\.\d+\.\d+$/, 'Version must be semver format').default('0.5.0'),
 
   /** Logging level */
   logLevel: LogLevelSchema.default('info'),

package/src/memory/chroma/client.ts

@@ -29,8 +29,12 @@ export class ChromaClientManager {
 
       switch (this.config.mode) {
         case 'persistent':
+          // ChromaDB v3.x no longer supports embedded persistent mode via 'path'.
+          // Fall through to client-server connecting to localhost.
+          this.logger.info('Persistent mode: connecting to ChromaDB server on localhost (v3.x requires a running server)')
           this.client = new ChromaClient({
-            path: this.config.path,
+            host: this.config.host || 'localhost',
+            port: this.config.port || 8000,
             ...authConfig
           })
           break

package/src/memory/index.ts

@@ -381,6 +381,97 @@ export class MemoryManager {
     return this.store.searchCorrections('', { limit: options?.limit || 10 })
   }
 
+  /**
+   * Fetch all decisions with content — routes to ChromaDB or SQLite
+   * Used by analytical tools that need bulk access to decision data
+   */
+  async fetchAllDecisions(project?: string): Promise<any[]> {
+    if (this.useChromaDB) {
+      try {
+        const results = await this.chroma.collections.decisions.get({
+          where: project ? { project } : undefined
+        })
+        if (results && results.ids) {
+          return results.ids.map((id: string, i: number) => ({
+            id,
+            content: results.documents?.[i] || '',
+            date: results.metadatas?.[i]?.created_at || new Date().toISOString(),
+            project: results.metadatas?.[i]?.project || project || 'unknown',
+            context: results.metadatas?.[i]?.context || '',
+            decision: results.metadatas?.[i]?.decision || results.documents?.[i] || '',
+            reasoning: results.metadatas?.[i]?.reasoning || '',
+            alternatives: results.metadatas?.[i]?.alternatives_considered || '',
+            tags: results.metadatas?.[i]?.tags || []
+          }))
+        }
+        return []
+      } catch (error) {
+        this.logger.warn({ error }, 'ChromaDB fetchAllDecisions failed, falling back to SQLite')
+      }
+    }
+    return this.store.getAllDecisionsWithContent(project)
+  }
+
+  /**
+   * Fetch all patterns with content — routes to ChromaDB or SQLite
+   */
+  async fetchAllPatterns(project?: string): Promise<any[]> {
+    if (this.useChromaDB) {
+      try {
+        const results = await this.chroma.collections.patterns.get({
+          where: project ? { project } : undefined
+        })
+        if (results && results.ids) {
+          return results.ids.map((id: string, i: number) => ({
+            id,
+            content: results.documents?.[i] || '',
+            date: results.metadatas?.[i]?.created_at || new Date().toISOString(),
+            project: results.metadatas?.[i]?.project || project || 'unknown',
+            pattern_type: results.metadatas?.[i]?.pattern_type || '',
+            description: results.metadatas?.[i]?.description || results.documents?.[i] || '',
+            example: results.metadatas?.[i]?.example || '',
+            confidence: results.metadatas?.[i]?.confidence || 0,
+            context: results.metadatas?.[i]?.context || ''
+          }))
+        }
+        return []
+      } catch (error) {
+        this.logger.warn({ error }, 'ChromaDB fetchAllPatterns failed, falling back to SQLite')
+      }
+    }
+    return this.store.getAllPatternsWithContent(project)
+  }
+
+  /**
+   * Fetch all corrections with content — routes to ChromaDB or SQLite
+   */
+  async fetchAllCorrections(project?: string): Promise<any[]> {
+    if (this.useChromaDB) {
+      try {
+        const results = await this.chroma.collections.corrections.get({
+          where: project ? { project } : undefined
+        })
+        if (results && results.ids) {
+          return results.ids.map((id: string, i: number) => ({
+            id,
+            content: results.documents?.[i] || '',
+            date: results.metadatas?.[i]?.created_at || new Date().toISOString(),
+            project: results.metadatas?.[i]?.project || project || 'unknown',
+            original: results.metadatas?.[i]?.original || '',
+            correction: results.metadatas?.[i]?.correction || results.documents?.[i] || '',
+            reasoning: results.metadatas?.[i]?.reasoning || '',
+            context: results.metadatas?.[i]?.context || '',
+            confidence: results.metadatas?.[i]?.confidence || 0
+          }))
+        }
+        return []
+      } catch (error) {
+        this.logger.warn({ error }, 'ChromaDB fetchAllCorrections failed, falling back to SQLite')
+      }
+    }
+    return this.store.getAllCorrectionsWithContent(project)
+  }
+
   /**
    * Search patterns by query — routes to ChromaDB or SQLite
    */

package/src/memory/store.ts

@@ -459,10 +459,14 @@ export class MemoryStore {
         metadata: {
           project: row.project,
           pattern_type: row.pattern_type,
+          description: row.description,
           example: row.example || '',
           confidence: row.confidence,
           context: row.context || '',
-          created_at: row.created_at
+          created_at: row.created_at,
+          first_seen: row.created_at,
+          last_seen: row.created_at,
+          occurrences: 1
         }
       }))
     } catch (error) {
@@ -484,14 +488,19 @@ export class MemoryStore {
       return rows.map(row => ({
         id: row.id,
         correction: row.correction,
+        description: row.correction,
         metadata: {
           project: row.project,
           original: row.original,
           correction: row.correction,
+          description: row.correction,
           reasoning: row.reasoning,
           context: row.context || '',
           confidence: row.confidence,
-          created_at: row.created_at
+          created_at: row.created_at,
+          first_seen: row.created_at,
+          last_seen: row.created_at,
+          occurrences: 1
         }
       }))
     } catch (error) {
@@ -553,10 +562,14 @@ export class MemoryStore {
           metadata: {
             project: row.project,
             pattern_type: row.pattern_type,
+            description: row.description,
             example: row.example || '',
             confidence: row.confidence,
             context: row.context || '',
-            created_at: row.created_at
+            created_at: row.created_at,
+            first_seen: row.created_at,
+            last_seen: row.created_at,
+            occurrences: 1
           },
           similarity
         }
@@ -613,14 +626,19 @@ export class MemoryStore {
         return {
           id: row.id,
           content: row.correction,
+          description: row.correction,
           metadata: {
             project: row.project,
             original: row.original,
             correction: row.correction,
+            description: row.correction,
             reasoning: row.reasoning,
             context: row.context || '',
             confidence: row.confidence,
-            created_at: row.created_at
+            created_at: row.created_at,
+            first_seen: row.created_at,
+            last_seen: row.created_at,
+            occurrences: 1
           },
           similarity
         }
@@ -636,6 +654,120 @@ export class MemoryStore {
     }
   }
 
+  /**
+   * Get all decisions with full content (for analytical tools without ChromaDB)
+   */
+  getAllDecisionsWithContent(project?: string): any[] {
+    try {
+      let sql = `
+        SELECT d.id, d.context, d.decision, d.reasoning, d.alternatives, d.tags,
+               m.content, m.project, m.created_at, m.metadata
+        FROM decisions d
+        JOIN memories m ON d.memory_id = m.id
+      `
+      const params: any[] = []
+      if (project) {
+        sql += ' WHERE m.project = ?'
+        params.push(project)
+      }
+      sql += ' ORDER BY m.created_at DESC'
+
+      const stmt = this.db.prepare(sql)
+      const rows = stmt.all(...params) as any[]
+
+      return rows.map(row => ({
+        id: row.id,
+        content: row.content,
+        date: row.created_at,
+        project: row.project,
+        context: row.context,
+        decision: row.decision,
+        reasoning: row.reasoning,
+        alternatives: row.alternatives,
+        tags: row.tags ? JSON.parse(row.tags) : []
+      }))
+    } catch (error) {
+      this.logger.error({ error, project }, 'Failed to get all decisions with content')
+      return []
+    }
+  }
+
+  /**
+   * Get all patterns with full content (for analytical tools without ChromaDB)
+   */
+  getAllPatternsWithContent(project?: string): any[] {
+    try {
+      let sql = `
+        SELECT p.id, p.pattern_type, p.description, p.example, p.confidence, p.context,
+               m.content, m.project, m.created_at
+        FROM patterns p
+        JOIN memories m ON p.memory_id = m.id
+      `
+      const params: any[] = []
+      if (project) {
+        sql += ' WHERE p.project = ?'
+        params.push(project)
+      }
+      sql += ' ORDER BY m.created_at DESC'
+
+      const stmt = this.db.prepare(sql)
+      const rows = stmt.all(...params) as any[]
+
+      return rows.map(row => ({
+        id: row.id,
+        content: row.content,
+        date: row.created_at,
+        project: row.project,
+        pattern_type: row.pattern_type,
+        description: row.description,
+        example: row.example,
+        confidence: row.confidence,
+        context: row.context
+      }))
+    } catch (error) {
+      this.logger.error({ error, project }, 'Failed to get all patterns with content')
+      return []
+    }
+  }
+
+  /**
+   * Get all corrections with full content (for analytical tools without ChromaDB)
+   */
+  getAllCorrectionsWithContent(project?: string): any[] {
+    try {
+      let sql = `
+        SELECT c.id, c.original, c.correction, c.reasoning, c.context as correction_context,
+               c.confidence, m.content, m.project, m.created_at
+        FROM corrections c
+        JOIN memories m ON c.memory_id = m.id
+      `
+      const params: any[] = []
+      if (project) {
+        sql += ' WHERE c.project = ?'
+        params.push(project)
+      }
+      sql += ' ORDER BY m.created_at DESC'
+
+      const stmt = this.db.prepare(sql)
+      const rows = stmt.all(...params) as any[]
+
+      return rows.map(row => ({
+        id: row.id,
+        content: row.content,
+        date: row.created_at,
+        project: row.project,
+        original: row.original,
+        correction: row.correction,
+        reasoning: row.reasoning,
+        context: row.correction_context,
+        confidence: row.confidence
+      }))
+    } catch (error) {
+      this.logger.error({ error, project }, 'Failed to get all corrections with content')
+      return []
+    }
+  }
+
   /**
    * Convert database row to Decision object
    */