claude-brain 0.17.13 → 0.22.0

package/src/code-intelligence/query.ts

@@ -0,0 +1,291 @@
+import { Database } from 'bun:sqlite'
+import type { Logger } from 'pino'
+import type { SymbolResult, FileResult, DependencyResult, FileMapEntry, IndexStats } from './types'
+
+export class CodeQuery {
+  private db: Database
+  private logger: Logger
+  private memoryDb?: Database
+
+  constructor(db: Database, logger: Logger) {
+    this.db = db
+    this.logger = logger.child({ component: 'code-query' })
+  }
+
+  /** Phase 29: Set memory DB for file-linked memory annotations */
+  setMemoryDb(db: Database): void {
+    this.memoryDb = db
+  }
+
+  findSymbols(query: string, project: string, limit: number = 20): SymbolResult[] {
+    if (!query.trim()) return []
+
+    // First try exact match
+    const exact = this.db.query(
+      `SELECT symbol_name, symbol_type, file_path, line_start, line_end, signature
+       FROM code_symbols
+       WHERE project = ? AND symbol_name = ?
+       LIMIT ?`
+    ).all(project, query, limit) as RawSymbolRow[]
+
+    if (exact.length > 0) {
+      return exact.map(row => ({
+        symbol: row.symbol_name,
+        type: row.symbol_type as any,
+        filePath: row.file_path,
+        lineStart: row.line_start,
+        lineEnd: row.line_end ?? undefined,
+        signature: row.signature ?? undefined,
+        confidence: 1.0,
+      }))
+    }
+
+    // Try prefix match
+    const prefix = this.db.query(
+      `SELECT symbol_name, symbol_type, file_path, line_start, line_end, signature
+       FROM code_symbols
+       WHERE project = ? AND symbol_name LIKE ? || '%'
+       LIMIT ?`
+    ).all(project, query, limit) as RawSymbolRow[]
+
+    if (prefix.length > 0) {
+      return prefix.map(row => ({
+        symbol: row.symbol_name,
+        type: row.symbol_type as any,
+        filePath: row.file_path,
+        lineStart: row.line_start,
+        lineEnd: row.line_end ?? undefined,
+        signature: row.signature ?? undefined,
+        confidence: 0.9,
+      }))
+    }
+
+    // Fall back to FTS5 search
+    try {
+      const ftsResults = this.db.query(
+        `SELECT s.symbol_name, s.symbol_type, s.file_path, s.line_start, s.line_end, s.signature,
+                rank
+         FROM code_symbols_fts fts
+         JOIN code_symbols s ON s.id = fts.rowid
+         WHERE code_symbols_fts MATCH ? AND s.project = ?
+         ORDER BY rank
+         LIMIT ?`
+      ).all(query, project, limit) as (RawSymbolRow & { rank: number })[]
+
+      if (ftsResults.length === 0) return []
+
+      // Normalize FTS5 rank to 0.5-0.85 confidence
+      const maxRank = Math.abs(ftsResults[0].rank) || 1
+      return ftsResults.map(row => ({
+        symbol: row.symbol_name,
+        type: row.symbol_type as any,
+        filePath: row.file_path,
+        lineStart: row.line_start,
+        lineEnd: row.line_end ?? undefined,
+        signature: row.signature ?? undefined,
+        confidence: 0.5 + 0.35 * (Math.abs(row.rank) / maxRank),
+      }))
+    } catch (error) {
+      // FTS5 can throw on invalid query syntax
+      this.logger.debug({ error, query }, 'FTS5 query failed, falling back to LIKE')
+
+      const likeResults = this.db.query(
+        `SELECT symbol_name, symbol_type, file_path, line_start, line_end, signature
+         FROM code_symbols
+         WHERE project = ? AND symbol_name LIKE '%' || ? || '%'
+         LIMIT ?`
+      ).all(project, query, limit) as RawSymbolRow[]
+
+      return likeResults.map(row => ({
+        symbol: row.symbol_name,
+        type: row.symbol_type as any,
+        filePath: row.file_path,
+        lineStart: row.line_start,
+        lineEnd: row.line_end ?? undefined,
+        signature: row.signature ?? undefined,
+        confidence: 0.5,
+      }))
+    }
+  }
+
+  findFiles(query: string, project: string): FileResult[] {
+    if (!query.trim()) return []
+
+    const rows = this.db.query(
+      `SELECT file_path, language, summary, symbol_count, line_count
+       FROM code_files
+       WHERE project = ? AND (file_path LIKE '%' || ? || '%' OR summary LIKE '%' || ? || '%')
+       ORDER BY file_path
+       LIMIT 50`
+    ).all(project, query, query) as RawFileRow[]
+
+    return rows.map(row => ({
+      filePath: row.file_path,
+      language: row.language ?? undefined,
+      summary: row.summary ?? undefined,
+      symbolCount: row.symbol_count,
+      lineCount: row.line_count,
+    }))
+  }
+
+  getDependencies(filePath: string, project: string): DependencyResult {
+    const imports = this.db.query(
+      `SELECT target_file, import_names
+       FROM code_dependencies
+       WHERE project = ? AND source_file = ?`
+    ).all(project, filePath) as { target_file: string; import_names: string | null }[]
+
+    const importedBy = this.db.query(
+      `SELECT source_file, import_names
+       FROM code_dependencies
+       WHERE project = ? AND target_file = ?`
+    ).all(project, filePath) as { source_file: string; import_names: string | null }[]
+
+    return {
+      file: filePath,
+      imports: imports.map(row => ({
+        file: row.target_file,
+        names: row.import_names ? row.import_names.split(', ').filter(Boolean) : [],
+      })),
+      importedBy: importedBy.map(row => ({
+        file: row.source_file,
+        names: row.import_names ? row.import_names.split(', ').filter(Boolean) : [],
+      })),
+    }
+  }
+
+  getDependents(filePath: string, project: string): DependencyResult {
+    // getDependents is the inverse view — same data, different perspective
+    return this.getDependencies(filePath, project)
+  }
+
+  getFileMap(project: string, maxEntries: number = 100): FileMapEntry[] {
+    const rows = this.db.query(
+      `SELECT f.file_path, f.language, f.summary,
+              GROUP_CONCAT(CASE WHEN s.exported = 1 THEN s.symbol_name END) as symbols
+       FROM code_files f
+       LEFT JOIN code_symbols s ON s.project = f.project AND s.file_path = f.file_path
+       WHERE f.project = ?
+       GROUP BY f.file_path
+       ORDER BY f.file_path
+       LIMIT ?`
+    ).all(project, maxEntries) as {
+      file_path: string
+      language: string | null
+      summary: string | null
+      symbols: string | null
+    }[]
+
+    // Phase 29: Count linked memories per file from observations table
+    const memoryCounts = this.getMemoryCounts(project)
+
+    return rows.map(row => ({
+      path: row.file_path,
+      language: row.language ?? undefined,
+      summary: row.summary ?? undefined,
+      symbols: row.symbols ? [...new Set(row.symbols.split(',').filter(Boolean))] : [],
+      linkedMemories: memoryCounts.get(row.file_path) ?? undefined,
+    }))
+  }
+
+  /** Phase 29: Query observations table for file path reference counts */
+  private getMemoryCounts(project: string): Map<string, number> {
+    const counts = new Map<string, number>()
+    if (!this.memoryDb) return counts
+
+    try {
+      const rows = this.memoryDb.prepare(
+        `SELECT file_paths FROM observations
+         WHERE project = ? AND file_paths IS NOT NULL AND archived = 0`
+      ).all(project) as { file_paths: string }[]
+
+      for (const row of rows) {
+        try {
+          const paths: string[] = JSON.parse(row.file_paths)
+          if (Array.isArray(paths)) {
+            for (const fp of paths) {
+              counts.set(fp, (counts.get(fp) || 0) + 1)
+            }
+          }
+        } catch {
+          // Skip malformed JSON
+        }
+      }
+    } catch (error) {
+      this.logger.debug({ error }, 'Failed to query memory counts from observations')
+    }
+
+    return counts
+  }
+
+  formatFileMap(entries: FileMapEntry[]): string {
+    const lines: string[] = []
+    let totalSize = 0
+    const MAX_SIZE = 4096 // 4KB budget
+
+    for (const entry of entries) {
+      let line = entry.path
+      if (entry.symbols.length > 0) {
+        const symbolStr = entry.symbols.length <= 5
+          ? entry.symbols.join(', ')
+          : `${entry.symbols.slice(0, 5).join(', ')} +${entry.symbols.length - 5}`
+        line += ` — ${symbolStr}`
+      }
+      if (entry.summary) {
+        line += ` — ${entry.summary}`
+      }
+      // Phase 29: Append linked memory count annotation
+      if (entry.linkedMemories && entry.linkedMemories > 0) {
+        line += ` [${entry.linkedMemories} ${entry.linkedMemories === 1 ? 'memory' : 'memories'}]`
+      }
+
+      // Check if adding this line would exceed budget
+      if (totalSize + line.length + 1 > MAX_SIZE) break
+      totalSize += line.length + 1
+      lines.push(line)
+    }
+
+    return lines.join('\n')
+  }
+
+  getStats(project: string): IndexStats {
+    const fileRow = this.db.query(
+      'SELECT COUNT(*) as cnt FROM code_files WHERE project = ?'
+    ).get(project) as { cnt: number } | null
+
+    const symbolRow = this.db.query(
+      'SELECT COUNT(*) as cnt FROM code_symbols WHERE project = ?'
+    ).get(project) as { cnt: number } | null
+
+    const lastRow = this.db.query(
+      'SELECT MAX(last_indexed) as last_indexed FROM code_files WHERE project = ?'
+    ).get(project) as { last_indexed: string | null } | null
+
+    return {
+      project,
+      filesIndexed: fileRow?.cnt ?? 0,
+      totalSymbols: symbolRow?.cnt ?? 0,
+      lastIndexed: lastRow?.last_indexed ?? null,
+      staleFiles: 0,
+    }
+  }
+}
+
+// ─── Internal Row Types ─────────────────────────────────────
+
+interface RawSymbolRow {
+  symbol_name: string
+  symbol_type: string
+  file_path: string
+  line_start: number
+  line_end: number | null
+  signature: string | null
+}
+
+interface RawFileRow {
+  file_path: string
+  language: string | null
+  summary: string | null
+  symbol_count: number
+  line_count: number
+}

