claude-brain 0.17.4 → 0.17.6

package/VERSION

@@ -1 +1 @@
-0.17.4
+0.17.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-brain",
-  "version": "0.17.4",
+  "version": "0.17.6",
   "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.17.4',
+  serverVersion: '0.17.6',
   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.17.4'),
+  serverVersion: z.string().regex(/^\d+\.\d+\.\d+$/, 'Version must be semver format').default('0.17.6'),
 
   /** Logging level */
   logLevel: LogLevelSchema.default('info'),

package/src/hooks/context-hook.ts

@@ -1,16 +1,23 @@
 #!/usr/bin/env bun
 /**
- * Phase 26: Context Injection Hook
+ * Phase 26+: Context Injection Hook
  * Runs on UserPromptSubmit and SessionStart to inject relevant memories
  * into Claude's context via additionalContext.
  *
+ * SessionStart also injects the static Claude Code Mastery guidelines
+ * (claude-code-mastery.md) to optimize Claude's behavior every session.
+ *
  * CRITICAL CONSTRAINTS:
  * - Must complete in <3s (blocks user prompt processing)
- * - No heavy imports — just fetch + JSON parse
+ * - No heavy imports — just fetch + JSON parse + fs.readFileSync
  * - All errors silently caught with process.exit(0)
  * - Outputs JSON to stdout: { hookSpecificOutput: { additionalContext: "..." } }
  */
 
+import { readFileSync, existsSync } from 'node:fs'
+import { join, dirname } from 'node:path'
+import { fileURLToPath } from 'node:url'
+
 interface HookStdin {
   session_id: string
   hook_event_name: string
@@ -19,6 +26,30 @@ interface HookStdin {
   source?: string
 }
 
+/** Cache the mastery doc in memory after first read */
+let masteryCache: string | null = null
+
+/** Read the static Claude Code Mastery guidelines from disk (once, then cached) */
+function loadMasteryDoc(): string {
+  if (masteryCache !== null) return masteryCache
+
+  // Resolve relative to this script's location (works both in src/ and installed ~/.claude-brain/hooks/)
+  const scriptDir = (import.meta as any).dir ?? dirname(fileURLToPath(import.meta.url))
+  const masteryPath = join(scriptDir, 'claude-code-mastery.md')
+
+  try {
+    if (existsSync(masteryPath)) {
+      masteryCache = readFileSync(masteryPath, 'utf-8').trim()
+    } else {
+      masteryCache = ''
+    }
+  } catch {
+    masteryCache = ''
+  }
+
+  return masteryCache
+}
+
 async function main(): Promise<void> {
   // Parse --event arg
   const eventIdx = process.argv.indexOf('--event')
@@ -57,7 +88,7 @@ async function main(): Promise<void> {
   const port = parseInt(process.env.CLAUDE_BRAIN_PORT || '3000', 10)
   const baseUrl = `http://localhost:${port}`
 
-  let context = ''
+  let brainContext = ''
 
   try {
     if (event === 'UserPromptSubmit' && input.prompt) {
@@ -74,7 +105,7 @@ async function main(): Promise<void> {
 
       if (res.ok) {
         const data = await res.json() as { success: boolean; context: string }
-        context = data.context || ''
+        brainContext = data.context || ''
       }
     } else if (event === 'SessionStart') {
       // Load broader project context on session start
@@ -87,21 +118,39 @@ async function main(): Promise<void> {
 
       if (res.ok) {
         const data = await res.json() as { success: boolean; context: string }
-        context = data.context || ''
+        brainContext = data.context || ''
       }
     }
   } catch {
-    // Server unreachable or timeout — exit silently
-    process.exit(0)
-    return
+    // Server unreachable or timeout — continue with static content only for SessionStart
+    if (event !== 'SessionStart') {
+      process.exit(0)
+      return
+    }
+  }
+
+  // Build final injection content
+  const parts: string[] = []
+
+  // SessionStart: prepend static Claude Code Mastery guidelines
+  if (event === 'SessionStart') {
+    const mastery = loadMasteryDoc()
+    if (mastery) {
+      parts.push(`[Claude Code Mastery]\n${mastery}`)
+    }
+  }
+
+  // Append dynamic brain memories (both events)
+  if (brainContext.trim()) {
+    parts.push(`[Brain Memory]\n${brainContext}`)
   }
 
-  // Only output if we have context to inject
-  if (context.trim()) {
+  // Output combined context
+  if (parts.length > 0) {
     const output = {
       hookSpecificOutput: {
         hookEventName: event,
-        additionalContext: `[Brain Memory]\n${context}`,
+        additionalContext: parts.join('\n\n'),
       },
     }
     process.stdout.write(JSON.stringify(output))

package/src/hooks/installer.ts

@@ -210,6 +210,7 @@ const HOOK_FILES = [
   'queue.ts',
   'types.ts',
   'passive-classifier.ts',
+  'claude-code-mastery.md',
 ]
 
 /** Copy the hook script and all its dependencies to the install location */

package/src/memory/chroma/embeddings.ts

@@ -36,13 +36,35 @@ export class TransformersEmbeddingProvider implements EmbeddingProvider {
 
   private async getPipeline() {
     if (!this.pipeline) {
-      const { pipeline } = await import('@xenova/transformers')
-      this.pipeline = await pipeline('feature-extraction', this.modelName)
+      try {
+        const { pipeline } = await import('@xenova/transformers')
+        this.pipeline = await pipeline('feature-extraction', this.modelName)
+      } catch (error) {
+        this.logger.warn({ error }, 'Model load failed, clearing cache and retrying')
+        await this.clearModelCache()
+        const { pipeline } = await import('@xenova/transformers')
+        this.pipeline = await pipeline('feature-extraction', this.modelName)
+      }
       this.logger.info({ model: this.modelName }, 'Transformers pipeline initialized')
     }
     return this.pipeline
   }
 
+  private async clearModelCache(): Promise<void> {
+    const { rm } = await import('fs/promises')
+    const { join } = await import('path')
+    const cacheDir = join(
+      require.resolve('@xenova/transformers'),
+      '..', '.cache', ...this.modelName.split('/')
+    )
+    try {
+      await rm(cacheDir, { recursive: true, force: true })
+      this.logger.info({ cacheDir }, 'Cleared corrupted model cache')
+    } catch {
+      // Cache dir may not exist, continue
+    }
+  }
+
   async generate(text: string): Promise<number[]> {
     const pipe = await this.getPipeline()
 

package/src/routing/intent-classifier.ts

@@ -174,7 +174,7 @@ const UPDATE_PHRASES = [
 
 // Delete/forget memory
 const DELETE_PHRASES = [
-  'forget that', 'forget about', 'delete that', 'delete the',
+  'forget that', 'forget about', 'delete that', 'delete the memory', 'delete the decision',
   'remove that memory', 'remove that decision', 'that was wrong',
   'discard that', 'erase that', 'undo that decision',
   'remove the memory', 'clear that', 'drop that'
@@ -400,6 +400,7 @@ export class IntentClassifier {
   }
 
   private isDeleteMemory(lower: string): boolean {
+    if (lower.length > 150) return false
     return DELETE_PHRASES.some(p => lower.includes(p))
   }