claude-brain 0.17.13 → 0.22.0

package/src/hooks/context-hook.ts

@@ -85,10 +85,15 @@ async function main(): Promise<void> {
     return
   }
 
-  const port = parseInt(process.env.CLAUDE_BRAIN_PORT || '3000', 10)
+  // BUG-006: Read port from --port arg (cross-platform) or env var fallback
+  const portIdx = process.argv.indexOf('--port')
+  const portArg = portIdx >= 0 ? process.argv[portIdx + 1] : undefined
+  const port = parseInt(portArg || process.env.CLAUDE_BRAIN_PORT || '3000', 10)
   const baseUrl = `http://localhost:${port}`
 
   let brainContext = ''
+  let codeMapText = ''
+  let fileMemoryText = ''
 
   try {
     if (event === 'UserPromptSubmit' && input.prompt) {
@@ -99,27 +104,64 @@ async function main(): Promise<void> {
       })
       if (input.cwd) params.set('cwd', input.cwd)
 
-      const res = await fetch(`${baseUrl}/api/hooks/context-query?${params}`, {
+      const contextPromise = fetch(`${baseUrl}/api/hooks/context-query?${params}`, {
         signal: AbortSignal.timeout(2000),
-      })
+      }).catch(() => null)
+
+      // Phase 29: Detect file paths in the user's prompt and fetch linked memories
+      const projectName = input.cwd ? input.cwd.split('/').filter(Boolean).pop() : ''
+      const filePaths = extractFilePathsFromPrompt(input.prompt)
+      const fileMemoryPromises = filePaths.slice(0, 3).map(fp =>
+        fetch(`${baseUrl}/api/memory/for-file?file=${encodeURIComponent(fp)}&project=${encodeURIComponent(projectName || '')}`, {
+          signal: AbortSignal.timeout(1000),
+        }).then(r => r.ok ? r.json() : null).catch(() => null)
+      )
 
-      if (res.ok) {
-        const data = await res.json() as { success: boolean; context: string }
+      const [contextRes, ...fileMemories] = await Promise.all([contextPromise, ...fileMemoryPromises])
+
+      if (contextRes?.ok) {
+        const data = await contextRes.json() as { success: boolean; context: string }
         brainContext = data.context || ''
       }
+
+      // Phase 29: Aggregate file memory summaries
+      const relevant = fileMemories.filter((m: any) => m?.data?.summary)
+      if (relevant.length > 0) {
+        fileMemoryText = relevant.map((m: any) => m.data.summary).join('\n\n')
+      }
     } else if (event === 'SessionStart') {
       // Load broader project context on session start
       const params = new URLSearchParams({ type: 'session-start' })
       if (input.cwd) params.set('cwd', input.cwd)
 
-      const res = await fetch(`${baseUrl}/api/hooks/context-query?${params}`, {
-        signal: AbortSignal.timeout(2000),
-      })
+      // Extract project name from cwd for code map
+      const projectName = input.cwd ? input.cwd.split('/').filter(Boolean).pop() : undefined
+
+      // Fetch brain context AND code map in parallel
+      const [contextRes, codeMapRes] = await Promise.all([
+        fetch(`${baseUrl}/api/hooks/context-query?${params}`, { signal: AbortSignal.timeout(2000) }).catch(() => null),
+        projectName
+          ? fetch(`${baseUrl}/api/code/file-map?project=${encodeURIComponent(projectName)}`, { signal: AbortSignal.timeout(2000) }).catch(() => null)
+          : Promise.resolve(null),
+      ])
 
-      if (res.ok) {
-        const data = await res.json() as { success: boolean; context: string }
+      // Process brain context (existing logic)
+      if (contextRes?.ok) {
+        const data = await contextRes.json() as { success: boolean; context: string }
         brainContext = data.context || ''
       }
+
+      // Process code map (Phase 28)
+      if (codeMapRes?.ok) {
+        try {
+          const data = await codeMapRes.json() as { success: boolean; data?: { map?: string } }
+          if (data.success && data.data?.map) {
+            codeMapText = data.data.map
+          }
+        } catch {
+          // Silently ignore malformed code map response
+        }
+      }
     }
   } catch {
     // Server unreachable or timeout — continue with static content only for SessionStart
@@ -145,6 +187,16 @@ async function main(): Promise<void> {
     parts.push(`[Brain Memory]\n${brainContext}`)
   }
 
+  // Phase 29: Append file-linked memories (UserPromptSubmit only)
+  if (fileMemoryText.trim()) {
+    parts.push(`[File Memories]\n${fileMemoryText}`)
+  }
+
+  // Append code map (SessionStart only, Phase 28)
+  if (codeMapText.trim()) {
+    parts.push(`[Code Map]\nProject file index (use Read directly, skip Glob):\n${codeMapText}`)
+  }
+
   // Output combined context
   if (parts.length > 0) {
     const output = {
@@ -159,6 +211,13 @@ async function main(): Promise<void> {
   process.exit(0)
 }
 
+/** Phase 29: Extract file paths from user prompt text */
+function extractFilePathsFromPrompt(prompt: string): string[] {
+  const pathPattern = /(?:^|\s)((?:src|lib|app|pages|components|utils|hooks|server|api|config|middleware|routes|models|services|types|scripts|tests|test)\/[\w\-./]+\.\w+)/g
+  const matches = [...prompt.matchAll(pathPattern)]
+  return [...new Set(matches.map(m => m[1]))]
+}
+
 /** Read all of stdin as a string */
 function readStdin(): Promise<string> {
   return new Promise((resolve, reject) => {

package/src/hooks/installer.ts

@@ -44,17 +44,14 @@ function writeSettings(settings: Record<string, any>): void {
   renameSync(tmpPath, CLAUDE_SETTINGS_PATH)
 }
 
-/** Build the hook command string, embedding the port so hooks work regardless of env */
+/** Build the hook command string, embedding the port so hooks work regardless of env.
+ * BUG-006: settings.json syncs across platforms. We use --port arg instead of
+ * platform-specific env var syntax (VAR=val on Unix, set VAR=val on Windows). */
 function buildHookCommand(event: string, script: 'brain-hook' | 'context-hook' = 'brain-hook'): string {
   const scriptPath = script === 'context-hook' ? getContextHookScriptPath() : getHookScriptPath()
   const port = process.env.PORT || process.env.CLAUDE_BRAIN_PORT || '3000'
 
-  // Claude Code runs hooks via cmd.exe on Windows, which can't parse VAR=value syntax
-  if (process.platform === 'win32') {
-    return `set CLAUDE_BRAIN_PORT=${port}&& bun "${scriptPath}" --event ${event} # ${HOOK_MARKER}`
-  }
-
-  return `CLAUDE_BRAIN_PORT=${port} bun "${scriptPath}" --event ${event} # ${HOOK_MARKER}`
+  return `bun "${scriptPath}" --event ${event} --port ${port} # ${HOOK_MARKER}`
 }
 
 /**

package/src/intelligence/cross-project/index.ts

@@ -1,13 +1,7 @@
 /**
  * Cross-Project Intelligence Module
- * Phase 15.4 - Pattern generalization, project affinity, knowledge transfer
+ * Phase 15.4 - Pattern generalization
  */
 
 export { PatternGeneralizer } from './generalizer'
 export type { GeneralizedPattern, GeneralizationResult } from './generalizer'
-
-export { AffinityCalculator } from './affinity'
-export type { ProjectAffinity } from './affinity'
-
-export { KnowledgeTransfer } from './transfer'
-export type { TransferableKnowledge, TransferItem } from './transfer'

package/src/intelligence/prediction/index.ts

@@ -1,13 +1,7 @@
 /**
  * Predictive Intelligence Module
- * Phase 15.3 - Decision prediction, context anticipation, recommendations
+ * Phase 15.3 - Recommendations
  */
 
-export { DecisionPredictor } from './decision-predictor'
-export type { PredictedDecision } from './decision-predictor'
-
-export { ContextAnticipator } from './context-anticipator'
-export type { AnticipatedContext } from './context-anticipator'
-
 export { Recommender } from './recommender'
 export type { Recommendation, RecommendationResult } from './recommender'

package/src/intelligence/reasoning/index.ts

@@ -1,13 +1,7 @@
 /**
  * Multi-Hop Reasoning Module
- * Phase 15.2 - Chain retrieval, result synthesis, counterfactual analysis
+ * Phase 15.2 - Chain retrieval
  */
 
 export { ChainRetrieval } from './chain-retrieval'
 export type { ChainStep, ChainResult, ChainRetrievalResult } from './chain-retrieval'
-
-export { ResultSynthesizer } from './synthesizer'
-export type { SynthesizedResult } from './synthesizer'
-
-export { CounterfactualAnalyzer } from './counterfactual'
-export type { WhatIfScenario } from './counterfactual'

package/src/memory/compression.ts

@@ -0,0 +1,105 @@
+/**
+ * Observation Compressor — Phase 30
+ * Optional LLM-based compression for long observations.
+ * Uses Anthropic API directly via fetch (no Agent SDK dependency).
+ * Graceful fallback: if compression fails, store original text.
+ */
+
+import type { Logger } from 'pino'
+
+export interface CompressionConfig {
+  enabled: boolean
+  provider: 'claude' | 'ollama'
+  model: string
+  apiKey?: string
+  minContentLength: number
+}
+
+export interface CompressedObservation {
+  summary: string
+  original?: string
+  compressed: boolean
+}
+
+export class ObservationCompressor {
+  private config: CompressionConfig
+  private logger: Logger
+
+  constructor(config: CompressionConfig, logger: Logger) {
+    this.config = config
+    this.logger = logger.child({ component: 'compressor' })
+  }
+
+  async compress(content: string, category: string): Promise<CompressedObservation> {
+    if (!this.config.enabled || content.length < this.config.minContentLength) {
+      return { summary: content, compressed: false }
+    }
+
+    const prompt = `Compress this ${category} observation into a concise summary (2-3 sentences max).
+Preserve: the core decision/insight, reasoning, and any specific technologies mentioned.
+Drop: filler words, repetition, context that's obvious from the category.
+
+Observation: ${content}`
+
+    try {
+      const response = await this.callLLM(prompt)
+      return { summary: response, original: content, compressed: true }
+    } catch (error) {
+      this.logger.warn({ error }, 'LLM compression failed, storing original')
+      return { summary: content, compressed: false }
+    }
+  }
+
+  private async callLLM(prompt: string): Promise<string> {
+    const apiKey = this.config.apiKey || process.env.ANTHROPIC_API_KEY
+    if (!apiKey) {
+      throw new Error('No API key configured for compression')
+    }
+
+    if (this.config.provider === 'ollama') {
+      return this.callOllama(prompt)
+    }
+
+    const res = await fetch('https://api.anthropic.com/v1/messages', {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'x-api-key': apiKey,
+        'anthropic-version': '2023-06-01'
+      },
+      body: JSON.stringify({
+        model: this.config.model || 'claude-haiku-4-5-20251001',
+        max_tokens: 200,
+        messages: [{ role: 'user', content: prompt }]
+      }),
+      signal: AbortSignal.timeout(10000)
+    })
+
+    if (!res.ok) {
+      throw new Error(`Anthropic API error: ${res.status} ${res.statusText}`)
+    }
+
+    const data = await res.json() as { content: Array<{ text: string }> }
+    return data.content[0].text
+  }
+
+  private async callOllama(prompt: string): Promise<string> {
+    const res = await fetch('http://localhost:11434/api/generate', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        model: this.config.model || 'llama3',
+        prompt,
+        stream: false
+      }),
+      signal: AbortSignal.timeout(10000)
+    })
+
+    if (!res.ok) {
+      throw new Error(`Ollama API error: ${res.status} ${res.statusText}`)
+    }
+
+    const data = await res.json() as { response: string }
+    return data.response
+  }
+}