claude-brain 0.16.0 → 0.17.1

package/VERSION

@@ -1 +1 @@
-0.16.0
+0.17.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-brain",
-  "version": "0.16.0",
+  "version": "0.17.1",
   "description": "Local development assistant bridging Obsidian vaults with Claude Code via MCP",
   "type": "module",
   "main": "src/index.ts",

package/src/config/defaults.ts

@@ -3,7 +3,7 @@ import type { PartialConfig } from './schema'
 /** Default configuration values for Claude Brain */
 export const defaultConfig: PartialConfig = {
   serverName: 'claude-brain',
-  serverVersion: '0.16.0',
+  serverVersion: '0.17.1',
   logLevel: 'info',
   logFilePath: './logs/claude-brain.log',
   dbPath: './data/memory.db',

package/src/config/schema.ts

@@ -284,7 +284,7 @@ export const ConfigSchema = z.object({
   serverName: z.string().default('claude-brain'),
 
   /** Server version in semver format */
-  serverVersion: z.string().regex(/^\d+\.\d+\.\d+$/, 'Version must be semver format').default('0.16.0'),
+  serverVersion: z.string().regex(/^\d+\.\d+\.\d+$/, 'Version must be semver format').default('0.17.1'),
 
   /** Logging level */
   logLevel: LogLevelSchema.default('info'),

package/src/hooks/context-hook.ts

@@ -0,0 +1,137 @@
+#!/usr/bin/env bun
+/**
+ * Phase 26: Context Injection Hook
+ * Runs on UserPromptSubmit and SessionStart to inject relevant memories
+ * into Claude's context via additionalContext.
+ *
+ * CRITICAL CONSTRAINTS:
+ * - Must complete in <3s (blocks user prompt processing)
+ * - No heavy imports — just fetch + JSON parse
+ * - All errors silently caught with process.exit(0)
+ * - Outputs JSON to stdout: { hookSpecificOutput: { additionalContext: "..." } }
+ */
+
+interface HookStdin {
+  session_id: string
+  hook_event_name: string
+  prompt?: string
+  cwd?: string
+  source?: string
+}
+
+async function main(): Promise<void> {
+  // Parse --event arg
+  const eventIdx = process.argv.indexOf('--event')
+  const eventName = eventIdx >= 0 ? process.argv[eventIdx + 1] : undefined
+
+  // Read stdin JSON from Claude Code
+  let rawInput: string
+  try {
+    rawInput = await readStdin()
+  } catch {
+    process.exit(0)
+    return
+  }
+
+  if (!rawInput.trim()) {
+    process.exit(0)
+    return
+  }
+
+  let input: HookStdin
+  try {
+    input = JSON.parse(rawInput)
+  } catch {
+    process.exit(0)
+    return
+  }
+
+  const event = eventName || input.hook_event_name
+
+  // Skip if hooks explicitly disabled
+  if (process.env.CLAUDE_BRAIN_HOOKS_ENABLED === 'false') {
+    process.exit(0)
+    return
+  }
+
+  const port = parseInt(process.env.CLAUDE_BRAIN_PORT || '3000', 10)
+  const baseUrl = `http://localhost:${port}`
+
+  let context = ''
+
+  try {
+    if (event === 'UserPromptSubmit' && input.prompt) {
+      // Query for memories relevant to the user's prompt
+      const params = new URLSearchParams({
+        query: input.prompt.slice(0, 500), // Limit query length
+        limit: '5',
+      })
+      if (input.cwd) params.set('cwd', input.cwd)
+
+      const res = await fetch(`${baseUrl}/api/hooks/context-query?${params}`, {
+        signal: AbortSignal.timeout(2000),
+      })
+
+      if (res.ok) {
+        const data = await res.json() as { success: boolean; context: string }
+        context = data.context || ''
+      }
+    } 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),
+      })
+
+      if (res.ok) {
+        const data = await res.json() as { success: boolean; context: string }
+        context = data.context || ''
+      }
+    }
+  } catch {
+    // Server unreachable or timeout — exit silently
+    process.exit(0)
+    return
+  }
+
+  // Only output if we have context to inject
+  if (context.trim()) {
+    const output = {
+      hookSpecificOutput: {
+        hookEventName: event,
+        additionalContext: `[Brain Memory]\n${context}`,
+      },
+    }
+    process.stdout.write(JSON.stringify(output))
+  }
+
+  process.exit(0)
+}
+
+/** Read all of stdin as a string */
+function readStdin(): Promise<string> {
+  return new Promise((resolve, reject) => {
+    const chunks: Buffer[] = []
+    const stdin = process.stdin
+
+    stdin.on('data', (chunk: Buffer) => chunks.push(chunk))
+    stdin.on('end', () => resolve(Buffer.concat(chunks).toString('utf-8')))
+    stdin.on('error', reject)
+
+    // Timeout after 2 seconds
+    setTimeout(() => {
+      stdin.destroy()
+      resolve(Buffer.concat(chunks).toString('utf-8'))
+    }, 2000)
+  })
+}
+
+// Execute when run directly
+const isDirectRun = process.argv[1]?.includes('context-hook')
+if (isDirectRun) {
+  main().catch(() => process.exit(0))
+}
+
+export { main }

