claude-brain 0.25.2 → 0.27.0

package/VERSION

@@ -1 +1 @@
-0.25.2
+0.27.0

package/package.json

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

package/src/routing/router.ts

@@ -13,7 +13,7 @@
 import type { Logger } from 'pino'
 import { IntentClassifier, type ClassificationResult } from './intent-classifier'
 import { BrainEntityExtractor, type BrainExtractedEntities } from './entity-extractor'
-import { ResponseFilter, type BrainResponse, type TierResults, formatCompactResponse, formatDetailResponse, formatTimeline, groupByDay } from './response-filter'
+import { ResponseFilter, type BrainResponse, type TierResults, type FilterableResult, formatCompactResponse, formatDetailResponse, formatTimeline, groupByDay } from './response-filter'
 import { SearchEngine } from './search-engine'
 import type { NormalizedResult } from './types'
 import {
@@ -24,6 +24,7 @@ import {
   getEpisodeService,
   getSessionTracker,
   getCodeLinker,
+  getCodeQuery,
   isServicesInitialized
 } from '@/server/services'
 import { timed } from '@/utils/timing'
@@ -275,6 +276,21 @@ export class BrainRouter {
       }
     }
 
+    // Phase 32: Include code file map in session context if code index is available
+    try {
+      const codeQuery = getCodeQuery()
+      if (codeQuery && project) {
+        const fileMap = codeQuery.getFileMap(project, 50)
+        if (fileMap.length > 0) {
+          const formatted = codeQuery.formatFileMap(fileMap)
+          parts.push('\n---\n## Code Structure\n')
+          parts.push(formatted)
+        }
+      }
+    } catch {
+      // Code intelligence not available
+    }
+
     // C8: Register with episode manager
     this.registerEpisodeMessage(message, project, 'session_start')
 
@@ -411,6 +427,12 @@ export class BrainRouter {
       })
     }
 
+    // Phase 32: Code intelligence — query code index for matching symbols/files
+    const codeTier = this.queryCodeIntelligence(query, searchProject)
+    if (codeTier) {
+      tiers.push(codeTier)
+    }
+
     const response = this.responseFilter.synthesize(tiers, message, displayProject)
 
     // P0: When no results found and message looks like a plain statement (not a question),
@@ -1052,6 +1074,12 @@ export class BrainRouter {
       })
     }
 
+    // Phase 32: Code intelligence — synchronous SQLite query, runs alongside async searches
+    const codeTier = this.queryCodeIntelligence(query, searchProject)
+    if (codeTier) {
+      tiers.push(codeTier)
+    }
+
     // Parallel: patterns + corrections + graph
     const [patternResults, correctionResults, graphResults] = await Promise.all([
       this.searchEngine.searchPatterns(query, { project: searchProject, limit: 3 }),
@@ -1376,6 +1404,12 @@ export class BrainRouter {
       })
     }
 
+    // Phase 32: Code intelligence for exploration queries
+    const codeTier = this.queryCodeIntelligence(query, searchProject)
+    if (codeTier) {
+      tiers.push(codeTier)
+    }
+
     return this.responseFilter.synthesize(tiers, message, displayProject, 'analyzed')
   }
 
