claude-brain 0.17.13 → 0.22.0

package/src/cli/commands/status.ts

@@ -0,0 +1,158 @@
+/**
+ * Status Command — Phase 30
+ * Shows a system overview of Claude Brain's current state.
+ *
+ * Usage: claude-brain status
+ */
+
+import { readFileSync, existsSync } from 'node:fs'
+import { resolve, join } from 'node:path'
+import { renderLogo, theme, heading, dimText, successText, warningText, summaryPanel } from '@/cli/ui/index.js'
+import { getClaudeBrainHome } from '@/config/home'
+
+export async function runStatus() {
+  console.log()
+  console.log(renderLogo())
+  console.log()
+  console.log(heading('System Status'))
+  console.log()
+
+  // Version
+  let version = 'unknown'
+  try {
+    const pkgPath = resolve(__dirname, '..', '..', '..', 'package.json')
+    const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'))
+    version = pkg.version || 'unknown'
+  } catch {
+    // fall through
+  }
+
+  const home = getClaudeBrainHome()
+  const items: Array<{ label: string; value: string; status?: 'success' | 'warning' | 'error' | 'info' }> = []
+
+  items.push({ label: 'Version', value: `v${version}`, status: 'info' })
+
+  // Storage info
+  const dbPath = join(home, 'data', 'memory.db')
+  if (existsSync(dbPath)) {
+    try {
+      const { Database } = await import('bun:sqlite')
+      const db = new Database(dbPath, { readonly: true })
+
+      // Count observations by category
+      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
+
+      items.push({ label: 'Storage', value: 'SQLite FTS5', status: 'success' })
+      items.push({
+        label: 'Observations',
+        value: `${total} (${decisions} decisions, ${patterns} patterns, ${corrections} corrections)`,
+        status: total > 0 ? 'success' : 'warning'
+      })
+
+      // Projects
+      const projects = db.prepare('SELECT DISTINCT project FROM observations WHERE archived = 0').all() as any[]
+      items.push({
+        label: 'Projects',
+        value: projects.length > 0 ? projects.map(p => p.project).join(', ') : '(none)',
+        status: projects.length > 0 ? 'success' : 'warning'
+      })
+
+      db.close()
+    } catch {
+      items.push({ label: 'Storage', value: 'SQLite FTS5 (error reading DB)', status: 'error' })
+    }
+  } else {
+    items.push({ label: 'Storage', value: 'Not initialized', status: 'warning' })
+  }
+
+  // Code intelligence
+  const codeDbPath = join(home, 'data', 'code.db')
+  if (existsSync(codeDbPath)) {
+    try {
+      const { Database } = await import('bun:sqlite')
+      const codeDb = new Database(codeDbPath, { readonly: true })
+
+      const files = (codeDb.prepare('SELECT COUNT(*) as cnt FROM code_files').get() as any)?.cnt ?? 0
+      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 lastIndexed = latest ? formatAge(latest) : 'never'
+
+      items.push({
+        label: 'Code Index',
+        value: `${files} files, ${symbols} symbols (last indexed: ${lastIndexed})`,
+        status: files > 0 ? 'success' : 'warning'
+      })
+
+      codeDb.close()
+    } catch {
+      items.push({ label: 'Code Index', value: 'Not available', status: 'warning' })
+    }
+  } else {
+    items.push({ label: 'Code Index', value: 'Not initialized', status: 'warning' })
+  }
+
+  // Hooks status
+  const hookNames = ['PostToolUse', 'Stop', 'SessionStart', 'UserPromptSubmit']
+  const settingsPath = join(process.env.HOME || '', '.claude', 'settings.json')
+  let installedHooks: string[] = []
+  if (existsSync(settingsPath)) {
+    try {
+      const settings = JSON.parse(readFileSync(settingsPath, 'utf-8'))
+      const hooks = settings.hooks || {}
+      for (const hookName of hookNames) {
+        const hookEntries = hooks[hookName] || []
+        const hasBrain = hookEntries.some((h: any) => {
+          const cmd = typeof h === 'string' ? h : h.command || ''
+          return cmd.includes('claude-brain')
+        })
+        if (hasBrain) installedHooks.push(hookName)
+      }
+    } catch {
+      // settings parse failed
+    }
+  }
+  items.push({
+    label: 'Hooks',
+    value: installedHooks.length > 0 ? `${installedHooks.length} installed (${installedHooks.join(', ')})` : 'Not installed',
+    status: installedHooks.length > 0 ? 'success' : 'warning'
+  })
+
+  // Server status
+  const port = process.env.CLAUDE_BRAIN_PORT || '3000'
+  try {
+    const res = await fetch(`http://localhost:${port}/api/health`, {
+      signal: AbortSignal.timeout(2000)
+    })
+    if (res.ok) {
+      items.push({ label: 'Server', value: `http://localhost:${port} (running)`, status: 'success' })
+    } else {
+      items.push({ label: 'Server', value: 'Not responding', status: 'warning' })
+    }
+  } catch {
+    items.push({ label: 'Server', value: 'Not running', status: 'warning' })
+  }
+
+  console.log(summaryPanel('Claude Brain', items))
+  console.log()
+}
+
+function formatAge(isoDate: string): string {
+  try {
+    const diff = Date.now() - new Date(isoDate).getTime()
+    const minutes = Math.floor(diff / 60000)
+    if (minutes < 1) return 'just now'
+    if (minutes < 60) return `${minutes} minutes ago`
+    const hours = Math.floor(minutes / 60)
+    if (hours < 24) return `${hours} hours ago`
+    const days = Math.floor(hours / 24)
+    if (days === 1) return 'yesterday'
+    return `${days} days ago`
+  } catch {
+    return 'unknown'
+  }
+}

