claude-brain 0.24.2 → 0.25.1

package/VERSION

@@ -1 +1 @@
-0.24.2
+0.25.1

package/package.json

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

package/scripts/postinstall.mjs

@@ -165,6 +165,7 @@ logLevel: warn
 const HOOK_FILES = [
   'brain-hook.ts',
   'context-hook.ts',
+  'interceptor-hook.ts',
   'capture.ts',
   'queue.ts',
   'types.ts',
@@ -215,7 +216,8 @@ function installHooks() {
       hasOurHooks(settings.hooks.PostToolUse) &&
       hasOurHooks(settings.hooks.Stop) &&
       hasOurHooks(settings.hooks.UserPromptSubmit) &&
-      hasOurHooks(settings.hooks.SessionStart)) {
+      hasOurHooks(settings.hooks.SessionStart) &&
+      hasOurHooks(settings.hooks.PreToolUse)) {
     log('Hooks already installed')
     return true
   }
@@ -223,8 +225,10 @@ function installHooks() {
   // Build hook command
   const brainScriptPath = join(HOME, 'hooks', 'brain-hook.ts')
   const contextScriptPath = join(HOME, 'hooks', 'context-hook.ts')
+  const interceptorScriptPath = join(HOME, 'hooks', 'interceptor-hook.ts')
+  const port = process.env.CLAUDE_BRAIN_PORT || process.env.PORT || '3000'
   function buildCmd(event, scriptPath) {
-    return `bun "${scriptPath}" --event ${event} # ${HOOK_MARKER}`
+    return `bun "${scriptPath}" --event ${event} --port ${port} # ${HOOK_MARKER}`
   }
 
   if (!settings.hooks) settings.hooks = {}
@@ -265,6 +269,19 @@ function installHooks() {
     })
   }
 
+  // PreToolUse — code intelligence interceptor for Glob and Grep
+  if (!hasOurHooks(settings.hooks.PreToolUse)) {
+    if (!settings.hooks.PreToolUse) settings.hooks.PreToolUse = []
+    settings.hooks.PreToolUse.push({
+      matcher: 'Glob',
+      hooks: [{ type: 'command', command: buildCmd('PreToolUse', interceptorScriptPath) }],
+    })
+    settings.hooks.PreToolUse.push({
+      matcher: 'Grep',
+      hooks: [{ type: 'command', command: buildCmd('PreToolUse', interceptorScriptPath) }],
+    })
+  }
+
   // Write atomically
   if (!existsSync(CLAUDE_DIR)) {
     mkdirSync(CLAUDE_DIR, { recursive: true })

package/src/hooks/context-hook.ts

@@ -109,7 +109,7 @@ async function main(): Promise<void> {
       }).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 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 || '')}`, {
@@ -135,7 +135,7 @@ async function main(): Promise<void> {
       if (input.cwd) params.set('cwd', input.cwd)
 
       // Extract project name from cwd for code map
-      const projectName = input.cwd ? input.cwd.split('/').filter(Boolean).pop() : undefined
+      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([

package/src/hooks/git-capture.ts

@@ -70,7 +70,7 @@ function resolveProjectName(raw: string): string {
   let name = raw.trim()
   // Strip npm scoped prefix: @scope/name → name
   if (name.startsWith('@') && name.includes('/')) {
-    name = name.split('/').pop() || name
+    name = name.split(/[/\\]/).pop() || name
   }
   return name || raw
 }

package/src/hooks/installer.ts

@@ -22,6 +22,11 @@ export function getContextHookScriptPath(): string {
   return join(getClaudeBrainHome(), 'hooks', 'context-hook.ts')
 }
 
+/** Get the path where the interceptor-hook script should be installed */
+export function getInterceptorHookScriptPath(): string {
+  return join(getClaudeBrainHome(), 'hooks', 'interceptor-hook.ts')
+}
+
 /** Read Claude Code settings.json, creating if needed */
 function readSettings(): Record<string, any> {
   if (!existsSync(CLAUDE_SETTINGS_PATH)) return {}
@@ -47,8 +52,12 @@ function writeSettings(settings: Record<string, any>): void {
 /** 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()
+function buildHookCommand(event: string, script: 'brain-hook' | 'context-hook' | 'interceptor-hook' = 'brain-hook'): string {
+  const scriptPath = script === 'context-hook'
+    ? getContextHookScriptPath()
+    : script === 'interceptor-hook'
+      ? getInterceptorHookScriptPath()
+      : getHookScriptPath()
   const port = process.env.PORT || process.env.CLAUDE_BRAIN_PORT || '3000'
 
   return `bun "${scriptPath}" --event ${event} --port ${port} # ${HOOK_MARKER}`
