claude-brain 0.30.2 → 0.30.3

package/src/server/routes/code.ts

@@ -0,0 +1,228 @@
+/**
+ * Code intelligence routes
+ */
+
+import type { Hono } from 'hono'
+import type { Context } from 'hono'
+import { validateBody, validateQuery } from '@/server/middleware/validate'
+import {
+  CodeIndexSchema,
+  CodeReindexSchema,
+  CodeSearchSchema,
+  ProjectQuerySchema,
+  CodeDepsQuerySchema,
+} from '@/server/schemas/api-schemas'
+import { normalizeProject } from './helpers'
+import type { RouteDeps } from './types'
+
+export function registerCodeRoutes(app: Hono, deps: RouteDeps): void {
+  app.post('/api/code/index', (c) => handleCodeIndex(c, deps))
+  app.post('/api/code/reindex', (c) => handleCodeReindex(c, deps))
+  app.get('/api/code/search', (c) => handleCodeSearch(c, deps))
+  app.get('/api/code/file-map', (c) => handleCodeFileMap(c, deps))
+  app.get('/api/code/deps', (c) => handleCodeDeps(c, deps))
+  app.get('/api/code/status', (c) => handleCodeStatus(c, deps))
+}
+
+async function handleCodeIndex(c: Context, deps: RouteDeps): Promise<Response> {
+  try {
+    const codeIndexer = deps.getCodeIndexer()
+    if (!codeIndexer) {
+      return Response.json(
+        { success: false, error: 'Code intelligence not initialized' },
+        { status: 503 }
+      )
+    }
+
+    const data = await validateBody(c, CodeIndexSchema)
+    if (!data) return Response.json({ success: false, error: 'Validation failed' }, { status: 400 })
+
+    const { projectPath, projectName, force } = data
+
+    // BUG-004: Clear existing index data when force flag is set
+    const codeQuery = deps.getCodeQuery()
+    if (force && codeQuery) {
+      try {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any -- accessing private db property for force reindex
+        const db = (codeQuery as Record<string, unknown>).db as { run: (sql: string, ...params: unknown[]) => void } | undefined
+        if (db) {
+          db.run('DELETE FROM code_files WHERE project = ?', projectName)
+          db.run('DELETE FROM code_symbols WHERE project = ?', projectName)
+          deps.logger.info({ projectName }, 'Force reindex: cleared existing data')
+        }
+      } catch (error) {
+        deps.logger.warn({ error, projectName }, 'Failed to clear index data for force reindex')
+      }
+    }
+
+    const result = await codeIndexer.indexProject(projectPath, projectName)
+    return Response.json({ success: true, data: result })
+  } catch (error) {
+    deps.logger.error({ error }, 'Failed to index project')
+    return Response.json(
+      { success: false, error: 'Failed to index project' },
+      { status: 500 }
+    )
+  }
+}
+
+async function handleCodeReindex(c: Context, deps: RouteDeps): Promise<Response> {
+  try {
+    const codeIndexer = deps.getCodeIndexer()
+    if (!codeIndexer) {
+      return Response.json(
+        { success: false, error: 'Code intelligence not initialized' },
+        { status: 503 }
+      )
+    }
+
+    const data = await validateBody(c, CodeReindexSchema)
+    if (!data) return Response.json({ success: false, error: 'Validation failed' }, { status: 400 })
+
+    const { filePath, project } = data
+
+    await codeIndexer.indexFile(filePath, project)
+    return Response.json({ success: true })
+  } catch (error) {
+    deps.logger.error({ error }, 'Failed to reindex file')
+    return Response.json(
+      { success: false, error: 'Failed to reindex file' },
+      { status: 500 }
+    )
+  }
+}
+
+function handleCodeSearch(c: Context, deps: RouteDeps): Response {
+  try {
+    const codeQuery = deps.getCodeQuery()
+    if (!codeQuery) {
+      return Response.json(
+        { success: false, error: 'Code intelligence not initialized' },
+        { status: 503 }
+      )
+    }
+
+    const params = validateQuery(c, CodeSearchSchema)
+    if (!params) {
+      return Response.json(
+        { success: false, error: 'Validation failed: query and project are required' },
+        { status: 400 }
+      )
+    }
+
+    const query = params.query
+    const project = normalizeProject(params.project)
+    const limit = params.limit
+
+    if (!query) {
+      return Response.json(
+        { success: false, error: 'query is required' },
+        { status: 400 }
+      )
+    }
+
+    const results = codeQuery.findSymbols(query, project, limit)
+    return Response.json({ success: true, data: results })
+  } catch (error) {
+    deps.logger.error({ error }, 'Failed to search code')
+    return Response.json(
+      { success: false, error: 'Failed to search code' },
+      { status: 500 }
+    )
+  }
+}
+
+function handleCodeFileMap(c: Context, deps: RouteDeps): Response {
+  try {
+    const codeQuery = deps.getCodeQuery()
+    if (!codeQuery) {
+      return Response.json(
+        { success: false, error: 'Code intelligence not initialized' },
+        { status: 503 }
+      )
+    }
+
+    const params = validateQuery(c, ProjectQuerySchema)
+    if (!params) {
+      return Response.json(
+        { success: false, error: 'Validation failed: project query parameter is required (e.g., ?project=my-app)' },
+        { status: 400 }
+      )
+    }
+
+    const project = normalizeProject(params.project)
+
+    const entries = codeQuery.getFileMap(project)
+    const map = codeQuery.formatFileMap(entries)
+    return Response.json({ success: true, data: { map } })
+  } catch (error) {
+    deps.logger.error({ error }, 'Failed to get file map')
+    return Response.json(
+      { success: false, error: 'Failed to get file map' },
+      { status: 500 }
+    )
+  }
+}
+
+function handleCodeDeps(c: Context, deps: RouteDeps): Response {
+  try {
+    const codeQuery = deps.getCodeQuery()
+    if (!codeQuery) {
+      return Response.json(
+        { success: false, error: 'Code intelligence not initialized' },
+        { status: 503 }
+      )
+    }
+
+    const params = validateQuery(c, CodeDepsQuerySchema)
+    if (!params) {
+      return Response.json(
+        { success: false, error: 'Validation failed: file and project query parameters are required (e.g., ?file=src/index.ts&project=my-app)' },
+        { status: 400 }
+      )
+    }
+
+    const file = params.file
+    const project = normalizeProject(params.project)
+
+    const result = codeQuery.getDependencies(file, project)
+    return Response.json({ success: true, data: result })
+  } catch (error) {
+    deps.logger.error({ error }, 'Failed to get dependencies')
+    return Response.json(
+      { success: false, error: 'Failed to get dependencies' },
+      { status: 500 }
+    )
+  }
+}
+
+function handleCodeStatus(c: Context, deps: RouteDeps): Response {
+  try {
+    const codeQuery = deps.getCodeQuery()
+    if (!codeQuery) {
+      return Response.json(
+        { success: false, error: 'Code intelligence not initialized' },
+        { status: 503 }
+      )
+    }
+
+    const params = validateQuery(c, ProjectQuerySchema)
+    if (!params) {
+      return Response.json(
+        { success: false, error: 'Validation failed: project query parameter is required (e.g., ?project=my-app)' },
+        { status: 400 }
+      )
+    }
+
+    const project = normalizeProject(params.project)
+
+    const stats = codeQuery.getStats(project)
+    return Response.json({ success: true, data: stats })
+  } catch (error) {
+    deps.logger.error({ error }, 'Failed to get code status')
+    return Response.json(
+      { success: false, error: 'Failed to get code status' },
+      { status: 500 }
+    )
+  }
+}

