claude-brain 0.30.2 → 0.30.3

package/src/server/routes/memory.ts

@@ -0,0 +1,397 @@
+/**
+ * Memory / brain routes
+ */
+
+import type { Hono } from 'hono'
+import type { Context } from 'hono'
+import { isServicesInitialized, getMemoryService, getVaultService } from '@/server/services'
+import { validateBody, validateQuery } from '@/server/middleware/validate'
+import {
+  RecallQuerySchema,
+  RememberDecisionSchema,
+  RecognizePatternSchema,
+  RecordCorrectionSchema,
+  UpdateProgressSchema,
+  FileQuerySchema,
+} from '@/server/schemas/api-schemas'
+import { formatAge } from './helpers'
+import type { RouteDeps } from './types'
+
+export function registerMemoryRoutes(app: Hono, deps: RouteDeps): void {
+  app.get('/api/claude-brain/smart-context/:projectName', (c) => handleSmartContext(c, deps))
+  app.get('/api/claude-brain/project-context/:projectName', (c) => handleProjectContext(c, deps))
+  app.get('/api/claude-brain/recall-similar', (c) => handleRecallSimilar(c, deps))
+  app.get('/api/claude-brain/get-decisions', () => handleGetDecisions(deps))
+  app.get('/api/claude-brain/get-patterns', () => handleGetPatterns(deps))
+  app.get('/api/claude-brain/get-corrections', () => handleGetCorrections(deps))
+  app.post('/api/claude-brain/remember-decision', (c) => handleRememberDecision(c, deps))
+  app.post('/api/claude-brain/recognize-pattern', (c) => handleRecognizePattern(c, deps))
+  app.post('/api/claude-brain/record-correction', (c) => handleRecordCorrection(c, deps))
+  app.post('/api/claude-brain/update-progress', (c) => handleUpdateProgress(c, deps))
+  app.get('/api/memory/for-file', (c) => handleMemoryForFile(c, deps))
+}
+
+async function handleSmartContext(c: Context, deps: RouteDeps): 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) {
+    deps.logger.error({ error }, 'Failed to get smart context')
+    return Response.json(
+      { success: false, error: 'Failed to get context' },
+      { status: 500 }
+    )
+  }
+}
+
+async function handleProjectContext(c: Context, deps: RouteDeps): 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) {
+    deps.logger.error({ error }, 'Failed to get project context')
+    return Response.json(
+      { success: false, error: 'Failed to get project context' },
+      { status: 500 }
+    )
+  }
+}
+
+async function handleRecallSimilar(c: Context, deps: RouteDeps): Promise<Response> {
+  try {
+    const params = validateQuery(c, RecallQuerySchema)
+    const query = params?.query ?? ''
+
+    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) {
+    deps.logger.error({ error }, 'Failed to recall similar memories')
+    return Response.json(
+      { success: false, error: 'Failed to search memories' },
+      { status: 500 }
+    )
+  }
+}
+
+async function handleGetDecisions(deps: RouteDeps): 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) {
+    deps.logger.error({ error }, 'Failed to get decisions')
+    return Response.json(
+      { success: false, error: 'Failed to get decisions' },
+      { status: 500 }
+    )
+  }
+}
+
+async function handleGetPatterns(deps: RouteDeps): 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) {
+    deps.logger.error({ error }, 'Failed to get patterns')
+    return Response.json(
+      { success: false, error: 'Failed to get patterns' },
+      { status: 500 }
+    )
+  }
+}
+
+async function handleGetCorrections(deps: RouteDeps): 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) {
+    deps.logger.error({ error }, 'Failed to get corrections')
+    return Response.json(
+      { success: false, error: 'Failed to get corrections' },
+      { status: 500 }
+    )
+  }
+}
+
+async function handleRememberDecision(c: Context, deps: RouteDeps): Promise<Response> {
+  try {
+    const data = await validateBody(c, RememberDecisionSchema)
+    if (!data) return Response.json({ success: false, error: 'Validation failed' }, { status: 400 })
+
+    const memoryService = getMemoryService()
+
+    if (!memoryService || !memoryService.isInitialized()) {
+      throw new Error('Memory service not initialized')
+    }
+
+    await memoryService.rememberDecision(
+      data.project_name,
+      data.context || '',
+      data.decision,
+      data.reasoning || '',
+      { tags: data.tags }
+    )
+
+    return Response.json({ success: true, data: { message: 'Decision stored successfully' } })
+  } catch (error) {
+    deps.logger.error({ error }, 'Failed to remember decision')
+    return Response.json(
+      { success: false, error: 'Failed to store decision' },
+      { status: 500 }
+    )
+  }
+}
+
+async function handleRecognizePattern(c: Context, deps: RouteDeps): Promise<Response> {
+  try {
+    const data = await validateBody(c, RecognizePatternSchema)
+    if (!data) return Response.json({ success: false, error: 'Validation failed' }, { status: 400 })
+
+    const memoryService = getMemoryService()
+
+    if (!memoryService || !memoryService.isInitialized()) {
+      throw new Error('Memory service not initialized')
+    }
+
+    await memoryService.storePattern({
+      description: data.description,
+      pattern_type: data.pattern_type,
+      context: data.context,
+      example: data.example,
+      project: data.project_name,
+      confidence: data.confidence,
+    })
+
+    return Response.json({ success: true, data: { message: 'Pattern stored successfully' } })
+  } catch (error) {
+    deps.logger.error({ error }, 'Failed to recognize pattern')
+    return Response.json(
+      { success: false, error: 'Failed to store pattern' },
+      { status: 500 }
+    )
+  }
+}
+
+async function handleRecordCorrection(c: Context, deps: RouteDeps): Promise<Response> {
+  try {
+    const data = await validateBody(c, RecordCorrectionSchema)
+    if (!data) return Response.json({ success: false, error: 'Validation failed' }, { status: 400 })
+
+    const memoryService = getMemoryService()
+
+    if (!memoryService || !memoryService.isInitialized()) {
+      throw new Error('Memory service not initialized')
+    }
+
+    await memoryService.storeCorrection({
+      original: data.original,
+      correction: data.correction,
+      reasoning: data.reasoning,
+      context: data.context,
+      project: data.project_name,
+      confidence: data.confidence,
+    })
+
+    return Response.json({ success: true, data: { message: 'Correction stored successfully' } })
+  } catch (error) {
+    deps.logger.error({ error }, 'Failed to record correction')
+    return Response.json(
+      { success: false, error: 'Failed to store correction' },
+      { status: 500 }
+    )
+  }
+}
+
+async function handleUpdateProgress(c: Context, deps: RouteDeps): Promise<Response> {
+  try {
+    const data = await validateBody(c, UpdateProgressSchema)
+    if (!data) return Response.json({ success: false, error: 'Validation failed' }, { status: 400 })
+
+    const vaultService = getVaultService()
+
+    if (!vaultService) {
+      throw new Error('Vault service not initialized')
+    }
+
+    const updates: Record<string, string> = {}
+    if (data.completed_task) {
+      updates.status = `Completed: ${data.completed_task}`
+    }
+    if (data.next_steps) updates.next_steps = data.next_steps
+    if (data.notes) updates.notes = data.notes
+
+    await vaultService.updateProgress(data.project_name, updates)
+
+    return Response.json({ success: true, data: { message: 'Progress updated successfully' } })
+  } catch (error) {
+    deps.logger.error({ error }, 'Failed to update progress')
+    return Response.json(
+      { success: false, error: 'Failed to update progress' },
+      { status: 500 }
+    )
+  }
+}
+
+function handleMemoryForFile(c: Context, deps: RouteDeps): Response {
+  try {
+    const params = validateQuery(c, FileQuerySchema)
+    if (!params) {
+      return Response.json(
+        { success: false, error: 'Validation failed: file query parameter is required' },
+        { status: 400 }
+      )
+    }
+
+    const file = params.file
+    const project = params.project || ''
+
+    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}%`
+
+    interface FileMemoryRow { id: string; category: string; content: string; reasoning: string; created_at: string }
+    let rows: FileMemoryRow[]
+    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) as FileMemoryRow[]
+    } 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) as FileMemoryRow[]
+    }
+
+    if (rows.length === 0) {
+      return Response.json({ success: true, data: { file, memoryCount: 0, summary: '' } })
+    }
+
+    const lines = rows.map((r: FileMemoryRow) => {
+      const age = 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) {
+    deps.logger.error({ error }, 'Failed to get memories for file')
+    return Response.json(
+      { success: false, error: 'Failed to get memories for file' },
+      { status: 500 }
+    )
+  }
+}

package/src/server/routes/models.ts

@@ -0,0 +1,96 @@
+/**
+ * SLM model and training routes
+ */
+
+import type { Hono } from 'hono'
+import type { Context } from 'hono'
+import { getInferenceRouter } from '@/server/services'
+import { getTrainingStats, getModelFeedbackStats, getDisagreements } from '@/training/data-store'
+import { validateQuery } from '@/server/middleware/validate'
+import {
+  ModelsFeedbackQuerySchema,
+  ModelsDisagreementsQuerySchema,
+} from '@/server/schemas/api-schemas'
+import type { RouteDeps } from './types'
+
+export function registerModelRoutes(app: Hono, deps: RouteDeps): void {
+  app.get('/api/models/status', () => handleModelsStatus(deps))
+  app.get('/api/models/feedback', (c) => handleModelsFeedback(c, deps))
+  app.get('/api/models/disagreements', (c) => handleModelsDisagreements(c, deps))
+  app.get('/api/training/stats', () => handleTrainingStats(deps))
+}
+
+function handleModelsStatus(deps: RouteDeps): 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) {
+    deps.logger.error({ error }, 'Failed to get model status')
+    return Response.json(
+      { success: false, error: 'Failed to get model status' },
+      { status: 500 }
+    )
+  }
+}
+
+function handleModelsFeedback(c: Context, deps: RouteDeps): Response {
+  try {
+    const params = validateQuery(c, ModelsFeedbackQuerySchema)
+    const task = params?.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) {
+    deps.logger.error({ error }, 'Failed to get model feedback stats')
+    return Response.json(
+      { success: false, error: 'Failed to get model feedback stats' },
+      { status: 500 }
+    )
+  }
+}
+
+function handleModelsDisagreements(c: Context, deps: RouteDeps): Response {
+  try {
+    const params = validateQuery(c, ModelsDisagreementsQuerySchema)
+    const task = params?.task ?? 'intent'
+    const limit = params?.limit ?? 50
+    const disagreements = getDisagreements(task, limit)
+    return Response.json({ success: true, data: disagreements })
+  } catch (error) {
+    deps.logger.error({ error }, 'Failed to get model disagreements')
+    return Response.json(
+      { success: false, error: 'Failed to get model disagreements' },
+      { status: 500 }
+    )
+  }
+}
+
+function handleTrainingStats(deps: RouteDeps): Response {
+  try {
+    const stats = getTrainingStats()
+    return Response.json({ success: true, data: stats })
+  } catch (error) {
+    deps.logger.error({ error }, 'Failed to get training stats')
+    return Response.json(
+      { success: false, error: 'Failed to get training stats' },
+      { status: 500 }
+    )
+  }
+}

package/src/server/routes/projects.ts

@@ -0,0 +1,89 @@
+/**
+ * Project routes
+ */
+
+import type { Hono } from 'hono'
+import type { Context } from 'hono'
+import { isServicesInitialized, getVaultService } from '@/server/services'
+import { validateBody } from '@/server/middleware/validate'
+import { CreateProjectSchema } from '@/server/schemas/api-schemas'
+import type { RouteDeps } from './types'
+
+export function registerProjectRoutes(app: Hono, deps: RouteDeps): void {
+  app.get('/api/projects/list', () => handleListProjects(deps))
+  app.post('/api/projects/create', (c) => handleCreateProject(c, deps))
+}
+
+async function handleListProjects(deps: RouteDeps): 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) {
+    deps.logger.error({ error }, 'Failed to list projects')
+    return Response.json(
+      { success: false, error: 'Failed to list projects' },
+      { status: 500 }
+    )
+  }
+}
+
+async function handleCreateProject(c: Context, deps: RouteDeps): Promise<Response> {
+  try {
+    const data = await validateBody(c, CreateProjectSchema)
+    if (!data) return Response.json({ success: false, error: 'Validation failed' }, { status: 400 })
+
+    const vaultService = getVaultService()
+
+    if (!vaultService) {
+      throw new Error('Vault service not initialized')
+    }
+
+    const normalizedName = data.name.replace(/\s+/g, '-').toLowerCase()
+    await vaultService.createProject(normalizedName)
+
+    const project = {
+      id: normalizedName,
+      name: normalizedName,
+      description: data.description || '',
+      techStack: data.techStack || [],
+      status: data.status || 'planning',
+      tags: data.tags || [],
+      createdAt: new Date().toISOString(),
+    }
+
+    return Response.json({ success: true, data: project })
+  } catch (error) {
+    deps.logger.error({ error }, 'Failed to create project')
+    return Response.json(
+      { success: false, error: 'Failed to create project' },
+      { status: 500 }
+    )
+  }
+}

package/src/server/routes/types.ts

@@ -0,0 +1,21 @@
+/**
+ * Shared types for route modules
+ */
+
+import type { Logger } from 'pino'
+import type { Config } from '@/config'
+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 type { HookStats } from '@/hooks/types'
+
+export interface RouteDeps {
+  logger: Logger
+  config: Config
+  getSessionTracker: () => HookSessionTracker | undefined
+  getCodeIndexer: () => CodeIndexer | undefined
+  getCodeQuery: () => CodeQuery | undefined
+  getCodeLinker: () => MemoryCodeLinker | undefined
+  hookStats: HookStats
+}