claude-brain 0.15.2 → 0.17.0

package/src/hooks/brain-hook.ts

@@ -1,112 +1,128 @@
-#!/usr/bin/env bun
-/**
- * Phase 17: Brain Hook Worker Script
- * Standalone entry point executed by Claude Code on every tool call.
- *
- * CRITICAL CONSTRAINTS:
- * - Must complete in <200ms (no heavy imports like ChromaDB/embeddings)
- * - NEVER write to stdout (would corrupt Claude Code JSON-RPC)
- * - All errors silently caught with process.exit(0)
- * - Reads stdin JSON from Claude Code, classifies, POSTs to HTTP API
- */
-
-import { BrainCapture } from './capture'
-import { appendToQueue } from './queue'
-import type { HookInput } from './types'
-
-export 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: HookInput
-  try {
-    input = JSON.parse(rawInput)
-  } catch {
-    process.exit(0)
-    return
-  }
-
-  // Override event name from arg if provided
-  if (eventName) {
-    input.hook_event_name = eventName as HookInput['hook_event_name']
-  }
-
-  // Phase 20: Hooks enabled by default — only disabled by explicit env var
-  if (process.env.CLAUDE_BRAIN_HOOKS_ENABLED === 'false') {
-    process.exit(0)
-    return
-  }
-
-  const port = parseInt(process.env.CLAUDE_BRAIN_PORT || '3000', 10)
-
-  // Process the hook event
-  const capture = new BrainCapture({ enabled: true })
-  const knowledge = capture.process(input)
-
-  if (!knowledge) {
-    process.exit(0)
-    return
-  }
-
-  // POST to HTTP API server
-  try {
-    const res = await fetch(`http://localhost:${port}/api/hooks/ingest`, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({
-        knowledge: [knowledge],
-        sessionId: input.session_id,
-      }),
-      signal: AbortSignal.timeout(3000),
-    })
-
-    if (!res.ok) {
-      // Server returned error — queue for later
-      appendToQueue([knowledge])
-    }
-  } catch {
-    // Server unreachable — append to offline queue
-    appendToQueue([knowledge])
-  }
-
-  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 (not when imported by CLI)
-const isDirectRun = process.argv[1]?.includes('brain-hook')
-if (isDirectRun) {
-  main().catch(() => process.exit(0))
-}
+#!/usr/bin/env bun
+/**
+ * Phase 17: Brain Hook Worker Script
+ * Standalone entry point executed by Claude Code on every tool call.
+ *
+ * CRITICAL CONSTRAINTS:
+ * - Must complete in <200ms (no heavy imports like ChromaDB/embeddings)
+ * - NEVER write to stdout (would corrupt Claude Code JSON-RPC)
+ * - All errors silently caught with process.exit(0)
+ * - Reads stdin JSON from Claude Code, classifies, POSTs to HTTP API
+ */
+
+import { BrainCapture } from './capture'
+import { appendToQueue } from './queue'
+import type { HookInput } from './types'
+
+export 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: HookInput
+  try {
+    input = JSON.parse(rawInput)
+  } catch {
+    process.exit(0)
+    return
+  }
+
+  // Override event name from arg if provided
+  if (eventName) {
+    input.hook_event_name = eventName as HookInput['hook_event_name']
+  }
+
+  // Phase 20: Hooks enabled by default — only disabled by explicit env var
+  if (process.env.CLAUDE_BRAIN_HOOKS_ENABLED === 'false') {
+    process.exit(0)
+    return
+  }
+
+  const port = parseInt(process.env.CLAUDE_BRAIN_PORT || '3000', 10)
+
+  // For Stop events: trigger session-end summarization regardless of classification
+  if (input.hook_event_name === 'Stop' && input.session_id) {
+    try {
+      await fetch(`http://localhost:${port}/api/hooks/session-end`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ sessionId: input.session_id }),
+        signal: AbortSignal.timeout(5000),
+      })
+    } catch {
+      // Server unreachable — session summary lost, acceptable tradeoff
+    }
+    process.exit(0)
+    return
+  }
+
+  // Process the hook event (non-Stop events only)
+  const capture = new BrainCapture({ enabled: true })
+  const knowledge = capture.process(input)
+
+  if (!knowledge) {
+    process.exit(0)
+    return
+  }
+
+  // POST to HTTP API server
+  try {
+    const res = await fetch(`http://localhost:${port}/api/hooks/ingest`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        knowledge: [knowledge],
+        sessionId: input.session_id,
+      }),
+      signal: AbortSignal.timeout(3000),
+    })
+
+    if (!res.ok) {
+      // Server returned error — queue for later
+      appendToQueue([knowledge])
+    }
+  } catch {
+    // Server unreachable — append to offline queue
+    appendToQueue([knowledge])
+  }
+
+  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 (not when imported by CLI)
+const isDirectRun = process.argv[1]?.includes('brain-hook')
+if (isDirectRun) {
+  main().catch(() => process.exit(0))
+}