@@ -108,6 +117,23 @@ export function installHooks(): { installed: boolean; message: string } {
     }],
   })
 
+  // PreToolUse interceptor — blocks Glob/Grep when code index has results
+  if (!settings.hooks.PreToolUse) settings.hooks.PreToolUse = []
+  settings.hooks.PreToolUse.push({
+    matcher: 'Glob',
+    hooks: [{
+      type: 'command',
+      command: buildHookCommand('PreToolUse', 'interceptor-hook'),
+    }],
+  })
+  settings.hooks.PreToolUse.push({
+    matcher: 'Grep',
+    hooks: [{
+      type: 'command',
+      command: buildHookCommand('PreToolUse', 'interceptor-hook'),
+    }],
+  })
+
   writeSettings(settings)
 
   // Copy hook script to install location
@@ -167,6 +193,16 @@ export function uninstallHooks(): { uninstalled: boolean; message: string } {
       }
     }
 
+    // Remove our entries from PreToolUse
+    if (Array.isArray(settings.hooks.PreToolUse)) {
+      settings.hooks.PreToolUse = settings.hooks.PreToolUse.filter(
+        (entry: any) => !isOurHookEntry(entry)
+      )
+      if (settings.hooks.PreToolUse.length === 0) {
+        delete settings.hooks.PreToolUse
+      }
+    }
+
     // Clean up empty hooks object
     if (Object.keys(settings.hooks).length === 0) {
       delete settings.hooks
@@ -194,7 +230,10 @@ export function isHooksInstalled(): boolean {
   const hasUserPromptSubmit = Array.isArray(settings.hooks.UserPromptSubmit) &&
     settings.hooks.UserPromptSubmit.some((entry: any) => isOurHookEntry(entry))
 
-  return hasPostToolUse || hasStop || hasUserPromptSubmit
+  const hasPreToolUse = Array.isArray(settings.hooks.PreToolUse) &&
+    settings.hooks.PreToolUse.some((entry: any) => isOurHookEntry(entry))
+
+  return hasPostToolUse || hasStop || hasUserPromptSubmit || hasPreToolUse
 }
 
 /** Check if a hook entry belongs to us (by marker in command) */
@@ -209,6 +248,7 @@ function isOurHookEntry(entry: any): boolean {
 const HOOK_FILES = [
   'brain-hook.ts',
   'context-hook.ts',
+  'interceptor-hook.ts',
   'capture.ts',
   'queue.ts',
   'types.ts',

package/src/hooks/interceptor-hook.ts

@@ -0,0 +1,201 @@
+#!/usr/bin/env bun
+/**
+ * Code Intelligence Interceptor — PreToolUse Hook
+ *
+ * Intercepts Glob and Grep calls, queries the code index,
+ * and blocks the tool when confident results exist.
+ *
+ * CRITICAL CONSTRAINTS:
+ * - Must complete in <3s (PreToolUse timeout)
+ * - Stderr = message shown to Claude when blocking
+ * - Exit 0 = allow tool, exit non-zero = block tool
+ * - NEVER write to stdout (corrupts JSON-RPC)
+ */
+
+interface HookStdin {
+  session_id: string
+  tool_name: string
+  tool_input: Record<string, any>
+  cwd?: string
+}
+
+interface SymbolResult {
+  symbol: string
+  type: string
+  filePath: string
+  lineStart: number
+  lineEnd?: number
+  signature?: string
+  confidence: number
+}
+
+async function main(): Promise<void> {
+  const rawInput = await readStdin()
+  if (!rawInput.trim()) { process.exit(0); return }
+
+  let input: HookStdin
+  try { input = JSON.parse(rawInput) }
+  catch { process.exit(0); return }
+
+  // Only intercept Glob and Grep
+  if (!['Glob', 'Grep'].includes(input.tool_name)) {
+    process.exit(0)
+    return
+  }
+
+  // Extract search intent from tool input
+  const searchTerm = extractSearchIntent(input)
+  if (!searchTerm) { process.exit(0); return }
+
+  // Detect project from cwd
+  const project = detectProject(input.cwd)
+  if (!project) { process.exit(0); return }
+
+  // Read port from --port arg or env
+  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)
+
+  try {
+    const params = new URLSearchParams({
+      query: searchTerm,
+      project,
+      limit: '10',
+    })
+
+    const res = await fetch(
+      `http://localhost:${port}/api/code/search?${params}`,
+      { signal: AbortSignal.timeout(2000) }
+    )
+
+    if (!res.ok) { process.exit(0); return }
+
+    const data = await res.json() as { data?: SymbolResult[] }
+    const results: SymbolResult[] = Array.isArray(data.data) ? data.data : (data.data as any) || []
+
+    // Only block if we have confident results
+    if (results.length > 0 && results[0].confidence > 0.7) {
+      const message = formatResults(results, input.tool_name, searchTerm)
+      process.stderr.write(message)
+      process.exit(2) // non-zero = BLOCK
+    } else {
+      process.exit(0) // let original tool run
+    }
+  } catch {
+    // Any error = let original tool run (safe fallback)
+    process.exit(0)
+  }
+}
+
+function extractSearchIntent(input: HookStdin): string | null {
+  const toolInput = input.tool_input
+
+  if (input.tool_name === 'Glob') {
+    const pattern = toolInput.pattern || ''
+    if (isGenericGlob(pattern)) return null
+    return extractGlobKeyword(pattern)
+  }
+
+  if (input.tool_name === 'Grep') {
+    const pattern = toolInput.pattern || ''
+    if (isComplexRegex(pattern)) return null
+    return pattern
+  }
+
+  return null
+}
+
+/** Returns true for patterns like "**\/*.ts", "**\/*.js" that match too broadly */
+function isGenericGlob(pattern: string): boolean {
+  return /^\*\*\/\*\.\w+$/.test(pattern)
+}
+
+/** Extract the meaningful keyword from a glob pattern */
+function extractGlobKeyword(pattern: string): string | null {
+  const cleaned = pattern
+    .replace(/\*\*/g, '')
+    .replace(/\*/g, '')
+    .replace(/\//g, ' ')
+    .replace(/\.\w+$/g, '') // remove extension
+    .trim()
+
+  const words = cleaned.split(/\s+/).filter(w => w.length >= 3)
+  return words.length > 0 ? words.join(' ') : null
+}
+
+/** Returns true for patterns that are complex regex, not simple symbol names */
+function isComplexRegex(pattern: string): boolean {
+  // Simple word-like patterns are fine to intercept
+  if (/^\w+$/.test(pattern)) return false
+  // Patterns with regex meta-chars are complex
+  return /[\\()[\]{}|^$+?]/.test(pattern)
+}
+
+function detectProject(cwd?: string): string | null {
+  if (!cwd) return null
+  // Split by both / and \ for cross-platform support (Windows uses backslashes)
+  const segments = cwd.split(/[/\\]/).filter(Boolean)
+  return segments[segments.length - 1] || null
+}
+
+function formatResults(
+  results: SymbolResult[],
+  toolName: string,
+  searchTerm: string
+): string {
+  const lines: string[] = [
+    `Code index found ${results.length} match${results.length === 1 ? '' : 'es'} for "${searchTerm}" (skip ${toolName}, use Read directly):`,
+    '',
+  ]
+
+  for (const r of results.slice(0, 8)) {
+    const sig = r.signature ? ` ${r.signature}` : ''
+    const lineRange = r.lineEnd
+      ? `${r.lineStart}-${r.lineEnd}`
+      : `${r.lineStart}`
+    lines.push(
+      `  ${r.symbol} (${r.type})${sig} → ${r.filePath}:${lineRange}`
+    )
+  }
+
+  if (results.length > 8) {
+    lines.push(`  ... and ${results.length - 8} more`)
+  }
+
+  // Add actionable tip
+  lines.push('')
+  const top = results[0]!
+  const offset = Math.max(1, top.lineStart - 5)
+  const limit = ((top.lineEnd || top.lineStart) + 20) - top.lineStart + 10
+  lines.push(
+    `Tip: Read("${top.filePath}", offset=${offset}, limit=${limit}) for the ${top.type} body.`
+  )
+
+  return lines.join('\n')
+}
+
+/** 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('interceptor-hook')
+if (isDirectRun) {
+  main().catch(() => process.exit(0))
+}
+
+export { main }

package/src/hooks/passive-classifier.ts

@@ -305,7 +305,7 @@ export class PassiveClassifier {
     }
 
     // Check for Dockerfile without extension
-    const basename = filePath.split('/').pop()?.toLowerCase() || ''
+    const basename = filePath.split(/[/\\]/).pop()?.toLowerCase() || ''
     if (basename === 'dockerfile' || basename.startsWith('dockerfile.')) {
       techs.push('docker')
     }