package/src/code-intelligence/indexer.ts

@@ -0,0 +1,315 @@
+import { Database } from 'bun:sqlite'
+import { readdir, stat } from 'node:fs/promises'
+import { join, relative, extname } from 'node:path'
+import { createHash } from 'node:crypto'
+import type { Logger } from 'pino'
+import type { CodeParser } from './parser'
+import type { IndexResult, IndexStats, ParsedFile } from './types'
+import { createCodeSchema } from './schema'
+
+const SKIP_DIRS = new Set([
+  'node_modules', '.git', 'dist', 'build', '__pycache__',
+  '.venv', 'target', '.cache', 'coverage', '.turbo', '.output', 'vendor',
+])
+
+const SKIP_FILES = new Set([
+  'package-lock.json', 'yarn.lock', 'bun.lockb', 'pnpm-lock.yaml', '.DS_Store',
+])
+
+const MAX_FILE_SIZE = 500 * 1024 // 500KB
+
+const SUPPORTED_EXTENSIONS = new Set([
+  '.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs',
+  '.py', '.go', '.rs', '.vue',
+  '.html', '.css', '.json', '.yaml', '.yml',
+])
+
+const BATCH_SIZE = 100
+
+export class CodeIndexer {
+  private db: Database
+  private parser: CodeParser
+  private logger: Logger
+
+  constructor(db: Database, parser: CodeParser, logger: Logger) {
+    this.db = db
+    this.parser = parser
+    this.logger = logger.child({ component: 'code-indexer' })
+  }
+
+  async initialize(): Promise<void> {
+    createCodeSchema(this.db)
+    this.logger.info('Code intelligence schema initialized')
+  }
+
+  async indexProject(projectPath: string, projectName: string): Promise<IndexResult> {
+    const startTime = Date.now()
+    const errors: string[] = []
+    let filesIndexed = 0
+    let filesSkipped = 0
+    let symbolsFound = 0
+
+    this.logger.info({ projectPath, projectName }, 'Starting project index')
+
+    // Collect all eligible files
+    const files = await this.collectFiles(projectPath)
+    this.logger.info({ fileCount: files.length }, 'Files collected for indexing')
+
+    // Process in batches
+    for (let i = 0; i < files.length; i += BATCH_SIZE) {
+      const batch = files.slice(i, i + BATCH_SIZE)
+      this.db.run('BEGIN TRANSACTION')
+      try {
+        for (const filePath of batch) {
+          try {
+            const result = await this.indexSingleFile(filePath, projectPath, projectName)
+            if (result.skipped) {
+              filesSkipped++
+            } else {
+              filesIndexed++
+              symbolsFound += result.symbolCount
+            }
+          } catch (error) {
+            const msg = `Failed to index ${filePath}: ${error instanceof Error ? error.message : String(error)}`
+            errors.push(msg)
+            this.logger.warn({ filePath, error }, 'Failed to index file')
+          }
+        }
+        this.db.run('COMMIT')
+      } catch (error) {
+        this.db.run('ROLLBACK')
+        const msg = `Batch failed at offset ${i}: ${error instanceof Error ? error.message : String(error)}`
+        errors.push(msg)
+        this.logger.error({ error, batchOffset: i }, 'Batch transaction failed')
+      }
+    }
+
+    const durationMs = Date.now() - startTime
+    this.logger.info(
+      { filesIndexed, filesSkipped, symbolsFound, durationMs, errors: errors.length },
+      'Project indexing complete'
+    )
+
+    return {
+      project: projectName,
+      filesIndexed,
+      filesSkipped,
+      symbolsFound,
+      durationMs,
+      errors,
+    }
+  }
+
+  async indexFile(filePath: string, projectName: string): Promise<void> {
+    this.db.run('BEGIN TRANSACTION')
+    try {
+      // Clear existing data for this file
+      this.db.run('DELETE FROM code_symbols WHERE project = ? AND file_path = ?', [projectName, filePath])
+      this.db.run('DELETE FROM code_dependencies WHERE project = ? AND source_file = ?', [projectName, filePath])
+      this.db.run('DELETE FROM code_files WHERE project = ? AND file_path = ?', [projectName, filePath])
+
+      const content = await Bun.file(filePath).text()
+      const hash = createHash('sha256').update(content).digest('hex')
+      const parsed = await this.parser.parseFile(filePath, content)
+
+      this.storeFile(parsed, projectName, hash)
+      this.storeSymbols(parsed, projectName)
+      this.storeDependencies(parsed, projectName)
+
+      this.db.run('COMMIT')
+      this.logger.debug({ filePath, symbols: parsed.symbols.length }, 'File re-indexed')
+    } catch (error) {
+      this.db.run('ROLLBACK')
+      throw error
+    }
+  }
+
+  async clearProject(projectName: string): Promise<void> {
+    this.db.run('BEGIN TRANSACTION')
+    try {
+      this.db.run('DELETE FROM code_symbols WHERE project = ?', [projectName])
+      this.db.run('DELETE FROM code_dependencies WHERE project = ?', [projectName])
+      this.db.run('DELETE FROM code_files WHERE project = ?', [projectName])
+      this.db.run('COMMIT')
+      this.logger.info({ projectName }, 'Project data cleared')
+    } catch (error) {
+      this.db.run('ROLLBACK')
+      throw error
+    }
+  }
+
+  getStats(projectName: string): IndexStats {
+    const fileRow = this.db.query(
+      'SELECT COUNT(*) as cnt FROM code_files WHERE project = ?'
+    ).get(projectName) as { cnt: number } | null
+
+    const symbolRow = this.db.query(
+      'SELECT COUNT(*) as cnt FROM code_symbols WHERE project = ?'
+    ).get(projectName) as { cnt: number } | null
+
+    const lastRow = this.db.query(
+      'SELECT MAX(last_indexed) as last_indexed FROM code_files WHERE project = ?'
+    ).get(projectName) as { last_indexed: string | null } | null
+
+    return {
+      project: projectName,
+      filesIndexed: fileRow?.cnt ?? 0,
+      totalSymbols: symbolRow?.cnt ?? 0,
+      lastIndexed: lastRow?.last_indexed ?? null,
+      staleFiles: 0, // Could be computed by comparing file hashes
+    }
+  }
+
+  generateFileSummary(parsed: ParsedFile): string {
+    const exported = parsed.symbols.filter(s => s.exported)
+    if (exported.length === 0) {
+      return `${parsed.language} file, ${parsed.lineCount} lines`
+    }
+
+    const grouped = new Map<string, string[]>()
+    for (const sym of exported) {
+      const existing = grouped.get(sym.type) ?? []
+      existing.push(sym.name)
+      grouped.set(sym.type, existing)
+    }
+
+    const parts: string[] = []
+    for (const [type, names] of grouped) {
+      if (names.length <= 3) {
+        parts.push(`${names.join(', ')} (${type})`)
+      } else {
+        parts.push(`${names.slice(0, 3).join(', ')} +${names.length - 3} (${type})`)
+      }
+    }
+
+    return parts.join(' — ')
+  }
+
+  // ─── Private Helpers ──────────────────────────────────────
+
+  private async collectFiles(dirPath: string): Promise<string[]> {
+    const files: string[] = []
+    await this.walkDirectory(dirPath, files)
+    return files
+  }
+
+  private async walkDirectory(dirPath: string, files: string[]): Promise<void> {
+    let entries
+    try {
+      entries = await readdir(dirPath, { withFileTypes: true })
+    } catch {
+      return // Skip unreadable directories
+    }
+
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        if (!SKIP_DIRS.has(entry.name)) {
+          await this.walkDirectory(join(dirPath, entry.name), files)
+        }
+      } else if (entry.isFile()) {
+        if (SKIP_FILES.has(entry.name)) continue
+        const ext = extname(entry.name).toLowerCase()
+        if (!SUPPORTED_EXTENSIONS.has(ext)) continue
+        files.push(join(dirPath, entry.name))
+      }
+    }
+  }
+
+  private async indexSingleFile(
+    filePath: string,
+    projectPath: string,
+    projectName: string
+  ): Promise<{ skipped: boolean; symbolCount: number }> {
+    // Check file size
+    const fileStats = await stat(filePath)
+    if (fileStats.size > MAX_FILE_SIZE) {
+      return { skipped: true, symbolCount: 0 }
+    }
+
+    const content = await Bun.file(filePath).text()
+    const hash = createHash('sha256').update(content).digest('hex')
+
+    // Check if file is unchanged
+    const relativePath = relative(projectPath, filePath)
+    const existing = this.db.query(
+      'SELECT file_hash FROM code_files WHERE project = ? AND file_path = ?'
+    ).get(projectName, relativePath) as { file_hash: string | null } | null
+
+    if (existing?.file_hash === hash) {
+      return { skipped: true, symbolCount: 0 }
+    }
+
+    // Clear old data for this file
+    this.db.run('DELETE FROM code_symbols WHERE project = ? AND file_path = ?', [projectName, relativePath])
+    this.db.run('DELETE FROM code_dependencies WHERE project = ? AND source_file = ?', [projectName, relativePath])
+    this.db.run('DELETE FROM code_files WHERE project = ? AND file_path = ?', [projectName, relativePath])
+
+    // Parse and store
+    const parsed = await this.parser.parseFile(filePath, content)
+    // Override filePath with relative path for storage
+    const storable: ParsedFile = { ...parsed, filePath: relativePath }
+
+    this.storeFile(storable, projectName, hash)
+    this.storeSymbols(storable, projectName)
+    this.storeDependencies(storable, projectName)
+
+    return { skipped: false, symbolCount: storable.symbols.length }
+  }
+
+  private storeFile(parsed: ParsedFile, projectName: string, hash: string): void {
+    const summary = this.generateFileSummary(parsed)
+    this.db.run(
+      `INSERT OR REPLACE INTO code_files (project, file_path, language, summary, symbol_count, line_count, last_indexed, file_hash)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
+      [
+        projectName,
+        parsed.filePath,
+        parsed.language,
+        summary,
+        parsed.symbols.length,
+        parsed.lineCount,
+        new Date().toISOString(),
+        hash,
+      ]
+    )
+  }
+
+  private storeSymbols(parsed: ParsedFile, projectName: string): void {
+    const stmt = this.db.prepare(
+      `INSERT INTO code_symbols (project, file_path, symbol_name, symbol_type, line_start, line_end, parent_symbol, signature, exported, updated_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+    )
+
+    for (const sym of parsed.symbols) {
+      stmt.run(
+        projectName,
+        parsed.filePath,
+        sym.name,
+        sym.type,
+        sym.lineStart,
+        sym.lineEnd ?? null,
+        sym.parentSymbol ?? null,
+        sym.signature ?? null,
+        sym.exported ? 1 : 0,
+        new Date().toISOString()
+      )
+    }
+  }
+
+  private storeDependencies(parsed: ParsedFile, projectName: string): void {
+    const stmt = this.db.prepare(
+      `INSERT INTO code_dependencies (project, source_file, target_file, import_names, import_type)
+       VALUES (?, ?, ?, ?, ?)`
+    )
+
+    for (const imp of parsed.imports) {
+      stmt.run(
+        projectName,
+        parsed.filePath,
+        imp.source,
+        imp.names.join(', '),
+        imp.importType
+      )
+    }
+  }
+}