package/src/code-intelligence/schema.ts

@@ -0,0 +1,83 @@
+import type { Database } from 'bun:sqlite'
+
+const CODE_INTELLIGENCE_SCHEMA = `
+-- File summaries
+CREATE TABLE IF NOT EXISTS code_files (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  project TEXT NOT NULL,
+  file_path TEXT NOT NULL,
+  language TEXT,
+  summary TEXT,
+  symbol_count INTEGER DEFAULT 0,
+  line_count INTEGER DEFAULT 0,
+  last_indexed TEXT NOT NULL,
+  file_hash TEXT,
+  UNIQUE(project, file_path)
+);
+
+-- Symbols: functions, classes, variables, exports
+CREATE TABLE IF NOT EXISTS code_symbols (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  project TEXT NOT NULL,
+  file_path TEXT NOT NULL,
+  symbol_name TEXT NOT NULL,
+  symbol_type TEXT NOT NULL,
+  line_start INTEGER NOT NULL,
+  line_end INTEGER,
+  parent_symbol TEXT,
+  signature TEXT,
+  exported BOOLEAN DEFAULT 0,
+  updated_at TEXT NOT NULL
+);
+
+-- Full-text search index on symbol names
+CREATE VIRTUAL TABLE IF NOT EXISTS code_symbols_fts USING fts5(
+  symbol_name, file_path, symbol_type, signature,
+  content='code_symbols', content_rowid='id'
+);
+
+-- FTS5 triggers to keep FTS in sync with code_symbols
+CREATE TRIGGER IF NOT EXISTS code_symbols_ai AFTER INSERT ON code_symbols BEGIN
+  INSERT INTO code_symbols_fts(rowid, symbol_name, file_path, symbol_type, signature)
+  VALUES (new.id, new.symbol_name, new.file_path, new.symbol_type, new.signature);
+END;
+
+CREATE TRIGGER IF NOT EXISTS code_symbols_ad AFTER DELETE ON code_symbols BEGIN
+  INSERT INTO code_symbols_fts(code_symbols_fts, rowid, symbol_name, file_path, symbol_type, signature)
+  VALUES ('delete', old.id, old.symbol_name, old.file_path, old.symbol_type, old.signature);
+END;
+
+CREATE TRIGGER IF NOT EXISTS code_symbols_au AFTER UPDATE ON code_symbols BEGIN
+  INSERT INTO code_symbols_fts(code_symbols_fts, rowid, symbol_name, file_path, symbol_type, signature)
+  VALUES ('delete', old.id, old.symbol_name, old.file_path, old.symbol_type, old.signature);
+  INSERT INTO code_symbols_fts(rowid, symbol_name, file_path, symbol_type, signature)
+  VALUES (new.id, new.symbol_name, new.file_path, new.symbol_type, new.signature);
+END;
+
+-- Import/export relationships
+CREATE TABLE IF NOT EXISTS code_dependencies (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  project TEXT NOT NULL,
+  source_file TEXT NOT NULL,
+  target_file TEXT NOT NULL,
+  import_names TEXT,
+  import_type TEXT
+);
+
+-- Indexes
+CREATE INDEX IF NOT EXISTS idx_symbols_project ON code_symbols(project);
+CREATE INDEX IF NOT EXISTS idx_symbols_name ON code_symbols(symbol_name);
+CREATE INDEX IF NOT EXISTS idx_symbols_file ON code_symbols(file_path);
+CREATE INDEX IF NOT EXISTS idx_files_project ON code_files(project);
+CREATE INDEX IF NOT EXISTS idx_files_path ON code_files(project, file_path);
+CREATE INDEX IF NOT EXISTS idx_deps_source ON code_dependencies(source_file);
+CREATE INDEX IF NOT EXISTS idx_deps_target ON code_dependencies(target_file);
+`
+
+/**
+ * Create the code intelligence schema tables in the given SQLite database.
+ * Safe to call multiple times — all statements use IF NOT EXISTS.
+ */
+export function createCodeSchema(db: Database): void {
+  db.exec(CODE_INTELLIGENCE_SCHEMA)
+}