package/src/hooks/installer.ts

@@ -12,11 +12,16 @@ import { getClaudeBrainHome } from '@/config/home'
 const CLAUDE_SETTINGS_PATH = join(homedir(), '.claude', 'settings.json')
 const HOOK_MARKER = 'claude-brain-hook'
 
-/** Get the path where the hook script should be installed */
+/** Get the path where the brain-hook script should be installed */
 export function getHookScriptPath(): string {
   return join(getClaudeBrainHome(), 'hooks', 'brain-hook.ts')
 }
 
+/** Get the path where the context-hook script should be installed */
+export function getContextHookScriptPath(): string {
+  return join(getClaudeBrainHome(), 'hooks', 'context-hook.ts')
+}
+
 /** Read Claude Code settings.json, creating if needed */
 function readSettings(): Record<string, any> {
   if (!existsSync(CLAUDE_SETTINGS_PATH)) return {}
@@ -39,10 +44,11 @@ function writeSettings(settings: Record<string, any>): void {
   renameSync(tmpPath, CLAUDE_SETTINGS_PATH)
 }
 
-/** Build the hook command string */
-function buildHookCommand(event: string): string {
-  const scriptPath = getHookScriptPath()
-  return `bun "${scriptPath}" --event ${event} # ${HOOK_MARKER}`
+/** Build the hook command string, embedding the port so hooks work regardless of env */
+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'
+  return `CLAUDE_BRAIN_PORT=${port} bun "${scriptPath}" --event ${event} # ${HOOK_MARKER}`
 }
 
 /**
@@ -79,6 +85,26 @@ export function installHooks(): { installed: boolean; message: string } {
     }],
   })
 
+  // UserPromptSubmit hook — injects relevant memories into every prompt
+  if (!settings.hooks.UserPromptSubmit) settings.hooks.UserPromptSubmit = []
+  settings.hooks.UserPromptSubmit.push({
+    matcher: '',
+    hooks: [{
+      type: 'command',
+      command: buildHookCommand('UserPromptSubmit', 'context-hook'),
+    }],
+  })
+
+  // SessionStart hook — injects project context on session start/resume
+  if (!settings.hooks.SessionStart) settings.hooks.SessionStart = []
+  settings.hooks.SessionStart.push({
+    matcher: 'startup,resume,compact',
+    hooks: [{
+      type: 'command',
+      command: buildHookCommand('SessionStart', 'context-hook'),
+    }],
+  })
+
   writeSettings(settings)
 
   // Copy hook script to install location
@@ -118,6 +144,26 @@ export function uninstallHooks(): { uninstalled: boolean; message: string } {
       }
     }
 
+    // Remove our entries from UserPromptSubmit
+    if (Array.isArray(settings.hooks.UserPromptSubmit)) {
+      settings.hooks.UserPromptSubmit = settings.hooks.UserPromptSubmit.filter(
+        (entry: any) => !isOurHookEntry(entry)
+      )
+      if (settings.hooks.UserPromptSubmit.length === 0) {
+        delete settings.hooks.UserPromptSubmit
+      }
+    }
+
+    // Remove our entries from SessionStart
+    if (Array.isArray(settings.hooks.SessionStart)) {
+      settings.hooks.SessionStart = settings.hooks.SessionStart.filter(
+        (entry: any) => !isOurHookEntry(entry)
+      )
+      if (settings.hooks.SessionStart.length === 0) {
+        delete settings.hooks.SessionStart
+      }
+    }
+
     // Clean up empty hooks object
     if (Object.keys(settings.hooks).length === 0) {
       delete settings.hooks
@@ -142,7 +188,10 @@ export function isHooksInstalled(): boolean {
   const hasStop = Array.isArray(settings.hooks.Stop) &&
     settings.hooks.Stop.some((entry: any) => isOurHookEntry(entry))
 
-  return hasPostToolUse || hasStop
+  const hasUserPromptSubmit = Array.isArray(settings.hooks.UserPromptSubmit) &&
+    settings.hooks.UserPromptSubmit.some((entry: any) => isOurHookEntry(entry))
+
+  return hasPostToolUse || hasStop || hasUserPromptSubmit
 }
 
 /** Check if a hook entry belongs to us (by marker in command) */
@@ -153,9 +202,10 @@ function isOurHookEntry(entry: any): boolean {
   )
 }
 
