claude-brain 0.14.2 → 0.14.3

package/VERSION

@@ -1 +1 @@
-0.14.2
+0.14.3

package/package.json

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

package/src/hooks/passive-classifier.ts

@@ -111,6 +111,36 @@ export class PassiveClassifier {
 
     // Check for new file creation (Write tool)
     if (input.tool_name?.toLowerCase() === 'write') {
+      // Check file content for decision/correction language before defaulting to pattern
+      if (typeof content === 'string' && content.length > 50) {
+        const decisionInContent = this.detectDecisionLanguage(content)
+        if (decisionInContent) {
+          return {
+            type: 'decision',
+            confidence: 0.8,
+            content: decisionInContent,
+            project: this.extractProjectFromCwd(input.cwd),
+            technologies,
+            metadata: { filePath, role, action: 'create' },
+            source: 'hook-passive',
+            timestamp: new Date().toISOString(),
+          }
+        }
+        const correctionInContent = this.detectCorrectionLanguage(content)
+        if (correctionInContent) {
+          return {
+            type: 'correction',
+            confidence: 0.75,
+            content: correctionInContent,
+            project: this.extractProjectFromCwd(input.cwd),
+            technologies,
+            metadata: { filePath, role, action: 'create' },
+            source: 'hook-passive',
+            timestamp: new Date().toISOString(),
+          }
+        }
+      }
+
       return {
         type: 'pattern',
         confidence: 0.7,
@@ -161,10 +191,19 @@ export class PassiveClassifier {
   }
 
   private classifyBashCommand(input: HookInput): CapturedKnowledge | null {
-    const command = (input.tool_input?.command || '') as string
-    if (!command || command.length < 3) return null
+    const rawCommand = (input.tool_input?.command || '') as string
+    if (!rawCommand || rawCommand.length < 3) return null
+
+    // Split compound commands (cd "..." && bun add react) into sub-commands
+    const subCommands = rawCommand.split(/\s*(?:&&|\|\||;)\s*/).map(s => s.trim()).filter(Boolean)
+
+    // Find the first meaningful sub-command (skip cd, export, etc.)
+    const command = subCommands.find(sub => {
+      const firstWord = sub.split(/\s+/)[0]?.toLowerCase()
+      return !firstWord || !SKIP_COMMANDS.has(firstWord)
+    }) || rawCommand
 
-    // Skip low-signal commands
+    // If all sub-commands are skip-worthy, bail
     const firstWord = command.trim().split(/\s+/)[0]?.toLowerCase()
     if (firstWord && SKIP_COMMANDS.has(firstWord)) return null
 
@@ -180,7 +219,7 @@ export class PassiveClassifier {
             content: `Installed package(s): ${packages}`,
             project: this.extractProjectFromCwd(input.cwd),
             technologies: this.extractTechFromPackages(packages),
-            metadata: { command, action: 'install' },
+            metadata: { command: rawCommand, action: 'install' },
             source: 'hook-passive',
             timestamp: new Date().toISOString(),
           }
@@ -198,16 +237,17 @@ export class PassiveClassifier {
           content: `Git: ${command.trim().slice(0, 200)}`,
           project: this.extractProjectFromCwd(input.cwd),
           technologies: ['git'],
-          metadata: { command, action: 'git' },
+          metadata: { command: rawCommand, action: 'git' },
           source: 'hook-passive',
           timestamp: new Date().toISOString(),
         }
       }
     }
 
-    // Test/build runs
+    // Test/build runs — check all sub-commands since test may follow cd
+    const buildCommand = subCommands.find(sub => BUILD_PATTERNS.some(p => p.test(sub))) || command
     for (const pattern of BUILD_PATTERNS) {
-      if (pattern.test(command)) {
+      if (pattern.test(buildCommand)) {
         const responseText = this.extractResponseText(input.tool_response)
         const failed = responseText?.toLowerCase().includes('fail') ||
                        responseText?.toLowerCase().includes('error')
@@ -216,10 +256,10 @@ export class PassiveClassifier {
           return {
             type: 'correction',
             confidence: 0.75,
-            content: `Build/test failure: ${command.trim().slice(0, 100)}`,
+            content: `Build/test failure: ${buildCommand.trim().slice(0, 100)}`,
             project: this.extractProjectFromCwd(input.cwd),
             technologies: [],
-            metadata: { command, action: 'build', failed: true },
+            metadata: { command: rawCommand, action: 'build', failed: true },
             source: 'hook-passive',
             timestamp: new Date().toISOString(),
           }
@@ -228,10 +268,10 @@ export class PassiveClassifier {
         return {
           type: 'progress',
           confidence: 0.7,
-          content: `Ran: ${command.trim().slice(0, 200)}`,
+          content: `Ran: ${buildCommand.trim().slice(0, 200)}`,
           project: this.extractProjectFromCwd(input.cwd),
           technologies: [],
-          metadata: { command, action: 'build', failed: false },
+          metadata: { command: rawCommand, action: 'build', failed: false },
           source: 'hook-passive',
           timestamp: new Date().toISOString(),
         }
@@ -249,7 +289,7 @@ export class PassiveClassifier {
           content: correction,
           project: this.extractProjectFromCwd(input.cwd),
           technologies: [],
-          metadata: { command, action: 'bash' },
+          metadata: { command: rawCommand, action: 'bash' },
           source: 'hook-passive',
           timestamp: new Date().toISOString(),
         }
@@ -281,7 +321,7 @@ export class PassiveClassifier {
 
   /** Extract file role from path segments */
   private extractRoleFromPath(filePath: string): string | undefined {
-    const segments = filePath.toLowerCase().split('/')
+    const segments = filePath.toLowerCase().split(/[/\\]/)
     for (const segment of segments) {
       if (PATH_ROLE_MAP[segment]) return PATH_ROLE_MAP[segment]
     }
@@ -331,7 +371,8 @@ export class PassiveClassifier {
   /** Extract project name from cwd (last directory segment) */
   private extractProjectFromCwd(cwd: string): string | undefined {
     if (!cwd) return undefined
-    const parts = cwd.split('/').filter(Boolean)
+    // Split on both / and \ for cross-platform support
+    const parts = cwd.split(/[/\\]/).filter(Boolean)
     const last = parts.pop()
     if (last && last.length > 1 && last.length < 50) {
       return last.replace(/\s+/g, '-').toLowerCase()
@@ -341,7 +382,7 @@ export class PassiveClassifier {
 
   /** Shorten a file path for display */
   private shortenPath(filePath: string): string {
-    const parts = filePath.split('/')
+    const parts = filePath.split(/[/\\]/)
     if (parts.length <= 3) return filePath
     return `.../${parts.slice(-3).join('/')}`
   }