claude-brain 0.30.2 → 0.30.3

package/src/server/http-api.ts

@@ -1,1229 +1,215 @@
-/**
- * Simple HTTP API Server for Claude Brain
- * Provides basic REST API endpoints
- */
-
-import { Hono } from 'hono'
-import type { Logger } from 'pino'
-import type { Config } from '@/config'
-import { getMemoryService, getVaultService, getInferenceRouter, isServicesInitialized } from '@/server/services'
-import { ResourceProvider } from '@/server/providers/resources'
-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'
-import { getTrainingStats, getModelFeedbackStats, getDisagreements } from '@/training/data-store'
-
-export class HttpApiServer {
-  private app: Hono
-  private logger: Logger
-  private config: Config
-  private server?: any
-  private sessionTracker?: HookSessionTracker
-  private codeIndexer?: CodeIndexer
-  private codeQuery?: CodeQuery
-  private codeLinker?: MemoryCodeLinker
-  private activityTracker?: () => void
-  private hookStats: HookStats = {
-    totalCaptured: 0,
-    totalSkipped: 0,
-    totalMerged: 0,
-    sessionsTracked: 0,
-    queueSize: 0,
-  }
-
-  constructor(config: Config, logger: Logger) {
-    this.config = config
-    this.logger = logger.child({ component: 'http-api' })
-    this.app = new Hono()
-    this.setupMiddleware()
-    setupWebViewer(this.app)
-    this.setupRoutes()
-  }
-
-  /** Set activity tracker callback — called on every HTTP request for idle watchdog */
-  setActivityTracker(fn: () => void): void {
-    this.activityTracker = fn
-  }
-
-  private setupMiddleware(): void {
-    this.app.use('*', async (c, next) => {
-      // Touch activity tracker on every request (idle watchdog)
-      this.activityTracker?.()
-
-      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')
-      // 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()
-    })
-  }
-
-  /** Set the session tracker (called from serve.ts after initialization) */
-  setSessionTracker(tracker: HookSessionTracker): void {
-    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) => {
-      const initialized = isServicesInitialized()
-      return c.json({
-        success: true,
-        status: initialized ? 'ok' : 'initializing',
-        initialized,
-        timestamp: new Date().toISOString(),
-      })
-    })
-
-    // Projects endpoints
-    this.app.get('/api/projects/list', () => this.handleListProjects())
-    this.app.post('/api/projects/create', (c) => this.handleCreateProject(c))
-
-    // Simple context endpoints
-    this.app.get('/api/claude-brain/smart-context/:projectName', (c) => this.handleSmartContext(c))
-    this.app.get('/api/claude-brain/project-context/:projectName', (c) => this.handleProjectContext(c))
-    this.app.get('/api/claude-brain/recall-similar', (c) => this.handleRecallSimilar(c))
-    this.app.get('/api/claude-brain/get-decisions', () => this.handleGetDecisions())
-    this.app.get('/api/claude-brain/get-patterns', () => this.handleGetPatterns())
-    this.app.get('/api/claude-brain/get-corrections', () => this.handleGetCorrections())
-    this.app.post('/api/claude-brain/remember-decision', (c) => this.handleRememberDecision(c))
-    this.app.post('/api/claude-brain/recognize-pattern', (c) => this.handleRecognizePattern(c))
-    this.app.post('/api/claude-brain/record-correction', (c) => this.handleRecordCorrection(c))
-    this.app.post('/api/claude-brain/update-progress', (c) => this.handleUpdateProgress(c))
-
-    // Phase 17: Hook passive learning endpoints
-    this.app.post('/api/hooks/ingest', (c) => this.handleHookIngest(c))
-    this.app.post('/api/hooks/session-end', (c) => this.handleHookSessionEnd(c))
-    this.app.get('/api/hooks/status', () => this.handleHookStatus())
-
-    // 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())
-
-    // MCP proxy endpoints — allow thin proxy clients to forward tool calls via HTTP
-    this.app.get('/api/mcp/list-tools', () => this.handleMcpListTools())
-    this.app.post('/api/mcp/call-tool', (c) => this.handleMcpCallTool(c))
-
-    // Phase 6A: SLM feedback & model status endpoints
-    this.app.get('/api/models/status', () => this.handleModelsStatus())
-    this.app.get('/api/models/feedback', (c) => this.handleModelsFeedback(c))
-    this.app.get('/api/models/disagreements', (c) => this.handleModelsDisagreements(c))
-    this.app.get('/api/training/stats', () => this.handleTrainingStats())
-  }
-
-  private async handleListProjects(): Promise<Response> {
-    try {
-      if (!isServicesInitialized()) {
-        return Response.json({ success: true, data: [] })
-      }
-
-      const vaultService = getVaultService()
-      if (!vaultService) {
-        return Response.json({ success: true, data: [] })
-      }
-
-      const projectNames = await vaultService.listProjects()
-
-      const projects = []
-      for (const name of projectNames) {
-        try {
-          const metadata = await vaultService.getProjectMetadata(name)
-          projects.push({
-            id: name,
-            name,
-            techStack: metadata?.techStack || [],
-            status: metadata?.status || 'active',
-            tags: metadata?.tags || [],
-            createdAt: new Date().toISOString(),
-          })
-        } catch (error) {
-          // Skip projects that fail to load
-        }
-      }
-
-      return Response.json({ success: true, data: projects })
-    } catch (error) {
-      this.logger.error({ error }, 'Failed to list projects')
-      return Response.json(
-        { success: false, error: 'Failed to list projects' },
-        { status: 500 }
-      )
-    }
-  }
-
-  private async handleCreateProject(c: any): Promise<Response> {
-    try {
-      const body = await c.req.json()
-      const vaultService = getVaultService()
-
-      if (!vaultService) {
-        throw new Error('Vault service not initialized')
-      }
-
-      const normalizedName = body.name.replace(/\s+/g, '-').toLowerCase()
-      await vaultService.createProject(normalizedName)
-
-      const project = {
-        id: normalizedName,
-        name: normalizedName,
-        description: body.description || '',
-        techStack: body.techStack || [],
-        status: body.status || 'planning',
-        tags: body.tags || [],
-        createdAt: new Date().toISOString(),
-      }
-
-      return Response.json({ success: true, data: project })
-    } catch (error) {
-      this.logger.error({ error }, 'Failed to create project')
-      return Response.json(
-        { success: false, error: 'Failed to create project' },
-        { status: 500 }
-      )
-    }
-  }
-
-  private async handleSmartContext(c: any): Promise<Response> {
-    try {
-      const projectName = c.req.param('projectName')
-      const vaultService = getVaultService()
-
-      if (!vaultService) {
-        return Response.json({ success: true, data: {} })
-      }
-
-      const context = await vaultService.getProjectContext(projectName)
-
-      return Response.json({
-        success: true,
-        data: {
-          description: context?.content || '',
-          tech_stack: [],
-          tags: [],
-          phase: 'setup',
-          completion: 0,
-          decisions: [],
-          patterns: [],
-        },
-      })
-    } catch (error) {
-      this.logger.error({ error }, 'Failed to get smart context')
-      return Response.json(
-        { success: false, error: 'Failed to get context' },
-        { status: 500 }
-      )
-    }
-  }
-
-  private async handleProjectContext(c: any): Promise<Response> {
-    try {
-      const projectName = c.req.param('projectName')
-      const vaultService = getVaultService()
-
-      if (!vaultService) {
-        return Response.json({ success: false, error: 'Vault service not available' }, { status: 500 })
-      }
-
-      const metadata = await vaultService.getProjectMetadata(projectName)
-
-      if (!metadata) {
-        return Response.json({ success: false, error: 'Project not found' }, { status: 404 })
-      }
-
-      return Response.json({
-        success: true,
-        data: {
-          project: {
-            id: projectName,
-            name: projectName,
-            techStack: metadata.techStack,
-            status: metadata.status,
-            tags: metadata.tags,
-          },
-          progress: {
-            phase: metadata.currentPhase || 'setup',
-            completion: metadata.completionPercentage || 0,
-            completed_task: '',
-            next_steps: '',
-            notes: '',
-          },
-          decisions: [],
-          patterns: [],
-        },
-      })
-    } catch (error) {
-      this.logger.error({ error }, 'Failed to get project context')
-      return Response.json(
-        { success: false, error: 'Failed to get project context' },
-        { status: 500 }
-      )
-    }
-  }
-
-  private async handleRecallSimilar(c: any): Promise<Response> {
-    try {
-      const query = c.req.query('query') || c.req.query('q') || ''
-
-      const memoryService = getMemoryService()
-
-      if (!memoryService || !memoryService.isInitialized()) {
-        return Response.json({ success: true, data: [] })
-      }
-
-      const resultText = await memoryService.recallSimilar(query, {
-        limit: 10,
-        minSimilarity: 0.3,
-      })
-
-      const memories = resultText ? [{
-        id: 'recall-result',
-        type: 'memory',
-        title: query,
-        description: resultText,
-        timestamp: new Date().toISOString(),
-        project: '',
-        tags: [] as string[],
-        context: resultText,
-        similarity: 0.8,
-      }] : []
-
-      return Response.json({ success: true, data: memories })
-    } catch (error) {
-      this.logger.error({ error }, 'Failed to recall similar memories')
-      return Response.json(
-        { success: false, error: 'Failed to search memories' },
-        { status: 500 }
-      )
-    }
-  }
-
-  private async handleGetDecisions(): Promise<Response> {
-    try {
-      const memoryService = getMemoryService()
-
-      if (!memoryService || !memoryService.isInitialized()) {
-        return Response.json({ success: true, data: [] })
-      }
-
-      const decisions = await memoryService.fetchAllDecisions()
-
-      return Response.json({ success: true, data: decisions })
-    } catch (error) {
-      this.logger.error({ error }, 'Failed to get decisions')
-      return Response.json(
-        { success: false, error: 'Failed to get decisions' },
-        { status: 500 }
-      )
-    }
-  }
-
-  private async handleGetPatterns(): Promise<Response> {
-    try {
-      const memoryService = getMemoryService()
-
-      if (!memoryService || !memoryService.isInitialized()) {
-        return Response.json({ success: true, data: [] })
-      }
-
-      const patterns = await memoryService.getPatterns(undefined, { limit: 100 })
-
-      return Response.json({ success: true, data: patterns })
-    } catch (error) {
-      this.logger.error({ error }, 'Failed to get patterns')
-      return Response.json(
-        { success: false, error: 'Failed to get patterns' },
-        { status: 500 }
-      )
-    }
-  }
-
-  private async handleGetCorrections(): Promise<Response> {
-    try {
-      const memoryService = getMemoryService()
-
-      if (!memoryService || !memoryService.isInitialized()) {
-        return Response.json({ success: true, data: [] })
-      }
-
-      const corrections = await memoryService.getCorrections(undefined, { limit: 100 })
-
-      return Response.json({ success: true, data: corrections })
-    } catch (error) {
-      this.logger.error({ error }, 'Failed to get corrections')
-      return Response.json(
-        { success: false, error: 'Failed to get corrections' },
-        { status: 500 }
-      )
-    }
-  }
-
-  private async handleRememberDecision(c: any): Promise<Response> {
-    try {
-      const body = await c.req.json()
-      const memoryService = getMemoryService()
-
-      if (!memoryService || !memoryService.isInitialized()) {
-        throw new Error('Memory service not initialized')
-      }
-
-      await memoryService.rememberDecision(
-        body.project_name,
-        body.context || '',
-        body.decision,
-        body.reasoning || '',
-        { tags: body.tags }
-      )
-
-      return Response.json({ success: true, data: { message: 'Decision stored successfully' } })
-    } catch (error) {
-      this.logger.error({ error }, 'Failed to remember decision')
-      return Response.json(
-        { success: false, error: 'Failed to store decision' },
-        { status: 500 }
-      )
-    }
-  }
-
-  private async handleRecognizePattern(c: any): Promise<Response> {
-    try {
-      const body = await c.req.json()
-      const memoryService = getMemoryService()
-
-      if (!memoryService || !memoryService.isInitialized()) {
-        throw new Error('Memory service not initialized')
-      }
-
-      await memoryService.storePattern({
-        description: body.description,
-        pattern_type: body.pattern_type,
-        context: body.context,
-        example: body.example,
-        project: body.project_name,
-        confidence: body.confidence || 0.8,
-      })
-
-      return Response.json({ success: true, data: { message: 'Pattern stored successfully' } })
-    } catch (error) {
-      this.logger.error({ error }, 'Failed to recognize pattern')
-      return Response.json(
-        { success: false, error: 'Failed to store pattern' },
-        { status: 500 }
-      )
-    }
-  }
-
-  private async handleRecordCorrection(c: any): Promise<Response> {
-    try {
-      const body = await c.req.json()
-      const memoryService = getMemoryService()
-
-      if (!memoryService || !memoryService.isInitialized()) {
-        throw new Error('Memory service not initialized')
-      }
-
-      await memoryService.storeCorrection({
-        original: body.original,
-        correction: body.correction,
-        reasoning: body.reasoning,
-        context: body.context,
-        project: body.project_name,
-        confidence: body.confidence || 0.9,
-      })
-
-      return Response.json({ success: true, data: { message: 'Correction stored successfully' } })
-    } catch (error) {
-      this.logger.error({ error }, 'Failed to record correction')
-      return Response.json(
-        { success: false, error: 'Failed to store correction' },
-        { status: 500 }
-      )
-    }
-  }
-
-  private async handleUpdateProgress(c: any): Promise<Response> {
-    try {
-      const body = await c.req.json()
-      const vaultService = getVaultService()
-
-      if (!vaultService) {
-        throw new Error('Vault service not initialized')
-      }
-
-      const updates: any = {}
-      if (body.completed_task) {
-        updates.status = `Completed: ${body.completed_task}`
-      }
-      if (body.next_steps) updates.next_steps = body.next_steps
-      if (body.notes) updates.notes = body.notes
-
-      await vaultService.updateProgress(body.project_name, updates)
-
-      return Response.json({ success: true, data: { message: 'Progress updated successfully' } })
-    } catch (error) {
-      this.logger.error({ error }, 'Failed to update progress')
-      return Response.json(
-        { success: false, error: 'Failed to update progress' },
-        { status: 500 }
-      )
-    }
-  }
-
-  // ─── 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 ''
-    }
-  }
-
-  /** Normalize project param — extract basename if full path provided */
-  private normalizeProject(raw: string): string {
-    if (!raw) return raw
-    // If it looks like a path (contains /), extract the last segment
-    if (raw.includes('/')) {
-      return raw.split('/').filter(Boolean).pop() || raw
-    }
-    return raw
-  }
-
-  // ─── 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, force } = body
-
-      if (!projectPath || !projectName) {
-        return Response.json(
-          { success: false, error: 'projectPath and projectName are required' },
-          { status: 400 }
-        )
-      }
-
-      // 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) {
-      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') || c.req.query('q') || ''
-      const project = this.normalizeProject(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 = this.normalizeProject(c.req.query('project') || '')
-
-      if (!project) {
-        return Response.json(
-          { success: false, error: 'project query parameter is required (e.g., ?project=my-app)' },
-          { 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 = this.normalizeProject(c.req.query('project') || '')
-
-      if (!file || !project) {
-        return Response.json(
-          { success: false, error: 'file and project query parameters are required (e.g., ?file=src/index.ts&project=my-app)' },
-          { 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 = this.normalizeProject(c.req.query('project') || '')
-
-      if (!project) {
-        return Response.json(
-          { success: false, error: 'project query parameter is required (e.g., ?project=my-app)' },
-          { 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> {
-    try {
-      const query = c.req.query('query') || c.req.query('q') || ''
-      const type = c.req.query('type') || ''
-      const cwd = c.req.query('cwd') || ''
-      const limit = parseInt(c.req.query('limit') || '5', 10)
-
-      const memoryService = getMemoryService()
-      if (!memoryService || !memoryService.isInitialized()) {
-        return Response.json({ success: true, context: '' })
-      }
-
-      // Extract project name from cwd (last path segment)
-      const projectName = cwd ? cwd.split('/').filter(Boolean).pop() : undefined
-
-      let contextParts: string[] = []
-
-      if (type === 'session-start') {
-        // Broader context for session start: recent decisions + patterns
-        const [recallText, patterns] = await Promise.all([
-          memoryService.recallSimilar(projectName || 'recent work', {
-            project: projectName,
-            limit: 5,
-            minSimilarity: 0.65,
-          }),
-          memoryService.getPatterns(projectName, { limit: 5 }),
-        ])
-
-        if (recallText && recallText.trim()) {
-          contextParts.push(recallText)
-        }
-
-        if (patterns && patterns.length > 0) {
-          const patternLines = patterns
-            .slice(0, 3)
-            .map((p: any) => `- Pattern: ${p.description}`)
-            .join('\n')
-          if (patternLines) {
-            contextParts.push(patternLines)
-          }
-        }
-      } else if (query) {
-        // Query-specific recall
-        const recallText = await memoryService.recallSimilar(query, {
-          project: projectName,
-          limit,
-          minSimilarity: 0.3,
-        })
-
-        if (recallText && recallText.trim()) {
-          contextParts.push(recallText)
-        }
-      }
-
-      const context = contextParts.join('\n')
-
-      return Response.json({ success: true, context })
-    } catch (error) {
-      this.logger.error({ error }, 'Failed to get context for hook')
-      return Response.json({ success: true, context: '' })
-    }
-  }
-
-  // ─── Phase 23b: Context Auto Endpoint ────────────────────
-
-  private async handleContextAuto(): Promise<Response> {
-    try {
-      const resourceProvider = new ResourceProvider(this.logger)
-      const result = await resourceProvider.readResource('brain://context/auto')
-      const text = result?.contents?.[0]?.text || ''
-      return Response.json({ success: true, data: { content: text } })
-    } catch (error) {
-      this.logger.error({ error }, 'Failed to get auto context')
-      return Response.json(
-        { success: false, error: 'Failed to get auto context' },
-        { status: 500 }
-      )
-    }
-  }
-
-  // ─── Phase 17: Hook Endpoints ────────────────────────────
-
-  private async handleHookIngest(c: any): Promise<Response> {
-    try {
-      const body = await c.req.json()
-      const items: CapturedKnowledge[] = body.knowledge || []
-      const sessionId: string | undefined = body.sessionId
-
-      if (items.length === 0) {
-        return Response.json({ success: true, data: { stored: 0, skipped: 0, merged: 0 } })
-      }
-
-      const memoryService = getMemoryService()
-      if (!memoryService || !memoryService.isInitialized()) {
-        return Response.json(
-          { success: false, error: 'Memory service not initialized' },
-          { status: 503 }
-        )
-      }
-
-      const deduplicator = new SmartDeduplicator(this.config.hooks?.deduplication)
-      let stored = 0, skipped = 0, merged = 0
-
-      for (const knowledge of items) {
-        const action = await deduplicator.beforeStore(knowledge, memoryService)
-
-        switch (action.action) {
-          case 'skip':
-            skipped++
-            this.hookStats.totalSkipped++
-            break
-
-          case 'merge':
-            merged++
-            this.hookStats.totalMerged++
-            // For merge, we store as update — treat as new store with merged content
-            await this.storeKnowledge({ ...knowledge, content: action.mergedContent }, memoryService)
-            stored++
-            break
-
-          case 'store_new':
-            await this.storeKnowledge(knowledge, memoryService)
-            stored++
-            this.hookStats.totalCaptured++
-            break
-        }
-
-        // Track in session if sessionId provided
-        if (sessionId && this.sessionTracker) {
-          await this.sessionTracker.track(sessionId, knowledge)
-        }
-      }
-
-      this.hookStats.lastCaptureAt = new Date().toISOString()
-
-      this.logger.debug(
-        { stored, skipped, merged, sessionId },
-        'Hook ingest processed'
-      )
-
-      return Response.json({ success: true, data: { stored, skipped, merged } })
-    } catch (error) {
-      this.logger.error({ error }, 'Failed to process hook ingest')
-      return Response.json(
-        { success: false, error: 'Failed to ingest hook data' },
-        { status: 500 }
-      )
-    }
-  }
-
-  private async handleHookSessionEnd(c: any): Promise<Response> {
-    try {
-      const body = await c.req.json()
-      const sessionId: string | undefined = body.sessionId
-
-      if (!sessionId) {
-        return Response.json(
-          { success: false, error: 'sessionId required' },
-          { status: 400 }
-        )
-      }
-
-      if (this.sessionTracker) {
-        await this.sessionTracker.endSession(sessionId)
-        this.hookStats.sessionsTracked++
-      }
-
-      return Response.json({ success: true, data: { message: 'Session ended' } })
-    } catch (error) {
-      this.logger.error({ error }, 'Failed to end hook session')
-      return Response.json(
-        { success: false, error: 'Failed to end session' },
-        { status: 500 }
-      )
-    }
-  }
-
-  private handleHookStatus(): Response {
-    const sessionStats = this.sessionTracker?.getStats()
-
-    return Response.json({
-      success: true,
-      data: {
-        ...this.hookStats,
-        activeSessions: sessionStats?.activeSessions ?? 0,
-        sessionItems: sessionStats?.totalItems ?? 0,
-        hooksEnabled: this.config.hooks?.enabled ?? true,
-      },
-    })
-  }
-
-  /** Route captured knowledge to the appropriate store method */
-  private async storeKnowledge(
-    knowledge: CapturedKnowledge,
-    memoryService: MemoryManager
-  ): Promise<void> {
-    const project = knowledge.project || 'unknown'
-
-    switch (knowledge.type) {
-      case 'decision':
-        await memoryService.rememberDecision(
-          project,
-          `Captured via hook: ${knowledge.metadata.action || 'tool-use'}`,
-          knowledge.content,
-          `Auto-captured from ${knowledge.source}`,
-          { tags: knowledge.technologies }
-        )
-        break
-
-      case 'pattern':
-        await memoryService.storePattern({
-          project,
-          pattern_type: 'solution',
-          description: knowledge.content,
-          context: `Captured via hook: ${knowledge.metadata.action || 'tool-use'}`,
-          confidence: knowledge.confidence,
-        })
-        break
-
-      case 'correction':
-        await memoryService.storeCorrection({
-          project,
-          original: knowledge.metadata.command || 'Unknown',
-          correction: knowledge.content,
-          reasoning: 'Auto-captured from hook passive learning',
-          context: `Captured via hook: ${knowledge.metadata.action || 'tool-use'}`,
-          confidence: knowledge.confidence,
-        })
-        break
-
-      case 'progress': {
-        // Store in ChromaDB so it's searchable via brain tool
-        await memoryService.rememberDecision(
-          project,
-          `Captured via hook: ${knowledge.metadata.action || knowledge.metadata.source || 'progress'}`,
-          knowledge.content,
-          `Auto-captured from ${knowledge.source}`,
-          { tags: knowledge.technologies }
-        )
-
-        // Also update vault progress if project exists
-        const vaultService = getVaultService()
-        if (vaultService) {
-          try {
-            await vaultService.updateProgress(project, {
-              status: `Hook: ${knowledge.content.slice(0, 200)}`,
-            })
-          } catch {
-            // Vault might not have this project
-          }
-        }
-        break
-      }
-    }
-  }
-
-  // ─── Phase 6A: SLM Model Feedback Endpoints ────────────
-
-  private handleModelsStatus(): Response {
-    try {
-      const inferenceRouter = getInferenceRouter()
-      if (!inferenceRouter) {
-        return Response.json({
-          success: true,
-          data: { enabled: false, message: 'SLM inference not initialized' },
-        })
-      }
-      return Response.json({ success: true, data: inferenceRouter.getStatus() })
-    } catch (error) {
-      this.logger.error({ error }, 'Failed to get model status')
-      return Response.json(
-        { success: false, error: 'Failed to get model status' },
-        { status: 500 }
-      )
-    }
-  }
-
-  private handleModelsFeedback(c: any): Response {
-    try {
-      const task = c.req.query('task')
-      const stats = getModelFeedbackStats()
-
-      if (task) {
-        const taskStats = stats[task]
-        if (!taskStats) {
-          return Response.json(
-            { success: false, error: `Unknown task: ${task}` },
-            { status: 400 }
-          )
-        }
-        return Response.json({ success: true, data: { [task]: taskStats } })
-      }
-
-      return Response.json({ success: true, data: stats })
-    } catch (error) {
-      this.logger.error({ error }, 'Failed to get model feedback stats')
-      return Response.json(
-        { success: false, error: 'Failed to get model feedback stats' },
-        { status: 500 }
-      )
-    }
-  }
-
-  private handleModelsDisagreements(c: any): Response {
-    try {
-      const task = c.req.query('task') || 'intent'
-      const limit = parseInt(c.req.query('limit') || '50', 10)
-      const disagreements = getDisagreements(task, limit)
-      return Response.json({ success: true, data: disagreements })
-    } catch (error) {
-      this.logger.error({ error }, 'Failed to get model disagreements')
-      return Response.json(
-        { success: false, error: 'Failed to get model disagreements' },
-        { status: 500 }
-      )
-    }
-  }
-
-  private handleTrainingStats(): Response {
-    try {
-      const stats = getTrainingStats()
-      return Response.json({ success: true, data: stats })
-    } catch (error) {
-      this.logger.error({ error }, 'Failed to get training stats')
-      return Response.json(
-        { success: false, error: 'Failed to get training stats' },
-        { status: 500 }
-      )
-    }
-  }
-
-  // ─── MCP Proxy Endpoints ────────────────────────────────
-
-  private async handleMcpListTools(): Promise<Response> {
-    try {
-      const { handleListTools } = await import('@/server/handlers/list-tools')
-      const result = await handleListTools()
-      return Response.json({ success: true, data: result })
-    } catch (error) {
-      this.logger.error({ error }, 'Failed to list MCP tools')
-      return Response.json(
-        { success: false, error: 'Failed to list tools' },
-        { status: 500 }
-      )
-    }
-  }
-
-  private async handleMcpCallTool(c: any): Promise<Response> {
-    try {
-      const body = await c.req.json()
-      const { name, args } = body
-
-      if (!name) {
-        return Response.json(
-          { success: false, error: 'name is required' },
-          { status: 400 }
-        )
-      }
-
-      const { handleCallTool } = await import('@/server/handlers/call-tool')
-      const result = await handleCallTool(name, args || {}, this.logger)
-      return Response.json({ success: true, data: result })
-    } catch (error: any) {
-      this.logger.error({ error }, 'Failed to call MCP tool')
-      return Response.json(
-        { success: false, error: error?.message || 'Failed to call tool' },
-        { status: 500 }
-      )
-    }
-  }
-
-  async start(): Promise<void> {
-    const port = this.config.port || 3000
-
-    this.logger.info({
-      port,
-      environment: this.config.nodeEnv,
-    }, 'Starting HTTP API server...')
-
-    try {
-      this.server = Bun.serve({
-        port,
-        fetch: this.app.fetch,
-      })
-
-      this.logger.info({
-        port,
-        url: `http://localhost:${port}`,
-      }, 'HTTP API server started successfully')
-    } catch (error: any) {
-      const code = error?.code || error?.message || ''
-      if (String(code).includes('EADDRINUSE') || String(error?.message).includes('EADDRINUSE')) {
-        this.logger.error(
-          { port },
-          `Port ${port} is already in use. Another claude-brain instance may be running. ` +
-          `Kill existing instances with: pkill -f "claude-brain serve"`
-        )
-      } else {
-        this.logger.error({ error }, 'Failed to start HTTP API server')
-      }
-      throw error
-    }
-  }
-
-  async stop(): Promise<void> {
-    if (this.server) {
-      this.logger.info('Stopping HTTP API server...')
-      this.server.stop()
-      this.logger.info('HTTP API server stopped')
-    }
-  }
-
-  getApp(): Hono {
-    return this.app
-  }
-}
+/**
+ * Simple HTTP API Server for Claude Brain
+ * Provides basic REST API endpoints
+ *
+ * Route handlers are split into modules under ./routes/
+ */
+
+import { Hono } from 'hono'
+import type { Logger } from 'pino'
+import type { Config } from '@/config'
+import type { HookStats } from '@/hooks/types'
+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 { getMemoryService } from '@/server/services'
+import { setupWebViewer, setWebViewerCodeQuery } from '@/server/web-viewer'
+import { apiKeyAuth } from './middleware/auth'
+import { rateLimit } from './middleware/rate-limit'
+import { errorHandler } from './middleware/error-handler'
+import type { RouteDeps } from './routes/types'
+import { registerHealthRoutes } from './routes/health'
+import { registerProjectRoutes } from './routes/projects'
+import { registerMemoryRoutes } from './routes/memory'
+import { registerHookRoutes } from './routes/hooks'
+import { registerCodeRoutes } from './routes/code'
+import { registerContextRoutes } from './routes/context'
+import { registerMcpRoutes } from './routes/mcp'
+import { registerModelRoutes } from './routes/models'
+
+export class HttpApiServer {
+  private app: Hono
+  private logger: Logger
+  private config: Config
+  private server?: { stop: () => void; port: number }
+  private sessionTracker?: HookSessionTracker
+  private codeIndexer?: CodeIndexer
+  private codeQuery?: CodeQuery
+  private codeLinker?: MemoryCodeLinker
+  private activityTracker?: () => void
+  private hookStats: HookStats = {
+    totalCaptured: 0,
+    totalSkipped: 0,
+    totalMerged: 0,
+    sessionsTracked: 0,
+    queueSize: 0,
+  }
+
+  constructor(config: Config, logger: Logger) {
+    this.config = config
+    this.logger = logger.child({ component: 'http-api' })
+    this.app = new Hono()
+    this.setupMiddleware()
+    this.app.use('*', errorHandler(this.logger))
+    this.app.use('/api/*', rateLimit({ windowMs: 60_000, max: 200 }))
+    const authKey = process.env.CLAUDE_BRAIN_API_KEY || this.config.apiKey
+    if (authKey) {
+      this.app.use('/api/*', apiKeyAuth(authKey))
+      this.logger.info('API key authentication enabled')
+    } else {
+      this.logger.warn('No API key configured — HTTP API is unauthenticated. Set CLAUDE_BRAIN_API_KEY env var.')
+    }
+    setupWebViewer(this.app)
+    this.setupRoutes()
+  }
+
+  /** Set activity tracker callback — called on every HTTP request for idle watchdog */
+  setActivityTracker(fn: () => void): void {
+    this.activityTracker = fn
+  }
+
+  private setupMiddleware(): void {
+    // CORS: Only allow localhost origins (configurable via config)
+    const allowedOrigins = new Set([
+      'http://localhost:3333',
+      'http://127.0.0.1:3333',
+      `http://localhost:${this.config.port || 3333}`,
+      `http://127.0.0.1:${this.config.port || 3333}`,
+      // Tauri desktop app
+      'tauri://localhost',
+      'https://tauri.localhost',
+    ])
+
+    // Allow additional origins from config if present
+    if (this.config.corsOrigins) {
+      for (const origin of this.config.corsOrigins) {
+        allowedOrigins.add(origin)
+      }
+    }
+
+    this.app.use('*', async (c, next) => {
+      // Touch activity tracker on every request (idle watchdog)
+      this.activityTracker?.()
+
+      const origin = c.req.header('Origin') || ''
+
+      // Only set CORS headers for allowed origins
+      if (allowedOrigins.has(origin)) {
+        c.header('Access-Control-Allow-Origin', origin)
+        c.header('Access-Control-Allow-Credentials', 'true')
+      }
+
+      c.header('Access-Control-Allow-Methods', 'GET, POST, PATCH, DELETE, OPTIONS')
+      c.header('Access-Control-Allow-Headers', 'Content-Type, Authorization, X-API-Key')
+
+      // Handle preflight
+      if (c.req.method === 'OPTIONS') {
+        return c.body(null, 204)
+      }
+
+      // 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()
+    })
+  }
+
+  /** Set the session tracker (called from serve.ts after initialization) */
+  setSessionTracker(tracker: HookSessionTracker): void {
+    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 {
+    const deps: RouteDeps = {
+      logger: this.logger,
+      config: this.config,
+      getSessionTracker: () => this.sessionTracker,
+      getCodeIndexer: () => this.codeIndexer,
+      getCodeQuery: () => this.codeQuery,
+      getCodeLinker: () => this.codeLinker,
+      hookStats: this.hookStats,
+    }
+
+    registerHealthRoutes(this.app, deps)
+    registerProjectRoutes(this.app, deps)
+    registerMemoryRoutes(this.app, deps)
+    registerHookRoutes(this.app, deps)
+    registerCodeRoutes(this.app, deps)
+    registerContextRoutes(this.app, deps)
+    registerMcpRoutes(this.app, deps)
+    registerModelRoutes(this.app, deps)
+  }
+
+  async start(): Promise<void> {
+    const port = this.config.port || 3000
+
+    this.logger.info({
+      port,
+      environment: this.config.nodeEnv,
+    }, 'Starting HTTP API server...')
+
+    try {
+      this.server = Bun.serve({
+        port,
+        fetch: this.app.fetch,
+      })
+
+      this.logger.info({
+        port,
+        url: `http://localhost:${port}`,
+      }, 'HTTP API server started successfully')
+    } catch (error: unknown) {
+      const err = error as Record<string, unknown>
+      const code = err?.code || err?.message || ''
+      if (String(code).includes('EADDRINUSE') || String(err?.message).includes('EADDRINUSE')) {
+        this.logger.error(
+          { port },
+          `Port ${port} is already in use. Another claude-brain instance may be running. ` +
+          `Kill existing instances with: pkill -f "claude-brain serve"`
+        )
+      } else {
+        this.logger.error({ error }, 'Failed to start HTTP API server')
+      }
+      throw error
+    }
+  }
+
+  async stop(): Promise<void> {
+    if (this.server) {
+      this.logger.info('Stopping HTTP API server...')
+      this.server.stop()
+      this.logger.info('HTTP API server stopped')
+    }
+  }
+
+  getApp(): Hono {
+    return this.app
+  }
+}