@@ -1675,6 +1709,129 @@ export class BrainRouter {
 
   // ===== Helpers =====
 
+  /**
+   * Phase 32: Query code intelligence for symbols and files matching a query.
+   * Returns a TierResults if matches found, null otherwise.
+   * Fast operation — direct SQLite queries, no network calls.
+   */
+  private queryCodeIntelligence(query: string, project: string | undefined): TierResults | null {
+    try {
+      const codeQuery = getCodeQuery()
+      if (!codeQuery) return null
+
+      // Extract meaningful keywords from query for code search
+      const keywords = this.extractCodeKeywords(query)
+      if (keywords.length === 0) return null
+
+      const results: FilterableResult[] = []
+
+      for (const keyword of keywords) {
+        // Search symbols across all indexed projects (project may not match code index project name)
+        const symbolResults = codeQuery.findSymbols(keyword, project || '', 5)
+
+        // If no results with project filter, try without (code index may use path-based project names)
+        const symbols = symbolResults.length > 0
+          ? symbolResults
+          : codeQuery.findSymbols(keyword, '', 5)
+
+        for (const sym of symbols.slice(0, 3)) {
+          const location = sym.lineEnd
+            ? `${sym.filePath}:${sym.lineStart}-${sym.lineEnd}`
+            : `${sym.filePath}:${sym.lineStart}`
+          const sigPart = sym.signature ? ` — \`${sym.signature}\`` : ''
+          results.push({
+            content: `**${sym.symbol}** (${sym.type}) at \`${location}\`${sigPart}`,
+            score: sym.confidence * 0.6, // Scale down so memories rank higher
+            source: 'Code Index',
+            metadata: {
+              filePath: sym.filePath,
+              lineStart: sym.lineStart,
+              lineEnd: sym.lineEnd,
+              symbolType: sym.type,
+            }
+          })
+        }
+
+        // Also search files by name/summary
+        const fileResults = codeQuery.findFiles(keyword, project || '')
+        const files = fileResults.length > 0
+          ? fileResults
+          : codeQuery.findFiles(keyword, '')
+
+        for (const file of files.slice(0, 3)) {
+          // Skip if we already have symbol results from this file
+          if (results.some(r => (r.metadata as any)?.filePath === file.filePath)) continue
+          const summaryPart = file.summary ? ` — ${file.summary}` : ''
+          results.push({
+            content: `**${file.filePath}** (${file.language || 'unknown'}, ${file.symbolCount} symbols, ${file.lineCount} lines)${summaryPart}`,
+            score: 0.4, // File matches are lower confidence
+            source: 'Code Index',
+            metadata: {
+              filePath: file.filePath,
+              symbolCount: file.symbolCount,
+            }
+          })
+        }
+      }
+
+      // Deduplicate by filePath
+      const seen = new Set<string>()
+      const deduped = results.filter(r => {
+        const fp = (r.metadata as any)?.filePath
+        if (fp && seen.has(fp)) return false
+        if (fp) seen.add(fp)
+        return true
+      })
+
+      if (deduped.length === 0) return null
+
+      return {
+        label: 'Code Intelligence',
+        results: deduped.slice(0, 5)
+      }
+    } catch (error) {
+      this.logger.debug({ error }, 'Code intelligence query failed (non-fatal)')
+      return null
+    }
+  }
+
+  /**
+   * Extract meaningful keywords from a natural language query for code search.
+   * Filters out stop words and common filler, returns words likely to match code symbols.
+   */
+  private extractCodeKeywords(query: string): string[] {
+    const STOP_WORDS = new Set([
+      'how', 'what', 'where', 'when', 'why', 'who', 'which', 'are', 'is', 'was',
+      'were', 'been', 'being', 'have', 'has', 'had', 'having', 'do', 'does', 'did',
+      'doing', 'will', 'would', 'could', 'should', 'shall', 'can', 'may', 'might',
+      'must', 'the', 'a', 'an', 'and', 'but', 'or', 'nor', 'for', 'yet', 'so',
+      'in', 'on', 'at', 'to', 'from', 'by', 'with', 'about', 'into', 'through',
+      'during', 'before', 'after', 'above', 'below', 'between', 'out', 'off', 'over',
+      'under', 'again', 'further', 'then', 'once', 'here', 'there', 'all', 'each',
+      'every', 'both', 'few', 'more', 'most', 'other', 'some', 'such', 'only', 'own',
+      'same', 'than', 'too', 'very', 'just', 'because', 'not', 'this', 'that', 'these',
+      'those', 'its', 'our', 'their', 'your', 'my', 'me', 'we', 'you', 'they', 'them',
+      'know', 'tell', 'show', 'find', 'get', 'make', 'use', 'using', 'used', 'managing',
+      'managed', 'handle', 'handling', 'handled', 'work', 'working', 'works', 'implement',
+      'implementing', 'implemented', 'doing', 'done', 'project', 'code', 'file', 'function',
+    ])
+
+    const words = query.toLowerCase()
+      .replace(/[^a-z0-9\s-_]/g, ' ')
+      .split(/\s+/)
+      .filter(w => w.length > 2 && !STOP_WORDS.has(w))
+
+    // Also try multi-word phrases (camelCase/kebab-case patterns the user might reference)
+    const phrases: string[] = []
+    for (let i = 0; i < words.length - 1; i++) {
+      // Create camelCase combo: "brain router" → "brainRouter"
+      phrases.push(words[i] + words[i + 1].charAt(0).toUpperCase() + words[i + 1].slice(1))
+    }
+
+    // Return unique keywords, single words first then phrases
+    return [...new Set([...words, ...phrases])].slice(0, 5)
+  }
+
   /**
    * Phase 29: Link a stored observation to code files (non-blocking, fire-and-forget).
    */