package/src/code-intelligence/linker.ts

@@ -0,0 +1,178 @@
+/**
+ * MemoryCodeLinker — Phase 29: Code-Anchored Memory
+ *
+ * Links stored observations to code files automatically using three strategies:
+ * 1. Explicit file paths mentioned in content
+ * 2. Recently edited files (from activity_log)
+ * 3. Symbol name matching (from code_symbols table)
+ *
+ * All linkage is fire-and-forget — failures are non-fatal.
+ */
+
+import type { Database } from 'bun:sqlite'
+import type { Logger } from 'pino'
+
+/** Regex to extract file paths from memory content */
+const FILE_PATH_REGEX = /(?:^|\s)((?:src|lib|app|pages|components|utils|hooks|server|api|config|middleware|routes|models|services|types|scripts|tests|test)\/[\w\-./]+\.\w+)/g
+
+/** Regex to extract camelCase/PascalCase/snake_case identifiers >4 chars */
+const SYMBOL_REGEX = /\b([a-z][a-zA-Z0-9]{3,}|[A-Z][a-zA-Z0-9]{3,}|[a-z]+(?:_[a-z]+){1,})\b/g
+
+/** Max symbol candidates to query against code_symbols */
+const MAX_SYMBOL_CANDIDATES = 20
+
+export class MemoryCodeLinker {
+  constructor(
+    private memoryDb: Database,
+    private codeDb: Database | null,
+    private logger: Logger
+  ) {
+    this.logger = logger.child({ component: 'code-linker' })
+  }
+
+  /**
+   * Link an observation to relevant code files.
+   * Called after storing an observation — non-blocking, fire-and-forget.
+   * Returns the file paths that were linked.
+   */
+  async linkObservation(observationId: string, content: string, project: string): Promise<string[]> {
+    const filePaths = new Set<string>()
+    const symbols = new Set<string>()
+
+    // Strategy 1: Explicit file paths in content
+    try {
+      const explicitPaths = this.extractFilePaths(content)
+      for (const p of explicitPaths) filePaths.add(p)
+    } catch (err) {
+      this.logger.debug({ err }, 'Strategy 1 (explicit paths) failed')
+    }
+
+    // Strategy 2: Recently edited files
+    try {
+      const recentFiles = this.getRecentlyEditedFiles(project)
+      for (const p of recentFiles) filePaths.add(p)
+    } catch (err) {
+      this.logger.debug({ err }, 'Strategy 2 (recent files) failed')
+    }
+
+    // Strategy 3: Symbol name matching (only when codeDb available)
+    if (this.codeDb) {
+      try {
+        const symbolMatches = this.matchSymbols(content, project)
+        for (const match of symbolMatches) {
+          filePaths.add(match.filePath)
+          symbols.add(match.symbol)
+        }
+      } catch (err) {
+        this.logger.debug({ err }, 'Strategy 3 (symbol matching) failed')
+      }
+    }
+
+    if (filePaths.size === 0 && symbols.size === 0) {
+      return []
+    }
+
+    // Update the observation with linked paths and symbols
+    const pathsArray = [...filePaths]
+    const symbolsArray = [...symbols]
+
+    try {
+      this.memoryDb.prepare(
+        `UPDATE observations SET file_paths = ?, symbols = ?, updated_at = ? WHERE id = ?`
+      ).run(
+        JSON.stringify(pathsArray),
+        JSON.stringify(symbolsArray),
+        new Date().toISOString(),
+        observationId
+      )
+
+      this.logger.debug(
+        { observationId, paths: pathsArray.length, symbols: symbolsArray.length },
+        'Observation linked to code'
+      )
+    } catch (err) {
+      this.logger.debug({ err, observationId }, 'Failed to update observation with code links')
+    }
+
+    return pathsArray
+  }
+
+  /**
+   * Strategy 1: Extract explicit file paths from content.
+   */
+  private extractFilePaths(content: string): string[] {
+    const paths: string[] = []
+    let match: RegExpExecArray | null
+
+    // Reset regex state
+    FILE_PATH_REGEX.lastIndex = 0
+    while ((match = FILE_PATH_REGEX.exec(content)) !== null) {
+      paths.push(match[1])
+    }
+
+    return [...new Set(paths)]
+  }
+
+  /**
+   * Strategy 2: Get recently edited files from activity_log.
+   * Gracefully degrades if the table doesn't exist or has a different schema.
+   */
+  private getRecentlyEditedFiles(project: string): string[] {
+    try {
+      const rows = this.memoryDb.prepare(`
+        SELECT DISTINCT json_extract(metadata, '$.file_path') as file_path
+        FROM activity_log
+        WHERE project = ?
+          AND tool_name IN ('Write', 'Edit')
+          AND json_extract(metadata, '$.file_path') IS NOT NULL
+        ORDER BY created_at DESC
+        LIMIT 5
+      `).all(project) as { file_path: string }[]
+
+      return rows.map(r => r.file_path).filter(Boolean)
+    } catch {
+      // activity_log table may not exist — graceful degradation
+      return []
+    }
+  }
+
+  /**
+   * Strategy 3: Match potential symbol names from content against code_symbols.
+   */
+  private matchSymbols(content: string, project: string): { symbol: string; filePath: string }[] {
+    if (!this.codeDb) return []
+
+    // Extract candidate symbols from content
+    const candidates = new Set<string>()
+    let match: RegExpExecArray | null
+
+    SYMBOL_REGEX.lastIndex = 0
+    while ((match = SYMBOL_REGEX.exec(content)) !== null) {
+      if (candidates.size >= MAX_SYMBOL_CANDIDATES) break
+      candidates.add(match[1])
+    }
+
+    if (candidates.size === 0) return []
+
+    // Query code_symbols for matches
+    const results: { symbol: string; filePath: string }[] = []
+    const placeholders = [...candidates].map(() => '?').join(', ')
+
+    try {
+      const rows = this.codeDb.prepare(`
+        SELECT DISTINCT symbol_name, file_path
+        FROM code_symbols
+        WHERE project = ? AND symbol_name IN (${placeholders})
+        LIMIT 20
+      `).all(project, ...candidates) as { symbol_name: string; file_path: string }[]
+
+      for (const row of rows) {
+        results.push({ symbol: row.symbol_name, filePath: row.file_path })
+      }
+    } catch (err) {
+      this.logger.debug({ err }, 'Symbol matching query failed')
+    }
+
+    return results
+  }
+}