claude-brain 0.9.3 → 0.13.0

package/src/server/providers/resources.ts

@@ -9,6 +9,8 @@ import {
   getVaultService,
   getContextService,
   getMemoryService,
+  getEpisodeService,
+  getSessionTracker,
   isServicesInitialized
 } from '@/server/services'
 import { isPhase12Available, getPhase12Instance } from '@/utils/phase12-helper'
@@ -42,6 +44,12 @@ export class ResourceProvider {
     const detectedProject = await this.detectCurrentProject()
 
     const resources: ResourceItem[] = [
+      {
+        uri: 'brain://context/auto',
+        name: 'Auto Context',
+        description: 'Session context auto-loaded by brain',
+        mimeType: 'text/markdown'
+      },
       {
         uri: 'project://list',
         name: 'All Projects',
@@ -88,6 +96,10 @@ export class ResourceProvider {
   async readResource(uri: string) {
     this.logger.info({ uri }, 'Reading resource')
 
+    if (uri.startsWith('brain://')) {
+      return await this.getBrainResource(uri)
+    }
+
     if (uri === 'project://list') {
       return await this.getProjectListResource()
     }
@@ -372,6 +384,189 @@ export class ResourceProvider {
     }
   }
 
+  /**
+   * Handle brain:// resource URIs
+   */
+  private async getBrainResource(uri: string) {
+    if (uri === 'brain://context/auto') {
+      const content = await this.getAutoContextContent()
+      return {
+        contents: [
+          {
+            uri,
+            mimeType: 'text/markdown',
+            text: content
+          }
+        ]
+      }
+    }
+
+    throw new Error(`Unknown brain resource URI: ${uri}`)
+  }
+
+  /**
+   * Phase 21: Build aggregated auto-context payload
+   * Combines last session summary, recent decisions, corrections,
+   * cross-project knowledge, and current session info.
+   */
+  private async getAutoContextContent(): Promise<string> {
+    if (!isServicesInitialized()) {
+      return '# Auto Context\n\nServices not initialized.'
+    }
+
+    const sections: string[] = ['# Auto Context\n']
+    const detectedProject = await this.detectCurrentProject()
+    const projectName = detectedProject?.name
+
+    // 1. Last session summary
+    try {
+      const episodeService = getEpisodeService()
+      if (episodeService) {
+        const recentEpisodes = await episodeService.getRecentEpisodes(projectName, 1)
+        if (recentEpisodes.length > 0 && recentEpisodes[0].summary?.brief) {
+          const ep = recentEpisodes[0]
+          sections.push('## Last Session\n')
+          sections.push(ep.summary!.brief)
+          if (ep.summary!.key_topics.length > 0) {
+            sections.push(`\n**Topics:** ${ep.summary!.key_topics.join(', ')}`)
+          }
+          sections.push('')
+        }
+      }
+    } catch (err) {
+      this.logger.debug({ err }, 'Failed to get last session for auto-context')
+    }
+
+    // 2. Current session info
+    try {
+      const tracker = getSessionTracker()
+      if (tracker) {
+        const stats = tracker.getStats()
+        if (stats.activeSessions > 0) {
+          sections.push('## Current Session\n')
+          sections.push(`Active sessions: ${stats.activeSessions}, items tracked: ${stats.totalItems}`)
+          sections.push('')
+        }
+      }
+    } catch (err) {
+      this.logger.debug({ err }, 'Failed to get current session for auto-context')
+    }
+
+    // 3. Recent decisions
+    try {
+      const memory = getMemoryService()
+      const searchProject = projectName || 'general'
+      const decisions = await memory.searchRaw(searchProject, {
+        project: searchProject,
+        limit: 5,
+        minSimilarity: 0.1
+      })
+
+      if (decisions.length > 0) {
+        sections.push('## Recent Decisions\n')
+        for (const d of decisions) {
+          const title = d.decision || d.content || 'Untitled'
+          const truncated = title.length > 120 ? title.slice(0, 120) + '...' : title
+          sections.push(`- ${truncated}`)
+        }
+        sections.push('')
+      }
+    } catch (err) {
+      this.logger.debug({ err }, 'Failed to get decisions for auto-context')
+    }
+
+    // 4. Corrections (watch out for)
+    try {
+      const memory = getMemoryService()
+      if (typeof memory.getCorrections === 'function') {
+        const corrections = await memory.getCorrections(projectName || 'general', { limit: 3 })
+        if (corrections && corrections.length > 0) {
+          sections.push('## Watch Out For\n')
+          for (const c of corrections) {
+            const text = typeof c === 'string' ? c : (c.content || c.correction || JSON.stringify(c))
+            const truncated = text.length > 120 ? text.slice(0, 120) + '...' : text
+            sections.push(`- ${truncated}`)
+          }
+          sections.push('')
+        }
+      }
+    } catch (err) {
+      this.logger.debug({ err }, 'Failed to get corrections for auto-context')
+    }
+
+    // 5. Cross-project knowledge
+    if (projectName) {
+      try {
+        const vault = getVaultService()
+        const allProjects = await vault.reader.getProjectDirectories(vault.paths.projects)
+        const otherProjects = allProjects.filter(p => p !== projectName)
+
+        if (otherProjects.length > 0) {
+          const memory = getMemoryService()
+          if (memory.isChromaDBEnabled()) {
+            const { KnowledgeTransfer } = await import('@/intelligence/cross-project/transfer')
+            const transfer = new KnowledgeTransfer(
+              this.logger,
+              memory.chroma.collections,
+              memory.chroma.embeddings
+            )
+
+            const transferItems: string[] = []
+            // Check up to 3 other projects for transferable knowledge
+            for (const other of otherProjects.slice(0, 3)) {
+              try {
+                const result = await transfer.findTransferable(other, projectName, { limit: 2, minRelevance: 0.5 })
+                for (const item of result.items) {
+                  const truncated = item.content.length > 100 ? item.content.slice(0, 100) + '...' : item.content
+                  transferItems.push(`- [${item.type} from ${other}] ${truncated}`)
+                }
+              } catch {
+                // Skip failed transfers
+              }
+            }
+
+            if (transferItems.length > 0) {
+              sections.push('## From Other Projects\n')
+              sections.push(...transferItems)
+              sections.push('')
+            }
+          }
+        }
+      } catch (err) {
+        this.logger.debug({ err }, 'Failed to get cross-project knowledge for auto-context')
+      }
+    }
+
+    // If no sections beyond the header, try auto-scan for first-session value
+    if (sections.length <= 1) {
+      try {
+        const cwd = process.cwd()
+        const { scanRepo } = await import('@/automation/repo-scanner')
+        const repoContext = await scanRepo(cwd)
+        if (repoContext.name) {
+          sections.push('## Project Detected\n')
+          sections.push(`**Name:** ${repoContext.name}`)
+          if (repoContext.techStack.length > 0) {
+            sections.push(`**Tech stack:** ${repoContext.techStack.join(', ')}`)
+          }
+          if (repoContext.description) {
+            const desc = repoContext.description.split('\n')[0]?.slice(0, 200) || ''
+            sections.push(`**Description:** ${desc}`)
+          }
+          sections.push('')
+        }
+      } catch {
+        // Scan failed, continue with empty context
+      }
+    }
+
+    if (sections.length <= 1) {
+      return '# Auto Context\n\nNo context available yet. Use brain to store decisions, patterns, and corrections.'
+    }
+
+    return sections.join('\n')
+  }
+
   /**
    * Detect current project from working directory
    */

package/src/server/services.ts

@@ -9,16 +9,18 @@ import * as path from 'path'
 import { MemoryManager } from '@/memory'
 import { VaultManager } from '@/vault'
 import { ContextManager } from '@/context'
-import { Phase12Manager } from '@/phase12'
+import { Phase12Manager } from '@/automation/phase12-manager'
 import { RetrievalService } from '@/retrieval/service'
+import { RetrievalPipeline } from '@/retrieval/pipeline'
 import { InMemoryKnowledgeGraph } from '@/knowledge/graph/memory-graph'
 import { GraphSearchEngine } from '@/knowledge/graph/search'
 import { KnowledgeGraphBuilder } from '@/knowledge/graph/builder'
 import { CrossReferenceLinker } from '@/knowledge/graph/linker'
 import { EpisodeManager } from '@/memory/episodic/manager'
+import { HookSessionTracker } from '@/hooks/session-tracker'
 import type { Config } from '@/config'
-import { SemanticCache } from '@/optimization/semantic-cache'
-import { PrecomputeEngine } from '@/optimization/precompute'
+import { SemanticCache } from '@/intelligence/optimization/semantic-cache'
+import { PrecomputeEngine } from '@/intelligence/optimization/precompute'
 
 export interface KnowledgeGraphServiceContainer {
   graph: InMemoryKnowledgeGraph
@@ -36,8 +38,10 @@ export interface Services {
   context: ContextManager
   phase12: Phase12Manager
   retrieval: RetrievalService | null
+  retrievalPipeline: RetrievalPipeline | null
   knowledgeGraph: KnowledgeGraphServiceContainer | null
   episodeManager: EpisodeManager | null
+  sessionTracker: HookSessionTracker | null
   semanticCache: SemanticCache | null
   precompute: PrecomputeEngine | null
   logger: Logger
@@ -127,6 +131,23 @@ export async function initializeServices(config: Config, logger: Logger): Promis
       serviceLogger.warn('Retrieval service requires ChromaDB, skipping initialization')
     }
 
+    // Initialize Retrieval Pipeline (Phase 19) — hybrid search with BM25 + semantic + fusion
+    let retrievalPipeline: RetrievalPipeline | null = null
+    if (config.retrieval?.enabled && memory.isChromaDBEnabled()) {
+      try {
+        retrievalPipeline = new RetrievalPipeline(
+          logger,
+          memory.chroma.collections,
+          memory.chroma.embeddings,
+          config.retrieval
+        )
+        await retrievalPipeline.initialize()
+        serviceLogger.info('Retrieval pipeline initialized (hybrid search)')
+      } catch (error) {
+        serviceLogger.warn({ error }, 'Failed to initialize retrieval pipeline, continuing without hybrid search')
+      }
+    }
+
     // Initialize Knowledge Graph Service (Phase 14)
     let knowledgeGraph: KnowledgeGraphServiceContainer | null = null
     if (config.knowledge?.graph?.enabled !== false) {
@@ -166,6 +187,21 @@ export async function initializeServices(config: Config, logger: Logger): Promis
           builder.processDecision(input)
         })
 
+        // Hook builder into decision deletion for graph synchronization
+        memory.addDecisionDeletedListener((id) => {
+          builder.removeDecision(id)
+
+          // Phase 20: Also unlink from active episodes
+          if (episodeManager) {
+            episodeManager.unlinkDecision(id)
+          }
+
+          // Phase 20: Invalidate semantic cache for deleted decisions
+          if (semanticCache) {
+            semanticCache.clear()
+          }
+        })
+
         serviceLogger.info(
           { nodes: graph.getNodeCount(), edges: graph.getEdgeCount() },
           'Knowledge graph service initialized'
@@ -191,6 +227,17 @@ export async function initializeServices(config: Config, logger: Logger): Promis
       }
     }
 
+    // Initialize Session Tracker (Phase 21) — promoted from serve.ts
+    let sessionTracker: HookSessionTracker | null = null
+    if (config.hooks?.enabled !== false) {
+      try {
+        sessionTracker = new HookSessionTracker(logger, episodeManager, config.hooks?.sessions, memory)
+        serviceLogger.info('Session tracker initialized')
+      } catch (error) {
+        serviceLogger.warn({ error }, 'Failed to initialize session tracker, continuing without it')
+      }
+    }
+
     // Initialize Semantic Cache & Precompute (Phase 15) — requires ChromaDB
     let semanticCache: SemanticCache | null = null
     let precompute: PrecomputeEngine | null = null
@@ -198,9 +245,9 @@ export async function initializeServices(config: Config, logger: Logger): Promis
       try {
         const cacheConfig = config.advancedIntelligence?.cache || {}
         semanticCache = new SemanticCache(logger, {
-          maxSize: cacheConfig.maxSize || 500,
-          ttlMs: cacheConfig.ttlMs || 30 * 60 * 1000,
-          similarityThreshold: cacheConfig.similarityThreshold || 0.85,
+          maxSize: cacheConfig.maxSize || 1000,
+          ttlMs: cacheConfig.ttlMs || 60 * 60 * 1000,
+          similarityThreshold: cacheConfig.similarityThreshold || 0.80,
           embeddings: memory.chroma.embeddings
         })
 
@@ -221,8 +268,10 @@ export async function initializeServices(config: Config, logger: Logger): Promis
       context,
       phase12,
       retrieval,
+      retrievalPipeline,
       knowledgeGraph,
       episodeManager,
+      sessionTracker,
       semanticCache,
       precompute,
       logger,
@@ -283,6 +332,14 @@ export function getRetrievalService(): RetrievalService | null {
   return getServices().retrieval
 }
 
+/**
+ * Get Retrieval Pipeline (Phase 19)
+ * Returns null if hybrid search is not enabled
+ */
+export function getRetrievalPipeline(): RetrievalPipeline | null {
+  return getServices().retrievalPipeline
+}
+
 /**
  * Get Knowledge Graph service
  * Returns null if knowledge graph is not enabled
@@ -299,6 +356,14 @@ export function getEpisodeService(): EpisodeManager | null {
   return getServices().episodeManager
 }
 
+/**
+ * Get Session Tracker service
+ * Returns null if hooks are not enabled
+ */
+export function getSessionTracker(): HookSessionTracker | null {
+  return getServices().sessionTracker
+}
+
 /**
  * Get Semantic Cache service
  * Returns null if caching is not enabled
@@ -352,6 +417,16 @@ export async function shutdownServices(): Promise<void> {
   const serviceLogger = services.logger.child({ component: 'services' })
   serviceLogger.info('Shutting down services...')
 
+  // End all active sessions
+  if (services.sessionTracker) {
+    try {
+      await services.sessionTracker.endAllSessions()
+      serviceLogger.info('Session tracker shut down')
+    } catch (error) {
+      serviceLogger.error({ error }, 'Failed to end sessions on shutdown')
+    }
+  }
+
   // Save and stop knowledge graph
   if (services.knowledgeGraph) {
     services.knowledgeGraph.graph.stopAutoSave()