package/src/hooks/capture.ts

@@ -1,205 +1,168 @@
-/**
- * Phase 17: Capture Engine
- * Orchestrates passive classification + entity extraction with privacy filters.
- */
-
-import type { HookInput, CapturedKnowledge } from './types'
-import type { HooksConfig } from '@/config/schema'
-import { PassiveClassifier } from './passive-classifier'
-
-// Reuse tech dictionaries from entity extractor for enrichment
-const COMMON_TECH: Set<string> = new Set([
-  'typescript', 'javascript', 'python', 'rust', 'go', 'java', 'ruby', 'php', 'swift', 'kotlin',
-  'react', 'vue', 'angular', 'svelte', 'nextjs', 'nuxt', 'remix', 'astro', 'solid',
-  'express', 'fastify', 'hono', 'nestjs', 'django', 'flask', 'fastapi', 'rails', 'spring',
-  'mongodb', 'redis', 'postgresql', 'postgres', 'mysql', 'sqlite', 'dynamodb', 'firebase', 'supabase',
-  'prisma', 'drizzle', 'typeorm', 'sequelize', 'chromadb', 'pinecone',
-  'docker', 'kubernetes', 'aws', 'gcp', 'azure', 'vercel', 'netlify',
-  'webpack', 'vite', 'esbuild', 'bun', 'deno', 'node', 'npm', 'yarn', 'pnpm',
-  'jest', 'vitest', 'cypress', 'playwright',
-  'tailwind', 'bootstrap', 'zod', 'trpc', 'graphql', 'rest',
-  'jwt', 'oauth', 'openai', 'anthropic', 'langchain',
-  'git', 'github', 'gitlab', 'eslint', 'prettier',
-  'zustand', 'redux', 'pinia', 'mobx', 'jotai', 'recoil',
-  'storybook', 'turborepo', 'nx',
-  'microservices', 'serverless', 'monolith', 'ssr', 'ssg', 'spa', 'pwa', 'mcp', 'rag'
-])
-
-const TECH_ALIASES: Record<string, string> = {
-  'ts': 'typescript', 'js': 'javascript', 'py': 'python',
-  'react.js': 'react', 'reactjs': 'react', 'vue.js': 'vue', 'vuejs': 'vue',
-  'next.js': 'nextjs', 'nuxt.js': 'nuxt', 'nest.js': 'nestjs',
-  'express.js': 'express', 'node.js': 'node', 'nodejs': 'node',
-  'mongo': 'mongodb', 'pg': 'postgresql', 'k8s': 'kubernetes',
-  'tailwindcss': 'tailwind', 'tailwind-css': 'tailwind',
-  'gql': 'graphql', 'golang': 'go',
-}
-
-/** Phase 20: Default privacy ignore paths for sensitive files */
-const DEFAULT_IGNORE_PATHS = [
-  'node_modules/**', '.env*', '*.key', '*.pem', '*.p12', '*.pfx',
-  '.git/**', 'dist/**', 'build/**', '*.secret', 'credentials*',
-  '.aws/**', '.ssh/**',
-  // Fix 4: Brain internal files
-  '.claude-brain/data/**',
-  '.claude-brain/logs/**',
-  // Fix 4: Claude Code temp files
-  '**/scratchpad/**',
-  // Fix 4: Claude plans (ephemeral)
-  '.claude/plans/**',
-]
-
-/** Fix 4: Path segments that indicate internal/temp files to never capture */
-const NOISE_PATH_SEGMENTS = [
-  '/scratchpad/',
-  '/.claude-brain/data/',
-  '/.claude-brain/logs/',
-  '/.claude/plans/',
-  '\\scratchpad\\',
-  '\\.claude-brain\\data\\',
-  '\\.claude-brain\\logs\\',
-  '\\.claude\\plans\\',
-]
-
-export class BrainCapture {
-  private classifier: PassiveClassifier
-  private config: HooksConfig
-
-  constructor(config?: Partial<HooksConfig>) {
-    this.config = {
-      enabled: config?.enabled ?? true,
-      capture: {
-        toolUse: config?.capture?.toolUse ?? true,
-        fileEdits: config?.capture?.fileEdits ?? true,
-        bashCommands: config?.capture?.bashCommands ?? true,
-        userMessages: config?.capture?.userMessages ?? true,
-      },
-      privacy: {
-        ignorePaths: config?.privacy?.ignorePaths ?? DEFAULT_IGNORE_PATHS,
-        ignoreProjects: config?.privacy?.ignoreProjects ?? [],
-        minConfidence: config?.privacy?.minConfidence ?? 0.7,
-      },
-      sessions: {
-        enabled: config?.sessions?.enabled ?? true,
-        idleTimeoutMinutes: config?.sessions?.idleTimeoutMinutes ?? 30,
-        minEventsForSummary: config?.sessions?.minEventsForSummary ?? 3,
-      },
-      deduplication: {
-        skipThreshold: config?.deduplication?.skipThreshold ?? 0.95,
-        mergeThreshold: config?.deduplication?.mergeThreshold ?? 0.85,
-      },
-    }
-    this.classifier = new PassiveClassifier()
-  }
-
-  /**
-   * Process a hook input event.
-   * Returns captured knowledge or null if nothing worth capturing.
-   */
-  process(input: HookInput): CapturedKnowledge | null {
-    if (!this.config.enabled) return null
-
-    // Privacy: check ignored paths
-    if (this.isPathIgnored(input.cwd)) return null
-
-    // Fix 4: Check individual file paths for internal/temp files
-    const filePath = input.tool_input?.file_path || input.tool_input?.path
-    if (typeof filePath === 'string' && this.isFilePathIgnored(filePath)) return null
-
-    // Check capture toggles by tool type
-    if (!this.shouldCapture(input)) return null
-
-    // Classify tool output
-    const knowledge = this.classifier.classify(input)
-    if (!knowledge) return null
-
-    // Privacy: check ignored projects
-    if (knowledge.project && this.config.privacy.ignoreProjects.includes(knowledge.project)) {
-      return null
-    }
-
-    // Enrich with additional technology detection from content
-    knowledge.technologies = this.enrichTechnologies(knowledge)
-
-    // Filter by minimum confidence
-    if (knowledge.confidence < this.config.privacy.minConfidence) {
-      return null
-    }
-
-    return knowledge
-  }
-
-  /** Check if a path matches any ignore pattern */
-  private isPathIgnored(cwd: string): boolean {
-    if (!cwd || this.config.privacy.ignorePaths.length === 0) return false
-    const lowerCwd = cwd.toLowerCase()
-    return this.config.privacy.ignorePaths.some(pattern => {
-      const lowerPattern = pattern.toLowerCase()
-      // Simple glob: just check if pattern appears in path
-      if (lowerPattern.includes('*')) {
-        const regex = new RegExp(lowerPattern.replace(/\*/g, '.*'))
-        return regex.test(lowerCwd)
-      }
-      return lowerCwd.includes(lowerPattern)
-    })
-  }
-
-  /** Check if this tool type should be captured based on config */
-  private shouldCapture(input: HookInput): boolean {
-    const toolName = input.tool_name?.toLowerCase()
-
-    // Fix 6: Allow Stop events through (handled by classifier)
-    if (!toolName) {
-      return input.hook_event_name === 'Stop'
-    }
-
-    switch (toolName) {
-      case 'edit':
-      case 'write':
-        return this.config.capture.fileEdits
-      case 'bash':
-        return this.config.capture.bashCommands
-      default:
-        return this.config.capture.toolUse
-    }
-  }
-
-  /** Fix 4: Check if a file path points to internal/temp files */
-  private isFilePathIgnored(filePath: string): boolean {
-    if (!filePath) return false
-    const normalized = filePath.toLowerCase().replace(/\\/g, '/')
-    return NOISE_PATH_SEGMENTS.some(seg => {
-      const normalizedSeg = seg.replace(/\\/g, '/')
-      return normalized.includes(normalizedSeg)
-    })
-  }
-
-  /** Enrich technologies by scanning content text for known tech names */
-  private enrichTechnologies(knowledge: CapturedKnowledge): string[] {
-    const existing = new Set(knowledge.technologies)
-    const lower = knowledge.content.toLowerCase()
-    const words = lower.split(/[\s,;:()[\]{}"'`|/\\]+/)
-
-    for (const word of words) {
-      const cleaned = word.replace(/^[^a-z0-9]+|[^a-z0-9]+$/g, '')
-      if (cleaned.length < 2) continue
-
-      if (COMMON_TECH.has(cleaned) && !existing.has(cleaned)) {
-        existing.add(cleaned)
-      }
-      const alias = TECH_ALIASES[cleaned]
-      if (alias && !existing.has(alias)) {
-        existing.add(alias)
-      }
-    }
-
-    // Check multi-word aliases
-    for (const [alias, normalized] of Object.entries(TECH_ALIASES)) {
-      if ((alias.includes('.') || alias.includes('-')) && lower.includes(alias) && !existing.has(normalized)) {
-        existing.add(normalized)
-      }
-    }
-
-    return Array.from(existing)
-  }
-}
+/**
+ * Phase 17: Capture Engine
+ * Orchestrates passive classification + entity extraction with privacy filters.
+ */
+
+import type { HookInput, CapturedKnowledge } from './types'
+import type { HooksConfig } from '@/config/schema'
+import { PassiveClassifier } from './passive-classifier'
+
+// Reuse tech dictionaries from entity extractor for enrichment
+const COMMON_TECH: Set<string> = new Set([
+  'typescript', 'javascript', 'python', 'rust', 'go', 'java', 'ruby', 'php', 'swift', 'kotlin',
+  'react', 'vue', 'angular', 'svelte', 'nextjs', 'nuxt', 'remix', 'astro', 'solid',
+  'express', 'fastify', 'hono', 'nestjs', 'django', 'flask', 'fastapi', 'rails', 'spring',
+  'mongodb', 'redis', 'postgresql', 'postgres', 'mysql', 'sqlite', 'dynamodb', 'firebase', 'supabase',
+  'prisma', 'drizzle', 'typeorm', 'sequelize', 'chromadb', 'pinecone',
+  'docker', 'kubernetes', 'aws', 'gcp', 'azure', 'vercel', 'netlify',
+  'webpack', 'vite', 'esbuild', 'bun', 'deno', 'node', 'npm', 'yarn', 'pnpm',
+  'jest', 'vitest', 'cypress', 'playwright',
+  'tailwind', 'bootstrap', 'zod', 'trpc', 'graphql', 'rest',
+  'jwt', 'oauth', 'openai', 'anthropic', 'langchain',
+  'git', 'github', 'gitlab', 'eslint', 'prettier',
+  'zustand', 'redux', 'pinia', 'mobx', 'jotai', 'recoil',
+  'storybook', 'turborepo', 'nx',
+  'microservices', 'serverless', 'monolith', 'ssr', 'ssg', 'spa', 'pwa', 'mcp', 'rag'
+])
+
+const TECH_ALIASES: Record<string, string> = {
+  'ts': 'typescript', 'js': 'javascript', 'py': 'python',
+  'react.js': 'react', 'reactjs': 'react', 'vue.js': 'vue', 'vuejs': 'vue',
+  'next.js': 'nextjs', 'nuxt.js': 'nuxt', 'nest.js': 'nestjs',
+  'express.js': 'express', 'node.js': 'node', 'nodejs': 'node',
+  'mongo': 'mongodb', 'pg': 'postgresql', 'k8s': 'kubernetes',
+  'tailwindcss': 'tailwind', 'tailwind-css': 'tailwind',
+  'gql': 'graphql', 'golang': 'go',
+}
+
+/** Phase 20: Default privacy ignore paths for sensitive files */
+const DEFAULT_IGNORE_PATHS = [
+  'node_modules/**', '.env*', '*.key', '*.pem', '*.p12', '*.pfx',
+  '.git/**', 'dist/**', 'build/**', '*.secret', 'credentials*',
+  '.aws/**', '.ssh/**'
+]
+
+export class BrainCapture {
+  private classifier: PassiveClassifier
+  private config: HooksConfig
+
+  constructor(config?: Partial<HooksConfig>) {
+    this.config = {
+      enabled: config?.enabled ?? true,
+      capture: {
+        toolUse: config?.capture?.toolUse ?? true,
+        fileEdits: config?.capture?.fileEdits ?? true,
+        bashCommands: config?.capture?.bashCommands ?? true,
+        userMessages: config?.capture?.userMessages ?? true,
+      },
+      privacy: {
+        ignorePaths: config?.privacy?.ignorePaths ?? DEFAULT_IGNORE_PATHS,
+        ignoreProjects: config?.privacy?.ignoreProjects ?? [],
+        minConfidence: config?.privacy?.minConfidence ?? 0.7,
+      },
+      sessions: {
+        enabled: config?.sessions?.enabled ?? true,
+        idleTimeoutMinutes: config?.sessions?.idleTimeoutMinutes ?? 30,
+        minEventsForSummary: config?.sessions?.minEventsForSummary ?? 3,
+      },
+      deduplication: {
+        skipThreshold: config?.deduplication?.skipThreshold ?? 0.95,
+        mergeThreshold: config?.deduplication?.mergeThreshold ?? 0.85,
+      },
+    }
+    this.classifier = new PassiveClassifier()
+  }
+
+  /**
+   * Process a hook input event.
+   * Returns captured knowledge or null if nothing worth capturing.
+   */
+  process(input: HookInput): CapturedKnowledge | null {
+    if (!this.config.enabled) return null
+
+    // Privacy: check ignored paths
+    if (this.isPathIgnored(input.cwd)) return null
+
+    // Check capture toggles by tool type
+    if (!this.shouldCapture(input)) return null
+
+    // Classify tool output
+    const knowledge = this.classifier.classify(input)
+    if (!knowledge) return null
+
+    // Privacy: check ignored projects
+    if (knowledge.project && this.config.privacy.ignoreProjects.includes(knowledge.project)) {
+      return null
+    }
+
+    // Enrich with additional technology detection from content
+    knowledge.technologies = this.enrichTechnologies(knowledge)
+
+    // Filter by minimum confidence
+    if (knowledge.confidence < this.config.privacy.minConfidence) {
+      return null
+    }
+
+    return knowledge
+  }
+
+  /** Check if a path matches any ignore pattern */
+  private isPathIgnored(cwd: string): boolean {
+    if (!cwd || this.config.privacy.ignorePaths.length === 0) return false
+    const lowerCwd = cwd.toLowerCase()
+    return this.config.privacy.ignorePaths.some(pattern => {
+      const lowerPattern = pattern.toLowerCase()
+      // Simple glob: just check if pattern appears in path
+      if (lowerPattern.includes('*')) {
+        const regex = new RegExp(lowerPattern.replace(/\*/g, '.*'))
+        return regex.test(lowerCwd)
+      }
+      return lowerCwd.includes(lowerPattern)
+    })
+  }
+
+  /** Check if this tool type should be captured based on config */
+  private shouldCapture(input: HookInput): boolean {
+    const toolName = input.tool_name?.toLowerCase()
+    if (!toolName) return false
+
+    switch (toolName) {
+      case 'edit':
+      case 'write':
+        return this.config.capture.fileEdits
+      case 'bash':
+        return this.config.capture.bashCommands
+      default:
+        return this.config.capture.toolUse
+    }
+  }
+
+  /** Enrich technologies by scanning content text for known tech names */
+  private enrichTechnologies(knowledge: CapturedKnowledge): string[] {
+    const existing = new Set(knowledge.technologies)
+    const lower = knowledge.content.toLowerCase()
+    const words = lower.split(/[\s,;:()[\]{}"'`|/\\]+/)
+
+    for (const word of words) {
+      const cleaned = word.replace(/^[^a-z0-9]+|[^a-z0-9]+$/g, '')
+      if (cleaned.length < 2) continue
+
+      if (COMMON_TECH.has(cleaned) && !existing.has(cleaned)) {
+        existing.add(cleaned)
+      }
+      const alias = TECH_ALIASES[cleaned]
+      if (alias && !existing.has(alias)) {
+        existing.add(alias)
+      }
+    }
+
+    // Check multi-word aliases
+    for (const [alias, normalized] of Object.entries(TECH_ALIASES)) {
+      if ((alias.includes('.') || alias.includes('-')) && lower.includes(alias) && !existing.has(normalized)) {
+        existing.add(normalized)
+      }
+    }
+
+    return Array.from(existing)
+  }
+}