claude-brain 0.5.0 → 0.8.0

package/src/server/handlers/list-tools.ts

@@ -1,18 +1,35 @@
 /**
  * List Tools Handler
  * Handles the MCP tools/list request
+ *
+ * In unified tool mode (Phase 16), only the brain() tool is exposed.
+ * In legacy mode, all 25 tools + brain are exposed.
  */
 
 import { ToolRegistry } from '@/tools/registry'
+import { getServices, isServicesInitialized } from '@/server/services'
 
 /**
  * Handle tools/list request
- * Returns all available tools in MCP format
+ * Returns available tools in MCP format, filtered by config
  */
 export async function handleListTools() {
-  const tools = ToolRegistry.getToolsForListResponse()
-
-  return {
-    tools
+  // Check if unified tool mode is enabled
+  if (isServicesInitialized()) {
+    try {
+      const { config } = getServices()
+      if (config.unifiedToolMode) {
+        const brainTool = ToolRegistry.getToolByName('brain')
+        return {
+          tools: brainTool ? [brainTool] : []
+        }
+      }
+    } catch {
+      // Services not ready, fall through to default
+    }
   }
+
+  // Default: return all tools (legacy + brain)
+  const tools = ToolRegistry.getToolsForListResponse()
+  return { tools }
 }

package/src/server/handlers/tools/brain.ts

@@ -0,0 +1,85 @@
+/**
+ * Brain Tool Handler
+ * Phase 16: Unified single tool that replaces all 25 MCP tools
+ *
+ * Accepts natural language, classifies intent server-side,
+ * routes internally, and returns a unified response.
+ */
+
+import type { Logger } from 'pino'
+import type { ToolResponse } from '@/tools/types'
+import { ToolValidator } from '@/server/utils/validators'
+import { ResponseFormatter } from '@/server/utils/response-formatter'
+import { withMemoryIndicator } from '@/server/utils/memory-indicator'
+import { ErrorHandler } from '@/server/utils/error-handler'
+import { McpError, ErrorCode } from '@modelcontextprotocol/sdk/types.js'
+import { BrainSchema } from './schemas'
+import { getBrainRouter } from '@/routing/router'
+
+export async function handleBrain(
+  args: unknown,
+  logger: Logger
+): Promise<ToolResponse> {
+  try {
+    const input = ToolValidator.validate(args, BrainSchema)
+    const { message, project } = input
+
+    logger.debug(
+      {
+        messageLength: message.length,
+        project,
+        messagePreview: message.slice(0, 80)
+      },
+      'Brain tool called'
+    )
+
+    const router = getBrainRouter(logger)
+    const response = await router.route({ message, project })
+
+    logger.info(
+      {
+        action: response.action,
+        summary: response.summary,
+        relevantItems: response.relevantItems
+      },
+      'Brain tool response'
+    )
+
+    // Format response
+    if (response.action === 'none' && !response.content) {
+      return ResponseFormatter.text(response.summary || 'No action needed.')
+    }
+
+    const parts: string[] = []
+
+    if (response.summary) {
+      parts.push(`**${response.summary}**`)
+      parts.push('')
+    }
+
+    if (response.content) {
+      parts.push(response.content)
+    }
+
+    const content = parts.join('\n')
+
+    // Add memory indicator if we found relevant items
+    if (response.relevantItems > 0 && response.action === 'retrieved') {
+      return ResponseFormatter.text(withMemoryIndicator(content, response.relevantItems))
+    }
+
+    return ResponseFormatter.text(content)
+
+  } catch (error) {
+    ErrorHandler.logError(logger, error, { tool: 'brain', args })
+
+    if (error instanceof McpError) {
+      throw error
+    }
+
+    throw new McpError(
+      ErrorCode.InternalError,
+      `Brain tool failed: ${error instanceof Error ? error.message : 'Unknown error'}`
+    )
+  }
+}

package/src/server/handlers/tools/init-project.ts

@@ -11,8 +11,11 @@ import { ToolValidator } from '@/server/utils/validators'
 import { ResponseFormatter } from '@/server/utils/response-formatter'
 import { ErrorHandler } from '@/server/utils/error-handler'
 import { McpError, ErrorCode } from '@modelcontextprotocol/sdk/types.js'
+import { PackManager, PackLoader, type PackLoadResult } from '@/packs/index'
 import fs from 'fs/promises'
 import path from 'path'
+import { fileURLToPath } from 'node:url'
+import { dirname, resolve } from 'node:path'
 
 interface InitProjectInput {
   project_path?: string
@@ -176,6 +179,36 @@ Has TypeScript: ${analysis.hasTypeScript}
       logger.info({ normalizedName }, 'Project saved to memory')
     }
 
+    // Phase 18: Load knowledge packs based on detected tech stack
+    let packResult: PackLoadResult | null = null
+    try {
+      const initFile = fileURLToPath(import.meta.url)
+      const initDir = dirname(initFile)
+      const PACKAGE_ROOT = resolve(initDir, '..', '..', '..', '..')
+      const dataDir = path.join(process.env.CLAUDE_BRAIN_HOME || path.join(process.env.HOME || '~', '.claude-brain'), 'data')
+
+      // Default packs config
+      const packsConfig = {
+        enabled: true,
+        packsDir: 'packs',
+        alwaysLoadCore: true,
+        alwaysLoadMeta: true,
+        communityConfidenceMultiplier: 0.8,
+        personalBoost: 1.2,
+        projectBoost: 1.15
+      }
+
+      if (packsConfig.enabled) {
+        const memory = getMemoryService()
+        const packManager = new PackManager(logger, packsConfig, PACKAGE_ROOT, dataDir)
+        const packLoader = new PackLoader(logger, memory, packManager, packsConfig)
+        packResult = await packLoader.loadPacksForProject(normalizedName, analysis.techStack)
+        logger.info({ packResult }, 'Knowledge packs loaded')
+      }
+    } catch (packError) {
+      logger.warn({ error: packError }, 'Pack loading failed (non-blocking)')
+    }
+
     // Build response
     const parts: string[] = []
     parts.push(`## ${projectExists ? '🔄 Project Updated' : '✅ Project Initialized'}: ${normalizedName}\n`)
@@ -226,6 +259,20 @@ Has TypeScript: ${analysis.hasTypeScript}
       parts.push(`Project context saved to semantic memory for future recall.`)
     }
 
