claude-brain 0.17.13 → 0.22.0

package/src/server/http-api.ts

@@ -12,6 +12,10 @@ import type { MemoryManager } from '@/memory'
 import type { CapturedKnowledge, HookStats } from '@/hooks/types'
 import { SmartDeduplicator } from '@/hooks/deduplicator'
 import type { HookSessionTracker } from '@/hooks/session-tracker'
+import type { CodeIndexer } from '@/code-intelligence/indexer'
+import type { CodeQuery } from '@/code-intelligence/query'
+import type { MemoryCodeLinker } from '@/code-intelligence/linker'
+import { setupWebViewer, setWebViewerCodeQuery } from '@/server/web-viewer'
 
 export class HttpApiServer {
   private app: Hono
@@ -19,6 +23,9 @@ export class HttpApiServer {
   private config: Config
   private server?: any
   private sessionTracker?: HookSessionTracker
+  private codeIndexer?: CodeIndexer
+  private codeQuery?: CodeQuery
+  private codeLinker?: MemoryCodeLinker
   private hookStats: HookStats = {
     totalCaptured: 0,
     totalSkipped: 0,
@@ -32,6 +39,7 @@ export class HttpApiServer {
     this.logger = logger.child({ component: 'http-api' })
     this.app = new Hono()
     this.setupMiddleware()
+    setupWebViewer(this.app)
     this.setupRoutes()
   }
 
@@ -40,7 +48,10 @@ export class HttpApiServer {
       c.header('Access-Control-Allow-Origin', '*')
       c.header('Access-Control-Allow-Methods', 'GET, POST, PATCH, DELETE, OPTIONS')
       c.header('Access-Control-Allow-Headers', 'Content-Type, Authorization')
-      c.header('Content-Type', 'application/json')
+      // Only set JSON content-type for API routes; web viewer sets its own
+      if (c.req.path.startsWith('/api/')) {
+        c.header('Content-Type', 'application/json')
+      }
       await next()
     })
   }
@@ -50,6 +61,31 @@ export class HttpApiServer {
     this.sessionTracker = tracker
   }
 
+  /** Set code intelligence services (called after initialization) */
+  setCodeIntelligence(indexer: CodeIndexer, query: CodeQuery): void {
+    this.codeIndexer = indexer
+    this.codeQuery = query
+
+    // Phase 30: Share code query with web viewer for stats
+    setWebViewerCodeQuery(query)
+
+    // Phase 29: Wire memory DB into code query for file-linked memory annotations
+    try {
+      const memoryService = getMemoryService()
+      if (memoryService?.isInitialized()) {
+        const memDb = memoryService.database.getDb()
+        this.codeQuery.setMemoryDb(memDb)
+      }
+    } catch {
+      // Memory service may not be ready yet — annotations will be empty
+    }
+  }
+
+  /** Set code linker (Phase 29) */
+  setCodeLinker(linker: MemoryCodeLinker): void {
+    this.codeLinker = linker
+  }
+
   private setupRoutes(): void {
     // Health check
     this.app.get('/api/health', (c) => {
@@ -86,6 +122,17 @@ export class HttpApiServer {
     // Phase 26: Context injection for UserPromptSubmit/SessionStart hooks
     this.app.get('/api/hooks/context-query', (c) => this.handleContextQuery(c))
 
+    // Phase 28: Code intelligence endpoints
+    this.app.post('/api/code/index', (c) => this.handleCodeIndex(c))
+    this.app.post('/api/code/reindex', (c) => this.handleCodeReindex(c))
+    this.app.get('/api/code/search', (c) => this.handleCodeSearch(c))
+    this.app.get('/api/code/file-map', (c) => this.handleCodeFileMap(c))
+    this.app.get('/api/code/deps', (c) => this.handleCodeDeps(c))
+    this.app.get('/api/code/status', (c) => this.handleCodeStatus(c))
+
+    // Phase 29: Memory-to-code linkage endpoint
+    this.app.get('/api/memory/for-file', (c) => this.handleMemoryForFile(c))
+
     // Phase 23b: Expose brain://context/auto via HTTP for testability
     this.app.get('/api/context/auto', () => this.handleContextAuto())
   }
@@ -447,6 +494,277 @@ export class HttpApiServer {
     }
   }
 
+  // ─── Phase 29: Memory-to-Code Linkage ─────────────────────
+
+  private handleMemoryForFile(c: any): Response {
+    try {
+      const file = c.req.query('file') || ''
+      const project = c.req.query('project') || ''
+
+      if (!file) {
+        return Response.json(
+          { success: false, error: 'file query parameter is required' },
+          { status: 400 }
+        )
+      }
+
+      if (!isServicesInitialized()) {
+        return Response.json({ success: true, data: { file, memoryCount: 0, summary: '' } })
+      }
+
+      const memoryService = getMemoryService()
+      if (!memoryService?.fts5) {
+        return Response.json({ success: true, data: { file, memoryCount: 0, summary: '' } })
+      }
+
+      const db = memoryService.database.getDb()
+      const likePattern = `%${file}%`
+
+      let rows: any[]
+      if (project) {
+        rows = db.prepare(`
+          SELECT id, category, content, reasoning, created_at
+          FROM observations
+          WHERE project = ? AND file_paths LIKE ? AND archived = 0
+          ORDER BY created_at DESC
+          LIMIT 5
+        `).all(project, likePattern)
+      } else {
+        rows = db.prepare(`
+          SELECT id, category, content, reasoning, created_at
+          FROM observations
+          WHERE file_paths LIKE ? AND archived = 0
+          ORDER BY created_at DESC
+          LIMIT 5
+        `).all(likePattern)
+      }
+
+      if (rows.length === 0) {
+        return Response.json({ success: true, data: { file, memoryCount: 0, summary: '' } })
+      }
+
+      const lines = rows.map((r: any) => {
+        const age = this.formatAge(r.created_at)
+        return `- [${r.category}] ${(r.content as string).slice(0, 120)} (${age})`
+      })
+
+      return Response.json({
+        success: true,
+        data: {
+          file,
+          memoryCount: rows.length,
+          summary: `Memories linked to ${file}:\n${lines.join('\n')}`
+        }
+      })
+    } catch (error) {
+      this.logger.error({ error }, 'Failed to get memories for file')
+      return Response.json(
+        { success: false, error: 'Failed to get memories for file' },
+        { status: 500 }
+      )
+    }
+  }
+
+  /** Format a date as a relative age string (e.g., "2 days ago") */
+  private 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}m ago`
+      const hours = Math.floor(minutes / 60)
+      if (hours < 24) return `${hours}h ago`
+      const days = Math.floor(hours / 24)
+      if (days === 1) return 'yesterday'
+      if (days < 30) return `${days} days ago`
+      return `${Math.floor(days / 30)} months ago`
+    } catch {
+      return ''
+    }
+  }
+
+  // ─── Phase 28: Code Intelligence Endpoints ─────────────────
+
+  private async handleCodeIndex(c: any): Promise<Response> {
+    try {
+      if (!this.codeIndexer) {
+        return Response.json(
+          { success: false, error: 'Code intelligence not initialized' },
+          { status: 503 }
+        )
+      }
+
+      const body = await c.req.json()
+      const { projectPath, projectName } = body
+
+      if (!projectPath || !projectName) {
+        return Response.json(
+          { success: false, error: 'projectPath and projectName are required' },
+          { status: 400 }
+        )
+      }
+
+      const result = await this.codeIndexer.indexProject(projectPath, projectName)
+      return Response.json({ success: true, data: result })
+    } catch (error) {
+      this.logger.error({ error }, 'Failed to index project')
+      return Response.json(
+        { success: false, error: 'Failed to index project' },
+        { status: 500 }
+      )
+    }
+  }
+
+  private async handleCodeReindex(c: any): Promise<Response> {
+    try {
+      if (!this.codeIndexer) {
+        return Response.json(
+          { success: false, error: 'Code intelligence not initialized' },
+          { status: 503 }
+        )
+      }
+
+      const body = await c.req.json()
+      const { filePath, project } = body
+
+      if (!filePath || !project) {
+        return Response.json(
+          { success: false, error: 'filePath and project are required' },
+          { status: 400 }
+        )
+      }
+
+      await this.codeIndexer.indexFile(filePath, project)
+      return Response.json({ success: true })
+    } catch (error) {
+      this.logger.error({ error }, 'Failed to reindex file')
+      return Response.json(
+        { success: false, error: 'Failed to reindex file' },
+        { status: 500 }
+      )
+    }
+  }
+
+  private handleCodeSearch(c: any): Response {
+    try {
+      if (!this.codeQuery) {
+        return Response.json(
+          { success: false, error: 'Code intelligence not initialized' },
+          { status: 503 }
+        )
+      }
+
+      const query = c.req.query('query') || ''
+      const project = c.req.query('project') || ''
+      const limit = parseInt(c.req.query('limit') || '20', 10)
+
+      if (!query || !project) {
+        return Response.json(
+          { success: false, error: 'query and project are required' },
+          { status: 400 }
+        )
+      }
+
+      const results = this.codeQuery.findSymbols(query, project, limit)
+      return Response.json({ success: true, data: results })
+    } catch (error) {
+      this.logger.error({ error }, 'Failed to search code')
+      return Response.json(
+        { success: false, error: 'Failed to search code' },
+        { status: 500 }
+      )
+    }
+  }
+
+  private handleCodeFileMap(c: any): Response {
+    try {
+      if (!this.codeQuery) {
+        return Response.json(
+          { success: false, error: 'Code intelligence not initialized' },
+          { status: 503 }
+        )
+      }
+
+      const project = c.req.query('project') || ''
+
+      if (!project) {
+        return Response.json(
+          { success: false, error: 'project is required' },
+          { status: 400 }
+        )
+      }
+
+      const entries = this.codeQuery.getFileMap(project)
+      const map = this.codeQuery.formatFileMap(entries)
+      return Response.json({ success: true, data: { map } })
+    } catch (error) {
+      this.logger.error({ error }, 'Failed to get file map')
+      return Response.json(
+        { success: false, error: 'Failed to get file map' },
+        { status: 500 }
+      )
+    }
+  }
+
+  private handleCodeDeps(c: any): Response {
+    try {
+      if (!this.codeQuery) {
+        return Response.json(
+          { success: false, error: 'Code intelligence not initialized' },
+          { status: 503 }
+        )
+      }
+
+      const file = c.req.query('file') || ''
+      const project = c.req.query('project') || ''
+
+      if (!file || !project) {
+        return Response.json(
+          { success: false, error: 'file and project are required' },
+          { status: 400 }
+        )
+      }
+
+      const result = this.codeQuery.getDependencies(file, project)
+      return Response.json({ success: true, data: result })
+    } catch (error) {
+      this.logger.error({ error }, 'Failed to get dependencies')
+      return Response.json(
+        { success: false, error: 'Failed to get dependencies' },
+        { status: 500 }
+      )
+    }
+  }
+
+  private handleCodeStatus(c: any): Response {
+    try {
+      if (!this.codeQuery) {
+        return Response.json(
+          { success: false, error: 'Code intelligence not initialized' },
+          { status: 503 }
+        )
+      }
+
+      const project = c.req.query('project') || ''
+
+      if (!project) {
+        return Response.json(
+          { success: false, error: 'project is required' },
+          { status: 400 }
+        )
+      }
+
+      const stats = this.codeQuery.getStats(project)
+      return Response.json({ success: true, data: stats })
+    } catch (error) {
+      this.logger.error({ error }, 'Failed to get code status')
+      return Response.json(
+        { success: false, error: 'Failed to get code status' },
+        { status: 500 }
+      )
+    }
+  }
+
   // ─── Phase 26: Context Query for Hook Injection ──────────
 
   private async handleContextQuery(c: any): Promise<Response> {

package/src/server/providers/resources.ts

@@ -494,48 +494,7 @@ export class ResourceProvider {
       this.logger.debug({ err }, 'Failed to get corrections for auto-context')
     }
 
-    // 5. Cross-project knowledge
-    if (projectName) {
-      try {
-        const vault = getVaultService()
-        const allProjects = await vault.reader.getProjectDirectories(vault.paths.projects)
-        const otherProjects = allProjects.filter(p => p !== projectName)
-
-        if (otherProjects.length > 0) {
-          const memory = getMemoryService()
-          if (memory.isChromaDBEnabled()) {
-            const { KnowledgeTransfer } = await import('@/intelligence/cross-project/transfer')
-            const transfer = new KnowledgeTransfer(
-              this.logger,
-              memory.chroma.collections,
-              memory.chroma.embeddings
-            )
-
-            const transferItems: string[] = []
-            // Check up to 3 other projects for transferable knowledge
-            for (const other of otherProjects.slice(0, 3)) {
-              try {
-                const result = await transfer.findTransferable(other, projectName, { limit: 2, minRelevance: 0.5 })
-                for (const item of result.items) {
-                  const truncated = item.content.length > 100 ? item.content.slice(0, 100) + '...' : item.content
-                  transferItems.push(`- [${item.type} from ${other}] ${truncated}`)
-                }
-              } catch {
-                // Skip failed transfers
-              }
-            }
-
-            if (transferItems.length > 0) {
-              sections.push('## From Other Projects\n')
-              sections.push(...transferItems)
-              sections.push('')
-            }
-          }
-        }
-      } catch (err) {
-        this.logger.debug({ err }, 'Failed to get cross-project knowledge for auto-context')
-      }
-    }
+    // 5. Cross-project knowledge (removed — KnowledgeTransfer deleted in Phase 26)
 
     // If no sections beyond the header, try auto-scan for first-session value
     if (sections.length <= 1) {

package/src/server/services.ts

@@ -19,6 +19,9 @@ import { CrossReferenceLinker } from '@/knowledge/graph/linker'
 import { EpisodeManager } from '@/memory/episodic/manager'
 import { HookSessionTracker } from '@/hooks/session-tracker'
 import type { Config } from '@/config'
+import type { CodeIndexer } from '@/code-intelligence/indexer'
+import type { CodeQuery } from '@/code-intelligence/query'
+import type { MemoryCodeLinker } from '@/code-intelligence/linker'
 import { SemanticCache } from '@/intelligence/optimization/semantic-cache'
 import { PrecomputeEngine } from '@/intelligence/optimization/precompute'
 import { MemoryArchiver } from '@/memory/consolidation/archiver'
@@ -47,6 +50,9 @@ export interface Services {
   semanticCache: SemanticCache | null
   precompute: PrecomputeEngine | null
   archiver: MemoryArchiver | null
+  codeIndexer: CodeIndexer | null
+  codeQuery: CodeQuery | null
+  codeLinker: MemoryCodeLinker | null
   logger: Logger
   config: Config
 }
@@ -78,30 +84,41 @@ export async function initializeServices(config: Config, logger: Logger): Promis
     const serviceLogger = logger.child({ component: 'services' })
     serviceLogger.info('Initializing services...')
 
-    // Validate vault path configuration
+    // Phase 30: Auto-create vault path if it doesn't exist (zero-config)
     if (!config.vaultPath) {
-      throw new Error('Vault path not configured. Set VAULT_PATH environment variable.')
+      const { getHomePaths } = await import('@/config/home')
+      config.vaultPath = getHomePaths().vault
+      serviceLogger.info({ vaultPath: config.vaultPath }, 'Auto-detected vault path')
     }
 
     if (!existsSync(config.vaultPath)) {
-      serviceLogger.warn(
-        { vaultPath: config.vaultPath },
-        'Vault path does not exist - will be created on first use'
-      )
+      try {
+        const { mkdirSync } = await import('node:fs')
+        mkdirSync(config.vaultPath, { recursive: true })
+        mkdirSync(path.join(config.vaultPath, 'Projects'), { recursive: true })
+        mkdirSync(path.join(config.vaultPath, 'Global'), { recursive: true })
+        serviceLogger.info({ vaultPath: config.vaultPath }, 'Created vault directory')
+      } catch (error) {
+        serviceLogger.warn({ error, vaultPath: config.vaultPath }, 'Failed to create vault directory, continuing without vault writes')
+      }
     } else {
       const projectsPath = path.join(config.vaultPath, 'Projects')
       if (!existsSync(projectsPath)) {
-        serviceLogger.warn(
-          { projectsPath },
-          'Projects directory missing in vault - will be created when first project is added'
-        )
+        try {
+          const { mkdirSync } = await import('node:fs')
+          mkdirSync(projectsPath, { recursive: true })
+        } catch {
+          serviceLogger.warn({ projectsPath }, 'Failed to create Projects directory')
+        }
       }
     }
 
     // Initialize Memory Manager
-    const memory = new MemoryManager(config.dbPath, logger)
+    // Phase 26: ChromaDB is now opt-in (default false), FTS5 is primary
+    const useChromaDB = config.chromadb?.enabled ?? false
+    const memory = new MemoryManager(config.dbPath, logger, useChromaDB)
     await memory.initialize()
-    serviceLogger.info('Memory service initialized')
+    serviceLogger.info({ chromadb: useChromaDB }, 'Memory service initialized')
 
     // Initialize Vault Manager
     const vault = new VaultManager(config.vaultPath, logger, {
@@ -306,6 +323,54 @@ export async function initializeServices(config: Config, logger: Logger): Promis
       }
     }
 
+    // Initialize Code Intelligence (Phase 28)
+    let codeIndexer: CodeIndexer | null = null
+    let codeQuery: CodeQuery | null = null
+    let codeLinker: MemoryCodeLinker | null = null
+    let codeDbInstance: import('bun:sqlite').Database | null = null
+    if (config.codeIntelligence?.enabled !== false) {
+      try {
+        const { Database } = await import('bun:sqlite')
+        const { resolve, dirname } = await import('node:path')
+        const { mkdirSync, existsSync } = await import('node:fs')
+        const { getClaudeBrainHome } = await import('@/config/home')
+        const codeDbDir = resolve(getClaudeBrainHome(), 'data')
+        if (!existsSync(codeDbDir)) {
+          mkdirSync(codeDbDir, { recursive: true })
+        }
+        const codeDbPath = resolve(codeDbDir, 'code.db')
+        const codeDb = new Database(codeDbPath)
+        codeDb.exec('PRAGMA journal_mode=WAL')
+        codeDbInstance = codeDb
+
+        const { CodeParser } = await import('@/code-intelligence/parser')
+        const { CodeIndexer: CodeIndexerClass } = await import('@/code-intelligence/indexer')
+        const { CodeQuery: CodeQueryClass } = await import('@/code-intelligence/query')
+
+        const parser = new CodeParser()
+        await parser.initialize()
+
+        codeIndexer = new CodeIndexerClass(codeDb, parser, serviceLogger)
+        await codeIndexer.initialize()
+
+        codeQuery = new CodeQueryClass(codeDb, serviceLogger)
+
+        serviceLogger.info('Code intelligence service initialized')
+      } catch (error) {
+        serviceLogger.warn({ error }, 'Failed to initialize code intelligence, continuing without it')
+      }
+    }
+
+    // Initialize MemoryCodeLinker (Phase 29)
+    try {
+      const { MemoryCodeLinker: LinkerClass } = await import('@/code-intelligence/linker')
+      const memoryDb = memory.database.getDb()
+      codeLinker = new LinkerClass(memoryDb, codeDbInstance, serviceLogger)
+      serviceLogger.info('Code linker initialized')
+    } catch (error) {
+      serviceLogger.warn({ error }, 'Failed to initialize code linker, continuing without it')
+    }
+
     // Store services
     services = {
       memory,
@@ -320,6 +385,9 @@ export async function initializeServices(config: Config, logger: Logger): Promis
       semanticCache,
       precompute,
       archiver,
+      codeIndexer,
+      codeQuery,
+      codeLinker,
       logger,
       config
     }
@@ -434,6 +502,30 @@ export function getArchiverService(): MemoryArchiver | null {
   return getServices().archiver
 }
 
+/**
+ * Get Code Indexer service (Phase 28)
+ * Returns null if code intelligence is not enabled
+ */
+export function getCodeIndexer(): CodeIndexer | null {
+  return services?.codeIndexer ?? null
+}
+
+/**
+ * Get Code Query service (Phase 28)
+ * Returns null if code intelligence is not enabled
+ */
+export function getCodeQuery(): CodeQuery | null {
+  return services?.codeQuery ?? null
+}
+
+/**
+ * Get Code Linker service (Phase 29)
+ * Returns null if not initialized
+ */
+export function getCodeLinker(): MemoryCodeLinker | null {
+  return services?.codeLinker ?? null
+}
+
 /**
  * Check if services are initialized
  */
@@ -516,6 +608,15 @@ export async function shutdownServices(): Promise<void> {
     serviceLogger.info('Memory archiver stopped')
   }
 
+  // Shut down code intelligence
+  if (services.codeIndexer) {
+    try {
+      serviceLogger.info('Code intelligence shut down')
+    } catch (error) {
+      serviceLogger.error({ error }, 'Failed to shut down code intelligence')
+    }
+  }
+
   // Cleanup Phase 12
   services.phase12.cleanup()