package/src/server/routes/context.ts

@@ -0,0 +1,26 @@
+/**
+ * Context routes
+ */
+
+import type { Hono } from 'hono'
+import { ResourceProvider } from '@/server/providers/resources'
+import type { RouteDeps } from './types'
+
+export function registerContextRoutes(app: Hono, deps: RouteDeps): void {
+  app.get('/api/context/auto', () => handleContextAuto(deps))
+}
+
+async function handleContextAuto(deps: RouteDeps): Promise<Response> {
+  try {
+    const resourceProvider = new ResourceProvider(deps.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) {
+    deps.logger.error({ error }, 'Failed to get auto context')
+    return Response.json(
+      { success: false, error: 'Failed to get auto context' },
+      { status: 500 }
+    )
+  }
+}

package/src/server/routes/health.ts

@@ -0,0 +1,19 @@
+/**
+ * Health check route
+ */
+
+import type { Hono } from 'hono'
+import { isServicesInitialized } from '@/server/services'
+import type { RouteDeps } from './types'
+
+export function registerHealthRoutes(app: Hono, _deps: RouteDeps): void {
+  app.get('/api/health', (c) => {
+    const initialized = isServicesInitialized()
+    return c.json({
+      success: true,
+      status: initialized ? 'ok' : 'initializing',
+      initialized,
+      timestamp: new Date().toISOString(),
+    })
+  })
+}

package/src/server/routes/helpers.ts

@@ -0,0 +1,100 @@
+/**
+ * Shared helper functions for route modules
+ */
+
+import type { MemoryManager } from '@/memory'
+import type { CapturedKnowledge } from '@/hooks/types'
+import { getVaultService } from '@/server/services'
+
+/** Format a date as a relative age string (e.g., "2 days ago") */
+export 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}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 */
+export function 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
+}
+
+/** Route captured knowledge to the appropriate store method */
+export async function 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
+    }
+  }
+}