+    if (packResult && packResult.packsLoaded > 0) {
+      parts.push(`\n### Knowledge Packs`)
+      parts.push(`Loaded **${packResult.packsLoaded}** pack(s) with **${packResult.entriesLoaded}** entries:`)
+      for (const detail of packResult.packDetails) {
+        parts.push(`- **${detail.name}** (${detail.entriesLoaded} entries)`)
+      }
+      if (packResult.skipped.length > 0) {
+        parts.push(`\nSkipped: ${packResult.skipped.map(s => `${s.packId} (${s.reason})`).join(', ')}`)
+      }
+    } else if (packResult && packResult.skipped.length > 0) {
+      parts.push(`\n### Knowledge Packs`)
+      parts.push(`All packs already loaded (${packResult.skipped.length} skipped).`)
+    }
+
     parts.push(`\n### Next Steps`)
     parts.push(`1. Use \`get_project_context("${normalizedName}")\` to view full context`)
     parts.push(`2. Use \`remember_decision\` to save architectural decisions`)

package/src/server/handlers/tools/schemas.ts

@@ -209,6 +209,15 @@ export const FindCrossProjectPatternsSchema = z.object({
   query: z.string().optional()
 })
 
+// ============================================================================
+// Phase 16 - Unified Brain Tool
+// ============================================================================
+
+export const BrainSchema = z.object({
+  message: z.string().min(1, 'message is required'),
+  project: z.string().optional()
+})
+
 // ============================================================================
 // Type exports for validated inputs
 // ============================================================================