-/** All files needed by brain-hook.ts at runtime */
+/** All files needed by brain-hook.ts and context-hook.ts at runtime */
 const HOOK_FILES = [
   'brain-hook.ts',
+  'context-hook.ts',
   'capture.ts',
   'queue.ts',
   'types.ts',

package/src/hooks/types.ts

@@ -5,7 +5,7 @@
 /** Claude Code hook stdin JSON format */
 export interface HookInput {
   session_id: string
-  hook_event_name: 'PostToolUse' | 'Stop' | 'PreToolUse' | 'GitCommit'
+  hook_event_name: 'PostToolUse' | 'Stop' | 'PreToolUse' | 'GitCommit' | 'UserPromptSubmit' | 'SessionStart'
   cwd: string
   tool_name?: string
   tool_input?: Record<string, any>
@@ -13,6 +13,11 @@ export interface HookInput {
     content?: string | Array<{ type: string; text?: string }>
     [key: string]: any
   }
+  // UserPromptSubmit fields
+  prompt?: string
+  // SessionStart fields
+  source?: string
+  model?: string
 }
 
 /** Knowledge type classifications */

package/src/server/http-api.ts

@@ -83,6 +83,9 @@ export class HttpApiServer {
     this.app.post('/api/hooks/session-end', (c) => this.handleHookSessionEnd(c))
     this.app.get('/api/hooks/status', () => this.handleHookStatus())
 
+    // Phase 26: Context injection for UserPromptSubmit/SessionStart hooks
+    this.app.get('/api/hooks/context-query', (c) => this.handleContextQuery(c))
+
     // Phase 23b: Expose brain://context/auto via HTTP for testability
     this.app.get('/api/context/auto', () => this.handleContextAuto())
   }
@@ -462,6 +465,71 @@ export class HttpApiServer {
     }
   }
 
+  // ─── Phase 26: Context Query for Hook Injection ──────────
+
+  private async handleContextQuery(c: any): Promise<Response> {
+    try {
+      const query = c.req.query('query') || ''
+      const type = c.req.query('type') || ''
+      const cwd = c.req.query('cwd') || ''
+      const limit = parseInt(c.req.query('limit') || '5', 10)
+
+      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.2,
+          }),
+          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: any) => `- 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) {
+      this.logger.error({ error }, 'Failed to get context for hook')
+      return Response.json({ success: true, context: '' })
+    }
+  }
+
   // ─── Phase 23b: Context Auto Endpoint ────────────────────
 
   private async handleContextAuto(): Promise<Response> {