claude-brain 0.22.0 → 0.22.2

package/VERSION

@@ -1 +1 @@
-0.22.0
+0.22.2

package/package.json

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

package/src/cli/commands/serve.ts

@@ -5,7 +5,6 @@ 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 = `
 ╔═══════════════════════════════════════════════════════╗
@@ -29,12 +28,12 @@ export async function runServe() {
     console.error(`[claude-brain] Hook auto-install skipped: ${error instanceof Error ? error.message : 'unknown error'}`)
   }
 
-  if (process.env.NODE_ENV !== 'production') {
+  const config = await loadConfig()
+
+  if (config.logLevel === 'debug' || config.logLevel === 'info') {
     console.error(BANNER)
   }
 
-  const config = await loadConfig()
-
   const logger = createLogger(config.logLevel, config.logFilePath)
   const mainLogger = createComponentLogger(logger, 'main')
 
@@ -54,10 +53,16 @@ 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')
+  // Only start ChromaDB if explicitly enabled in config
+  let chromaReady = false
+  if (config.chromadb?.enabled) {
+    mainLogger.info('ChromaDB enabled, ensuring it is available...')
+    const { ensureChromaRunning } = await import('@/cli/commands/chroma')
+    chromaReady = await ensureChromaRunning({ silent: process.env.NODE_ENV === 'production' })
+    mainLogger.info({ chromaReady }, chromaReady ? 'ChromaDB is ready' : 'ChromaDB not available, using SQLite fallback')
+  } else {
+    mainLogger.info('Using SQLite FTS5 storage (ChromaDB disabled)')
+  }
 
   mainLogger.info('Initializing services...')
   await initializeServices(config, logger)

package/src/cli/commands/start.ts

@@ -1,17 +1,16 @@
 /**
  * Start Command
- * Starts ChromaDB + MCP server together, or just ChromaDB with --chroma-only
+ * Starts the Claude Brain server (MCP + HTTP)
  *
  * Usage:
- *   claude-brain start              Start ChromaDB + MCP server
- *   claude-brain start --chroma-only  Start only ChromaDB server
+ *   claude-brain start              Start server
+ *   claude-brain start --chroma-only  Start only ChromaDB server (if enabled)
  */
 
 import { parseArgs } from 'citty'
 import {
   heading, successText, warningText, dimText,
 } from '@/cli/ui/index.js'
-import { ensureChromaRunning } from '@/cli/commands/chroma'
 
 export async function runStart(): Promise<void> {
   const args = parseArgs(process.argv.slice(3), {
@@ -20,6 +19,7 @@ export async function runStart(): Promise<void> {
   const chromaOnly = args['chroma-only']
 
   if (chromaOnly) {
+    const { ensureChromaRunning } = await import('@/cli/commands/chroma')
     console.log()
     console.log(heading('Starting ChromaDB'))
     console.log()
@@ -36,9 +36,7 @@ export async function runStart(): Promise<void> {
     return
   }
 
-  // Full start: ChromaDB + MCP server
-  // serve.ts already calls ensureChromaRunning(), so just delegate
-  console.error(dimText('Starting ChromaDB + MCP server...'))
+  console.error(dimText('Starting Claude Brain server...'))
   console.error()
 
   const { runServe } = await import('./serve')

package/src/cli/commands/status.ts

@@ -39,16 +39,17 @@ export async function runStatus() {
       const { Database } = await import('bun:sqlite')
       const db = new Database(dbPath, { readonly: true })
 
-      // Count observations by category
+      // Count observations by category (dynamic — includes all categories)
       const total = (db.prepare('SELECT COUNT(*) as cnt FROM observations WHERE archived = 0').get() as any)?.cnt ?? 0
-      const decisions = (db.prepare("SELECT COUNT(*) as cnt FROM observations WHERE category = 'decision' AND archived = 0").get() as any)?.cnt ?? 0
-      const patterns = (db.prepare("SELECT COUNT(*) as cnt FROM observations WHERE category = 'pattern' AND archived = 0").get() as any)?.cnt ?? 0
-      const corrections = (db.prepare("SELECT COUNT(*) as cnt FROM observations WHERE category = 'correction' AND archived = 0").get() as any)?.cnt ?? 0
+      const catRows = db.prepare(
+        'SELECT category, COUNT(*) as cnt FROM observations WHERE archived = 0 GROUP BY category'
+      ).all() as any[]
+      const breakdown = catRows.map((r: any) => `${r.cnt} ${r.category}s`).join(', ')
 
       items.push({ label: 'Storage', value: 'SQLite FTS5', status: 'success' })
       items.push({
         label: 'Observations',
-        value: `${total} (${decisions} decisions, ${patterns} patterns, ${corrections} corrections)`,
+        value: `${total}${breakdown ? ` (${breakdown})` : ''}`,
         status: total > 0 ? 'success' : 'warning'
       })
 
@@ -79,7 +80,7 @@ export async function runStatus() {
       const symbols = (codeDb.prepare('SELECT COUNT(*) as cnt FROM code_symbols').get() as any)?.cnt ?? 0
 
       // Last indexed time
-      const latest = (codeDb.prepare('SELECT MAX(indexed_at) as latest FROM code_files').get() as any)?.latest
+      const latest = (codeDb.prepare('SELECT MAX(last_indexed) as latest FROM code_files').get() as any)?.latest
       const lastIndexed = latest ? formatAge(latest) : 'never'
 
       items.push({

package/src/memory/fts5-search.ts

@@ -245,15 +245,21 @@ export class FTS5Search {
   /**
    * Fetch all observations for a project, optionally filtered by category.
    */
-  fetchAll(project: string, category?: ObservationCategory): ObservationResult[] {
+  fetchAll(project?: string, category?: ObservationCategory): ObservationResult[] {
     let sql: string
-    const params: any[] = [project]
+    const params: any[] = []
 
-    if (category) {
+    if (project && category) {
       sql = `SELECT * FROM observations WHERE project = ? AND category = ? AND archived = 0 ORDER BY created_at DESC`
+      params.push(project, category)
+    } else if (project) {
+      sql = `SELECT * FROM observations WHERE project = ? AND archived = 0 ORDER BY created_at DESC`
+      params.push(project)
+    } else if (category) {
+      sql = `SELECT * FROM observations WHERE category = ? AND archived = 0 ORDER BY created_at DESC`
       params.push(category)
     } else {
-      sql = `SELECT * FROM observations WHERE project = ? AND archived = 0 ORDER BY created_at DESC`
+      sql = `SELECT * FROM observations WHERE archived = 0 ORDER BY created_at DESC`
     }
 
     const rows = this.db.prepare(sql).all(...params) as any[]
@@ -337,6 +343,26 @@ export class FTS5Search {
     this.recordAccess(id)
   }
 
+  /**
+   * BUG-002: Search within a specific category, optionally scoped to a project.
+   * Returns results ordered by creation date (most recent first).
+   */
+  searchByCategory(category: ObservationCategory, project?: string, limit: number = 10): ObservationResult[] {
+    let sql: string
+    const params: any[] = []
+
+    if (project) {
+      sql = `SELECT * FROM observations WHERE category = ? AND project = ? AND archived = 0 ORDER BY created_at DESC LIMIT ?`
+      params.push(category, project, limit)
+    } else {
+      sql = `SELECT * FROM observations WHERE category = ? AND archived = 0 ORDER BY created_at DESC LIMIT ?`
+      params.push(category, limit)
+    }
+
+    const rows = this.db.prepare(sql).all(...params) as any[]
+    return rows.map(row => this.rowToResult(row))
+  }
+
   // --- Private helpers ---
 
   /**
@@ -362,9 +388,9 @@ export class FTS5Search {
    * Typical range: -20 (excellent) to 0 (poor).
    */
   private normalizeBM25(score: number): number {
-    // Map typical BM25 range to 0.5-0.85
+    // Map BM25 range to 0.2-0.9 (wider range, allows low scores to be filtered)
     const normalized = Math.min(1, Math.max(0, score / 20))
-    return 0.5 + normalized * 0.35
+    return 0.2 + normalized * 0.7
   }
 
   /**

package/src/memory/index.ts

@@ -543,8 +543,8 @@ export class MemoryManager {
       limit?: number
     }
   ): Promise<any[]> {
-    // Phase 26: Try FTS5 first
-    if (this._fts5 && project) {
+    // Phase 26: Try FTS5 first (BUG-002: works with or without project)
+    if (this._fts5) {
       const results = this._fts5.fetchAll(project, 'pattern')
       if (results.length > 0) {
         return results.map(r => ({
@@ -580,8 +580,8 @@ export class MemoryManager {
     project?: string,
     options?: { limit?: number }
   ): Promise<any[]> {
-    // Phase 26: Try FTS5 first
-    if (this._fts5 && project) {
+    // Phase 26: Try FTS5 first (BUG-002: works with or without project)
+    if (this._fts5) {
       const results = this._fts5.fetchAll(project, 'correction')
       if (results.length > 0) {
         return results.map(r => ({
@@ -615,8 +615,8 @@ export class MemoryManager {
    * Used by analytical tools that need bulk access to decision data
    */
   async fetchAllDecisions(project?: string): Promise<any[]> {
-    // Phase 26: Try FTS5 first
-    if (this._fts5 && project) {
+    // Phase 26: Try FTS5 first (BUG-002: works with or without project)
+    if (this._fts5) {
       const results = this._fts5.fetchAll(project, 'decision')
       if (results.length > 0) {
         return results.map(r => ({
@@ -664,8 +664,8 @@ export class MemoryManager {
    * Fetch all patterns with content — routes to FTS5, ChromaDB, or legacy SQLite
    */
   async fetchAllPatterns(project?: string): Promise<any[]> {
-    // Phase 26: Try FTS5 first
-    if (this._fts5 && project) {
+    // Phase 26: Try FTS5 first (BUG-002: works with or without project)
+    if (this._fts5) {
       const results = this._fts5.fetchAll(project, 'pattern')
       if (results.length > 0) {
         return results.map(r => ({
@@ -713,8 +713,8 @@ export class MemoryManager {
    * Fetch all corrections with content — routes to FTS5, ChromaDB, or legacy SQLite
    */
   async fetchAllCorrections(project?: string): Promise<any[]> {
-    // Phase 26: Try FTS5 first
-    if (this._fts5 && project) {
+    // Phase 26: Try FTS5 first (BUG-002: works with or without project)
+    if (this._fts5) {
       const results = this._fts5.fetchAll(project, 'correction')
       if (results.length > 0) {
         return results.map(r => ({
@@ -873,14 +873,47 @@ export class MemoryManager {
     reasoning: string,
     options?: { alternatives?: string; tags?: string[] }
   ): Promise<string> {
-    // Delete old version — fires onDecisionDeletedCallbacks (graph + episode cleanup)
+    // BUG-001: True in-place update using FTS5 (preserves original ID)
+    if (this._fts5) {
+      try {
+        this._fts5.update(oldId, {
+          content: decision,
+          reasoning,
+          context,
+          tags: options?.tags
+        })
+        this.logger.debug({ oldId }, 'Decision updated in-place via FTS5')
+
+        // Also update ChromaDB if available (best-effort)
+        if (this.useChromaDB) {
+          try {
+            await this.chroma.store.deleteDecision(oldId)
+            await this.chroma.store.storeDecision({
+              project,
+              context,
+              decision,
+              reasoning,
+              alternatives: options?.alternatives,
+              tags: options?.tags
+            })
+          } catch {
+            // ChromaDB sync failed, FTS5 is source of truth
+          }
+        }
+
+        return oldId // SAME ID preserved
+      } catch (error) {
+        this.logger.warn({ error, oldId }, 'FTS5 in-place update failed, falling back to delete+store')
+      }
+    }
+
+    // Fallback: delete + store (legacy behavior for non-FTS5 backends)
     try {
       await this.deleteDecision(oldId)
       this.logger.debug({ oldId }, 'Old decision deleted for update')
     } catch (error) {
       this.logger.warn({ error, oldId }, 'Failed to delete old decision during update, storing new version anyway')
     }
-    // Store new version — fires onDecisionStoredCallbacks (graph rebuild)
     const newId = await this.rememberDecision(project, context, decision, reasoning, options)
     this.logger.debug({ oldId, newId }, 'Decision updated: old deleted, new stored')
     return newId

package/src/routing/response-filter.ts

@@ -225,7 +225,7 @@ export class ResponseFilter {
       ? (left + right) / 2
       : right
 
-    const threshold = Math.max(median * 0.7, 0.35)
+    const threshold = Math.max(median * 0.7, 0.45)
 
     return results.filter(r => r.score >= threshold)
   }

package/src/routing/router.ts

@@ -33,8 +33,8 @@ import type { ObservationCompressor } from '@/memory/compression'
 const DEFAULT_PROJECT = 'general'
 
 /** Phase 19 D4: Minimum similarity for destructive operations */
-const DELETE_MIN_SIMILARITY = 0.5
-const UPDATE_MIN_SIMILARITY = 0.5
+const DELETE_MIN_SIMILARITY = 0.3
+const UPDATE_MIN_SIMILARITY = 0.3
 
 export interface BrainInput {
   message: string
@@ -879,7 +879,23 @@ export class BrainRouter {
             relevantItems: 0
           }
         } else if (results.length > 0 && matchSimilarity < DELETE_MIN_SIMILARITY) {
-          // D4: No confident match
+          // D4: No confident match — try direct FTS5 content search as fallback
+          const memory = getMemoryService()
+          if (memory.fts5) {
+            const ftsResults = memory.fts5.search(topic, effectiveProject, 3)
+            if (ftsResults.length > 0) {
+              const ftsTarget = ftsResults[0]
+              await memory.deleteDecision(ftsTarget.id)
+              if (this.lastStoredId === ftsTarget.id) this.lastStoredId = null
+              this.searchEngine.invalidateCache(effectiveProject)
+              return {
+                action: 'stored',
+                summary: `Deleted memory`,
+                content: `Deleted: "${ftsTarget.content.slice(0, 100)}" (ID: ${ftsTarget.id})`,
+                relevantItems: 0
+              }
+            }
+          }
           return {
             action: 'none',
             summary: 'No confident match to delete',
@@ -936,6 +952,12 @@ export class BrainRouter {
       return this.servicesNotReady()
     }
 
+    // BUG-002: Detect category-based queries and route to fetchAll
+    const categoryIntent = this.detectCategoryIntent(message)
+    if (categoryIntent) {
+      return this.handleCategoryQuery(message, project, categoryIntent)
+    }
+
     // Phase 25: Use undefined for search (no project filter = search all) when no project detected
     const searchProject = project || undefined
     const displayProject = project || DEFAULT_PROJECT
@@ -1832,6 +1854,102 @@ export class BrainRouter {
     return { content }
   }
 
+  /**
+   * BUG-002: Detect category-based intent from question messages.
+   * Returns the category if the user is asking about a specific type of memory.
+   */
+  private detectCategoryIntent(message: string): 'decision' | 'pattern' | 'correction' | null {
+    const lower = message.toLowerCase()
+
+    // Decision-oriented queries
+    if (
+      lower.includes('what decisions') || lower.includes('my decisions') ||
+      lower.includes('what have i decided') || lower.includes('what did i decide') ||
+      lower.includes('what choices') || lower.includes('decisions i') ||
+      lower.includes('list decisions') || lower.includes('show decisions') ||
+      lower.includes('all decisions') || lower.includes('what did i choose')
+    ) {
+      return 'decision'
+    }
+
+    // Pattern-oriented queries
+    if (
+      lower.includes('what patterns') || lower.includes('my patterns') ||
+      lower.includes('best practices') || lower.includes('conventions') ||
+      lower.includes('list patterns') || lower.includes('show patterns') ||
+      lower.includes('all patterns')
+    ) {
+      return 'pattern'
+    }
+
+    // Correction-oriented queries
+    if (
+      lower.includes('what mistakes') || lower.includes('my mistakes') ||
+      lower.includes('what bugs') || lower.includes('lessons learned') ||
+      lower.includes('what corrections') || lower.includes('my corrections') ||
+      lower.includes('list corrections') || lower.includes('show corrections') ||
+      lower.includes('all corrections') || lower.includes('what have i fixed') ||
+      lower.includes('what did i fix')
+    ) {
+      return 'correction'
+    }
+
+    return null
+  }
+
+  /**
+   * BUG-002: Handle category-scoped queries by fetching all items of that category.
+   */
+  private async handleCategoryQuery(
+    message: string,
+    project: string | undefined,
+    category: 'decision' | 'pattern' | 'correction'
+  ): Promise<BrainResponse> {
+    const memory = getMemoryService()
+    const projectLabel = project || 'all projects'
+
+    let items: any[]
+    switch (category) {
+      case 'decision':
+        items = await memory.fetchAllDecisions(project)
+        break
+      case 'pattern':
+        items = await memory.fetchAllPatterns(project)
+        break
+      case 'correction':
+        items = await memory.fetchAllCorrections(project)
+        break
+    }
+
+    if (items.length === 0) {
+      return {
+        action: 'none',
+        summary: `No ${category}s found`,
+        content: `No ${category}s found for ${projectLabel}.`,
+        relevantItems: 0
+      }
+    }
+
+    // Format as compact items
+    const allItems = items.map(item => ({
+      id: item.id || item.decision_id,
+      content: typeof (item.decision || item.description || item.correction || item.original || item.document || item.content) === 'string'
+        ? (item.decision || item.description || item.correction || item.original || item.document || item.content)
+        : JSON.stringify(item.decision || item.description || item.correction || item.original || item.document || item.content || ''),
+      category,
+      project: item.project || project || 'general',
+      created_at: item.created_at || item.date || '',
+    }))
+
+    const compactContent = formatCompactResponse(allItems, `${category}s for ${projectLabel}`)
+    return {
+      action: 'retrieved',
+      summary: `${items.length} ${category}s for ${projectLabel}`,
+      content: compactContent,
+      relevantItems: items.length
+    }
+  }
+
   private generateTaskId(title: string): string {
     return title
       .toLowerCase()

package/src/server/http-api.ts

@@ -595,7 +595,7 @@ export class HttpApiServer {
       }
 
       const body = await c.req.json()
-      const { projectPath, projectName } = body
+      const { projectPath, projectName, force } = body
 
       if (!projectPath || !projectName) {
         return Response.json(
@@ -604,6 +604,20 @@ export class HttpApiServer {
         )
       }
 
+      // BUG-004: Clear existing index data when force flag is set
+      if (force && this.codeQuery) {
+        try {
+          const db = (this.codeQuery as any).db
+          if (db) {
+            db.run('DELETE FROM code_files WHERE project = ?', projectName)
+            db.run('DELETE FROM code_symbols WHERE project = ?', projectName)
+            this.logger.info({ projectName }, 'Force reindex: cleared existing data')
+          }
+        } catch (error) {
+          this.logger.warn({ error, projectName }, 'Failed to clear index data for force reindex')
+        }
+      }
+
       const result = await this.codeIndexer.indexProject(projectPath, projectName)
       return Response.json({ success: true, data: result })
     } catch (error) {
@@ -654,7 +668,7 @@ export class HttpApiServer {
         )
       }
 
-      const query = c.req.query('query') || ''
+      const query = c.req.query('query') || c.req.query('q') || ''
       const project = c.req.query('project') || ''
       const limit = parseInt(c.req.query('limit') || '20', 10)
 

package/src/tools/schemas.ts

@@ -600,7 +600,7 @@ export const TOOLS = {
         },
         project: {
           type: 'string',
-          description: 'Project name (optional — auto-detected from message if omitted)'
+          description: 'Project name (IMPORTANT: pass this to scope memories correctly, e.g. "my-app"). Auto-detected from message if omitted, defaults to "general".'
         }
       },
       required: ['message']