@@ -239,3 +248,6 @@ export type ValidatedDetectTrends = z.infer<typeof DetectTrendsSchema>
 export type ValidatedWhatIfAnalysis = z.infer<typeof WhatIfAnalysisSchema>
 export type ValidatedGetRecommendations = z.infer<typeof GetRecommendationsSchema>
 export type ValidatedFindCrossProjectPatterns = z.infer<typeof FindCrossProjectPatternsSchema>
+
+// Phase 16
+export type ValidatedBrain = z.infer<typeof BrainSchema>

package/src/server/http-api.ts

@@ -7,12 +7,24 @@ import { Hono } from 'hono'
 import type { Logger } from 'pino'
 import type { Config } from '@/config'
 import { getMemoryService, getVaultService, isServicesInitialized } from '@/server/services'
+import type { MemoryManager } from '@/memory'
+import type { CapturedKnowledge, HookStats } from '@/hooks/types'
+import { SmartDeduplicator } from '@/hooks/deduplicator'
+import type { HookSessionTracker } from '@/hooks/session-tracker'
 
 export class HttpApiServer {
   private app: Hono
   private logger: Logger
   private config: Config
   private server?: any
+  private sessionTracker?: HookSessionTracker
+  private hookStats: HookStats = {
+    totalCaptured: 0,
+    totalSkipped: 0,
+    totalMerged: 0,
+    sessionsTracked: 0,
+    queueSize: 0,
+  }
 
   constructor(config: Config, logger: Logger) {
     this.config = config
@@ -32,6 +44,11 @@ export class HttpApiServer {
     })
   }
 
+  /** Set the session tracker (called from serve.ts after initialization) */
+  setSessionTracker(tracker: HookSessionTracker): void {
+    this.sessionTracker = tracker
+  }
+
   private setupRoutes(): void {
     // Health check
     this.app.get('/api/health', (c) => {
@@ -59,6 +76,11 @@ export class HttpApiServer {
     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())
   }
 
   private async handleListProjects(): Promise<Response> {
@@ -436,6 +458,172 @@ export class HttpApiServer {
     }
   }
 
+  // ─── 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 ?? false,
+      },
+    })
+  }
+
+  /** 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': {
+        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
+      }
+    }
+  }
+
   async start(): Promise<void> {
     const port = this.config.port || 3000
 

package/src/tools/registry.ts

@@ -69,6 +69,15 @@ export class ToolRegistry {
     return Object.values(TOOLS)
   }
 
+  /**
+   * Get only the unified brain tool (Phase 16)
+   * @returns Array containing only the brain tool
+   */
+  static getUnifiedTools(): ToolDefinition[] {
+    const brain = this.getToolByName('brain')
+    return brain ? [brain] : []
+  }
+
   /**
    * Validate that required parameters are present
    * @param toolName - Name of the tool

package/src/tools/schemas.ts

@@ -9,7 +9,7 @@
  */
 
 /** Tool definition type */
-interface ToolDefinition {
+export interface ToolDefinition {
   name: string
   description: string
   inputSchema: {
@@ -895,6 +895,38 @@ export const TOOLS = {
         }
       }
     }
+  },
+  // =========================================================================
+  // Phase 16 - Unified Brain Tool
+  // =========================================================================
+
+  /**
+   * BRAIN
+   * Unified intelligent tool that replaces all 25 tools
+   *
+   * Use this when:
+   * - You want a single tool for all Claude Brain interactions
+   * - Enabled via unifiedToolMode config flag
+   *
+   * The server classifies intent and routes internally
+   */
+  BRAIN: {
+    name: 'brain',
+    description: 'Your intelligent memory. Tell it what you are doing in natural language. The server classifies intent and routes internally — no need to pick the right tool.',
+    inputSchema: {
+      type: 'object' as const,
+      properties: {
+        message: {
+          type: 'string',
+          description: 'What you are doing, decided, learned, or need. Natural language.'
+        },
+        project: {
+          type: 'string',
+          description: 'Project name (optional — auto-detected from message if omitted)'
+        }
+      },
+      required: ['message']
+    }
   }
 } as const satisfies Record<string, ToolDefinition>