package/src/server/routes/hooks.ts

@@ -0,0 +1,197 @@
+/**
+ * Hook routes — passive learning endpoints
+ */
+
+import type { Hono } from 'hono'
+import type { Context } from 'hono'
+import { getMemoryService } from '@/server/services'
+import { validateBody, validateQuery } from '@/server/middleware/validate'
+import {
+  IngestKnowledgeSchema,
+  SessionEndSchema,
+  ContextQuerySchema,
+} from '@/server/schemas/api-schemas'
+import type { CapturedKnowledge } from '@/hooks/types'
+import { SmartDeduplicator } from '@/hooks/deduplicator'
+import { storeKnowledge } from './helpers'
+import type { RouteDeps } from './types'
+
+export function registerHookRoutes(app: Hono, deps: RouteDeps): void {
+  app.post('/api/hooks/ingest', (c) => handleHookIngest(c, deps))
+  app.post('/api/hooks/session-end', (c) => handleHookSessionEnd(c, deps))
+  app.get('/api/hooks/status', () => handleHookStatus(deps))
+  app.get('/api/hooks/context-query', (c) => handleContextQuery(c, deps))
+}
+
+async function handleHookIngest(c: Context, deps: RouteDeps): Promise<Response> {
+  try {
+    const data = await validateBody(c, IngestKnowledgeSchema)
+    if (!data) return Response.json({ success: false, error: 'Validation failed' }, { status: 400 })
+
+    const items: CapturedKnowledge[] = data.knowledge as CapturedKnowledge[]
+    const sessionId: string | undefined = data.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(deps.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++
+          deps.hookStats.totalSkipped++
+          break
+
+        case 'merge':
+          merged++
+          deps.hookStats.totalMerged++
+          // For merge, we store as update — treat as new store with merged content
+          await storeKnowledge({ ...knowledge, content: action.mergedContent }, memoryService)
+          stored++
+          break
+
+        case 'store_new':
+          await storeKnowledge(knowledge, memoryService)
+          stored++
+          deps.hookStats.totalCaptured++
+          break
+      }
+
+      // Track in session if sessionId provided
+      const sessionTracker = deps.getSessionTracker()
+      if (sessionId && sessionTracker) {
+        await sessionTracker.track(sessionId, knowledge)
+      }
+    }
+
+    deps.hookStats.lastCaptureAt = new Date().toISOString()
+
+    deps.logger.debug(
+      { stored, skipped, merged, sessionId },
+      'Hook ingest processed'
+    )
+
+    return Response.json({ success: true, data: { stored, skipped, merged } })
+  } catch (error) {
+    deps.logger.error({ error }, 'Failed to process hook ingest')
+    return Response.json(
+      { success: false, error: 'Failed to ingest hook data' },
+      { status: 500 }
+    )
+  }
+}
+
+async function handleHookSessionEnd(c: Context, deps: RouteDeps): Promise<Response> {
+  try {
+    const data = await validateBody(c, SessionEndSchema)
+    if (!data) return Response.json({ success: false, error: 'Validation failed: sessionId required' }, { status: 400 })
+
+    const sessionId = data.sessionId
+
+    const sessionTracker = deps.getSessionTracker()
+    if (sessionTracker) {
+      await sessionTracker.endSession(sessionId)
+      deps.hookStats.sessionsTracked++
+    }
+
+    return Response.json({ success: true, data: { message: 'Session ended' } })
+  } catch (error) {
+    deps.logger.error({ error }, 'Failed to end hook session')
+    return Response.json(
+      { success: false, error: 'Failed to end session' },
+      { status: 500 }
+    )
+  }
+}
+
+function handleHookStatus(deps: RouteDeps): Response {
+  const sessionTracker = deps.getSessionTracker()
+  const sessionStats = sessionTracker?.getStats()
+
+  return Response.json({
+    success: true,
+    data: {
+      ...deps.hookStats,
+      activeSessions: sessionStats?.activeSessions ?? 0,
+      sessionItems: sessionStats?.totalItems ?? 0,
+      hooksEnabled: deps.config.hooks?.enabled ?? true,
+    },
+  })
+}
+
+async function handleContextQuery(c: Context, deps: RouteDeps): Promise<Response> {
+  try {
+    const params = validateQuery(c, ContextQuerySchema)
+    const query = params?.query ?? ''
+    const type = params?.type ?? ''
+    const cwd = params?.cwd ?? ''
+    const limit = params?.limit ?? 5
+
+    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: Record<string, unknown>) => `- 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) {
+    deps.logger.error({ error }, 'Failed to get context for hook')
+    return Response.json({ success: true, context: '' })
+  }
+}

package/src/server/routes/mcp.ts

@@ -0,0 +1,47 @@
+/**
+ * MCP proxy routes
+ */
+
+import type { Hono } from 'hono'
+import type { Context } from 'hono'
+import { validateBody } from '@/server/middleware/validate'
+import { McpCallToolSchema } from '@/server/schemas/api-schemas'
+import type { RouteDeps } from './types'
+
+export function registerMcpRoutes(app: Hono, deps: RouteDeps): void {
+  app.get('/api/mcp/list-tools', () => handleMcpListTools(deps))
+  app.post('/api/mcp/call-tool', (c) => handleMcpCallTool(c, deps))
+}
+
+async function handleMcpListTools(deps: RouteDeps): Promise<Response> {
+  try {
+    const { handleListTools } = await import('@/server/handlers/list-tools')
+    const result = await handleListTools()
+    return Response.json({ success: true, data: result })
+  } catch (error) {
+    deps.logger.error({ error }, 'Failed to list MCP tools')
+    return Response.json(
+      { success: false, error: 'Failed to list tools' },
+      { status: 500 }
+    )
+  }
+}
+
+async function handleMcpCallTool(c: Context, deps: RouteDeps): Promise<Response> {
+  try {
+    const data = await validateBody(c, McpCallToolSchema)
+    if (!data) return Response.json({ success: false, error: 'Validation failed: name is required' }, { status: 400 })
+
+    const { name, args } = data
+
+    const { handleCallTool } = await import('@/server/handlers/call-tool')
+    const result = await handleCallTool(name, args || {}, deps.logger)
+    return Response.json({ success: true, data: result })
+  } catch (error: unknown) {
+    deps.logger.error({ error }, 'Failed to call MCP tool')
+    return Response.json(
+      { success: false, error: error instanceof Error ? error.message : 'Failed to call tool' },
+      { status: 500 }
+    )
+  }
+}