package/src/code-intelligence/types.ts

@@ -0,0 +1,95 @@
+/** Supported languages for code intelligence */
+export type Language =
+  | 'typescript' | 'javascript' | 'tsx' | 'jsx'
+  | 'python' | 'go' | 'rust' | 'vue'
+  | 'html' | 'css' | 'json' | 'yaml'
+
+/** Symbol types extracted from source files */
+export type SymbolType =
+  | 'function' | 'class' | 'variable' | 'export'
+  | 'import' | 'interface' | 'type' | 'method'
+  | 'enum' | 'constant'
+
+/** A symbol extracted from a source file */
+export interface CodeSymbol {
+  name: string
+  type: SymbolType
+  filePath: string
+  lineStart: number
+  lineEnd?: number
+  parentSymbol?: string     // for methods inside classes
+  signature?: string        // function signature
+  exported: boolean
+}
+
+/** Parsed file result */
+export interface ParsedFile {
+  filePath: string
+  language: Language
+  symbols: CodeSymbol[]
+  imports: ImportInfo[]
+  lineCount: number
+}
+
+/** Import information */
+export interface ImportInfo {
+  source: string            // the module path (e.g., './auth', 'express')
+  names: string[]           // imported names (e.g., ['Router', 'Request'])
+  importType: 'import' | 'require' | 'dynamic'
+  line: number
+}
+
+/** Result of a symbol search */
+export interface SymbolResult {
+  symbol: string
+  type: SymbolType
+  filePath: string
+  lineStart: number
+  lineEnd?: number
+  signature?: string
+  confidence: number        // 0-1, how well this matches the query
+}
+
+/** Result of a file search */
+export interface FileResult {
+  filePath: string
+  language?: string
+  summary?: string
+  symbolCount: number
+  lineCount: number
+}
+
+/** Result of a dependency query */
+export interface DependencyResult {
+  file: string
+  imports: Array<{ file: string; names: string[] }>
+  importedBy: Array<{ file: string; names: string[] }>
+}
+
+/** Indexing result */
+export interface IndexResult {
+  project: string
+  filesIndexed: number
+  filesSkipped: number
+  symbolsFound: number
+  durationMs: number
+  errors: string[]
+}
+
+/** File map entry for session injection */
+export interface FileMapEntry {
+  path: string
+  language?: string
+  summary?: string
+  symbols: string[]         // top-level exported symbol names
+  linkedMemories?: number   // Phase 29: count of observations referencing this file
+}
+
+/** Index statistics for the status endpoint */
+export interface IndexStats {
+  project: string
+  filesIndexed: number
+  totalSymbols: number
+  lastIndexed: string | null
+  staleFiles: number
+}

package/src/config/defaults.ts

@@ -3,16 +3,16 @@ import type { PartialConfig } from './schema'
 
 /** Default configuration values for Claude Brain */
 export const defaultConfig: PartialConfig = {
-  vaultPath: '',
+  vaultPath: '', // Auto-detected from ~/.claude-brain/vault if empty
   serverName: 'claude-brain',
   serverVersion: pkg.version,
-  logLevel: 'info',
+  logLevel: 'warn',
   logFilePath: './logs/claude-brain.log',
   dbPath: './data/memory.db',
   port: 3000,
   enableFileWatch: true,
   cacheSize: 100,
-  nodeEnv: 'development',
+  nodeEnv: 'production',
   retrieval: {
     enabled: false,
     dense: {

package/src/config/loader.ts

@@ -167,6 +167,12 @@ export async function loadConfig(basePath: string = process.cwd()): Promise<Conf
     data.knowledge.graph.persistPath = resolveHomePath(data.knowledge.graph.persistPath)
   }
 
+  // Phase 30: Auto-detect vaultPath if not configured
+  if (!data.vaultPath) {
+    const { getHomePaths } = await import('./home')
+    data.vaultPath = getHomePaths().vault
+  }
+
   return data
 }
 

package/src/config/schema.ts

@@ -280,8 +280,8 @@ export type AdvancedIntelligenceConfig = z.infer<typeof AdvancedIntelligenceConf
 
 /** Main configuration schema for Claude Brain */
 export const ConfigSchema = z.object({
-  /** Absolute path to the Obsidian vault */
-  vaultPath: z.string().min(1, 'Vault path is required'),
+  /** Absolute path to the Obsidian vault (auto-detected if empty) */
+  vaultPath: z.string().default(''),
 
   /** MCP server identifier */
   serverName: z.string().default('claude-brain'),
@@ -332,6 +332,32 @@ export const ConfigSchema = z.object({
   intelligence: z.object({
     /** Enable consolidated intelligence features */
     enabled: z.boolean().default(false)
+  }).default({} as any),
+
+  /** Phase 26: ChromaDB configuration (now optional, SQLite FTS5 is primary) */
+  chromadb: z.object({
+    /** Enable ChromaDB vector storage backend */
+    enabled: z.boolean().default(false)
+  }).default({} as any),
+
+  /** Phase 28: Code intelligence configuration */
+  codeIntelligence: z.object({
+    /** Enable code intelligence (project indexing and file maps) */
+    enabled: z.boolean().default(true),
+  }).default({} as any),
+
+  /** Phase 30: Optional LLM compression for observations */
+  compression: z.object({
+    /** Enable LLM-based compression of long observations */
+    enabled: z.boolean().default(false),
+    /** LLM provider for compression */
+    provider: z.enum(['claude', 'ollama']).default('claude'),
+    /** Model to use for compression */
+    model: z.string().default('claude-haiku-4-5-20251001'),
+    /** API key (falls back to ANTHROPIC_API_KEY env var) */
+    apiKey: z.string().optional(),
+    /** Minimum content length to trigger compression */
+    minContentLength: z.number().default(500),
   }).default({} as any)
 })
 

package/src/health/index.ts

@@ -115,7 +115,9 @@ export class HealthChecker {
   private async checkMemory(): Promise<ComponentHealth> {
     try {
       const config = await loadConfig()
-      const memory = new MemoryManager(config.dbPath, this.logger)
+      // Phase 26: Respect chromadb.enabled config
+      const useChromaDB = config.chromadb?.enabled ?? false
+      const memory = new MemoryManager(config.dbPath, this.logger, useChromaDB)
 
       await memory.initialize()
 
@@ -156,7 +158,8 @@ export class HealthChecker {
       const vault = new VaultManager(config.vaultPath, this.logger, { backupDir: resolveHomePath('./data/backups') })
       await vault.initialize()
 
-      const memory = new MemoryManager(config.dbPath, this.logger)
+      const useChromaDB2 = config.chromadb?.enabled ?? false
+      const memory = new MemoryManager(config.dbPath, this.logger, useChromaDB2)
       await memory.initialize()
 
       const context = new ContextManager(this.logger, vault, memory)

package/src/hooks/brain-hook.ts

@@ -52,7 +52,10 @@ export async function main(): Promise<void> {
     return
   }
 
-  const port = parseInt(process.env.CLAUDE_BRAIN_PORT || '3000', 10)
+  // BUG-006: Read port from --port arg (cross-platform) or env var fallback
+  const portIdx = process.argv.indexOf('--port')
+  const portArg = portIdx >= 0 ? process.argv[portIdx + 1] : undefined
+  const port = parseInt(portArg || process.env.CLAUDE_BRAIN_PORT || '3000', 10)
 
   // For Stop events: trigger session-end summarization regardless of classification
   if (input.hook_event_name === 'Stop' && input.session_id) {