claude-brain 0.15.2 → 0.17.0

package/src/hooks/passive-classifier.ts

@@ -1,723 +1,404 @@
-/**
- * Phase 17: Passive Classifier
- * Extracts knowledge from tool outputs using lightweight pattern matching.
- * No embeddings needed — runs fast enough for hook context (<200ms).
- *
- * v2: Fixes from HOOK-CLASSIFIER-IMPROVEMENTS.md
- * - Fix 1: Smart content summarization for Write tool
- * - Fix 2: Edit context capture (not just decision language)
- * - Fix 3: Expanded Bash command coverage (server, process, docker)
- * - Fix 5: Pre-storage deduplication via LRU hash set
- * - Fix 6: Stop event handler for session summaries
- */
-
-import type { HookInput, CapturedKnowledge } from './types'
-
-/** Phrases that indicate a decision was made */
-const DECISION_PHRASES = [
-  'i recommend', 'you should use', 'the best approach', 'i suggest',
-  'better to use', 'prefer using', 'go with', 'choose', 'instead of',
-  'the right choice', 'decided to', "let's use", 'we will use',
-  'the solution is', 'implement using', 'going with', 'switching to',
-  'adopting', 'we chose', 'the plan is to'
-]
-
-/** Phrases indicating a correction or lesson */
-const CORRECTION_PHRASES = [
-  'the bug was', 'the issue was', 'the problem was', 'mistake was',
-  'should have', 'should not have', "shouldn't have",
-  'lesson learned', "don't use", 'avoid using', 'never use',
-  'the fix is', 'the fix was', 'fixed by', 'solved by'
-]
-
-/** Package install patterns for bash commands */
-const INSTALL_PATTERNS = [
-  /(?:npm|yarn|pnpm|bun)\s+(?:install|add|i)\s+(.+)/i,
-  /pip\s+install\s+(.+)/i,
-  /cargo\s+add\s+(.+)/i,
-  /go\s+get\s+(.+)/i,
-  /gem\s+install\s+(.+)/i,
-]
-
-/** Git operation patterns */
-const GIT_PATTERNS = [
-  /git\s+commit\s+.*-m\s+["'](.+?)["']/i,
-  /git\s+merge\s+(\S+)/i,
-  /git\s+checkout\s+-b\s+(\S+)/i,
-  /git\s+branch\s+(\S+)/i,
-]
-
-/** Test/build command patterns */
-const BUILD_PATTERNS = [
-  /(?:npm|yarn|pnpm|bun)\s+(?:run\s+)?(?:test|build|lint|typecheck|check)/i,
-  /(?:jest|vitest|pytest|cargo\s+test|go\s+test)/i,
-]
-
-/** Fix 3: Server start patterns */
-const SERVER_PATTERNS = [
-  /(?:bun|node|deno|python|python3)\s+(?:run\s+)?(\S+\.(?:ts|js|py|mjs))/i,
-  /(?:npm|yarn|pnpm|bun)\s+(?:run\s+)?(?:start|dev|serve)/i,
-  /(?:uvicorn|gunicorn|flask\s+run|rails\s+s)/i,
-]
-
-/** Fix 3: Process management patterns */
-const PROCESS_PATTERNS = [
-  /taskkill\s+.*(?:\/PID|\/IM)\s+(\S+)/i,
-  /kill\s+(?:-\d+\s+)?(\d+)/i,
-  /netstat\s+.*(?:-ano|-tulpn)/i,
-  /lsof\s+.*-i/i,
-  /fuser\s+.*\/tcp/i,
-]
-
-/** Fix 3: Docker patterns */
-const DOCKER_PATTERNS = [
-  /docker\s+(?:build|run|compose|push|pull|stop|rm|exec)\b/i,
-  /docker-compose\s+(?:up|down|build|restart)\b/i,
-]
-
-/** Bash commands to skip (low signal) */
-const SKIP_COMMANDS = new Set([
-  'cd', 'ls', 'cat', 'head', 'tail', 'pwd', 'echo', 'clear', 'which', 'whoami',
-  'date', 'env', 'printenv', 'export', 'source', 'alias', 'history',
-])
-
-/** File extension to technology mapping */
-const EXT_TO_TECH: Record<string, string> = {
-  '.ts': 'typescript', '.tsx': 'typescript', '.js': 'javascript', '.jsx': 'javascript',
-  '.py': 'python', '.rs': 'rust', '.go': 'go', '.java': 'java',
-  '.rb': 'ruby', '.php': 'php', '.swift': 'swift', '.kt': 'kotlin',
-  '.vue': 'vue', '.svelte': 'svelte', '.astro': 'astro',
-  '.css': 'css', '.scss': 'sass', '.less': 'less',
-  '.sql': 'sql', '.graphql': 'graphql', '.gql': 'graphql',
-  '.yml': 'yaml', '.yaml': 'yaml', '.toml': 'toml',
-  '.dockerfile': 'docker', '.prisma': 'prisma',
-}
-
-/** Path segments that indicate file role */
-const PATH_ROLE_MAP: Record<string, string> = {
-  'test': 'testing', 'tests': 'testing', '__tests__': 'testing', 'spec': 'testing',
-  'src': 'source', 'lib': 'library', 'utils': 'utility', 'helpers': 'utility',
-  'components': 'component', 'pages': 'page', 'routes': 'routing',
-  'api': 'api', 'server': 'server', 'client': 'client',
-  'config': 'configuration', 'scripts': 'scripting',
-  'hooks': 'hooks', 'middleware': 'middleware', 'types': 'types',
-}
-
-/** Fix 1: Key API/framework patterns to detect in file content */
-const KEY_API_PATTERNS: [RegExp, string][] = [
-  [/Bun\.serve\b/, 'Bun.serve'],
-  [/express\s*\(\)/, 'Express'],
-  [/new\s+Hono\b/, 'Hono'],
-  [/createServer\b/, 'HTTP server'],
-  [/WebSocket\b/i, 'WebSocket'],
-  [/app\.(?:get|post|put|delete|patch|use)\s*\(/, 'REST routes'],
-  [/useEffect|useState|useRef/, 'React hooks'],
-  [/createContext|useContext/, 'React context'],
-  [/prisma\.\w+/, 'Prisma ORM'],
-  [/mongoose\.\w+/, 'Mongoose'],
-  [/\.query\s*\(|\.execute\s*\(/, 'database queries'],
-  [/jwt\.|jsonwebtoken/, 'JWT auth'],
-  [/bcrypt|argon2|scrypt/, 'password hashing'],
-  [/rate.?limit/i, 'rate limiting'],
-  [/(?:sanitize|escapeHtml|xss)\b/, 'input sanitization'],
-  [/cron|schedule/i, 'scheduled tasks'],
-  [/createReadStream|\.pipe\s*\(/, 'streaming'],
-]
-
-export class PassiveClassifier {
-  /** Fix 5: LRU set of recent content hashes for deduplication */
-  private recentHashes = new Set<string>()
-  private readonly maxRecent = 50
-
-  /**
-   * Classify a hook event and extract knowledge if found.
-   * Returns null if no knowledge worth capturing.
-   */
-  classify(input: HookInput): CapturedKnowledge | null {
-    const toolName = input.tool_name?.toLowerCase()
-
-    // Fix 6: Handle Stop events (no tool_name)
-    if (!toolName) {
-      if (input.hook_event_name === 'Stop') {
-        return this.dedup(this.classifySessionEnd(input))
-      }
-      return null
-    }
-
-    let result: CapturedKnowledge | null = null
-
-    switch (toolName) {
-      case 'edit':
-      case 'write':
-        result = this.classifyFileEdit(input)
-        break
-      case 'bash':
-        result = this.classifyBashCommand(input)
-        break
-      default:
-        // Read, Glob, Grep — skip (read-only, low signal)
-        return null
-    }
-
-    // Fix 5: Pre-storage deduplication
-    return this.dedup(result)
-  }
-
-  /** Fix 5: Check and filter duplicates via LRU hash */
-  private dedup(result: CapturedKnowledge | null): CapturedKnowledge | null {
-    if (result && this.isDuplicate(result.content)) {
-      return null
-    }
-    return result
-  }
-
-  private classifyFileEdit(input: HookInput): CapturedKnowledge | null {
-    const toolInput = input.tool_input
-    if (!toolInput) return null
-
-    const filePath = (toolInput.file_path || toolInput.path || '') as string
-    if (!filePath) return null
-
-    const technologies = this.extractTechFromPath(filePath)
-    const role = this.extractRoleFromPath(filePath)
-
-    // Check if the edit content contains decision language
-    const content = toolInput.new_string || toolInput.content || ''
-    const responseText = this.extractResponseText(input.tool_response)
-
-    // 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(),
-          }
-        }
-      }
-
-      // Fix 1: Smart content summarization instead of generic "Created file: path"
-      if (typeof content === 'string' && content.length > 100) {
-        const summary = this.summarizeFileContent(content, filePath)
-        return {
-          type: 'pattern',
-          confidence: 0.75,
-          content: summary,
-          project: this.extractProjectFromCwd(input.cwd),
-          technologies,
-          metadata: { filePath, role, action: 'create' },
-          source: 'hook-passive',
-          timestamp: new Date().toISOString(),
-        }
-      }
-
-      // Short files still get the basic pattern
-      return {
-        type: 'pattern',
-        confidence: 0.7,
-        content: `Created ${role ? role + ' ' : ''}file: ${this.shortenPath(filePath)}${technologies.length ? ` (${technologies.join(', ')})` : ''}`,
-        project: this.extractProjectFromCwd(input.cwd),
-        technologies,
-        metadata: { filePath, role, action: 'create' },
-        source: 'hook-passive',
-        timestamp: new Date().toISOString(),
-      }
-    }
-
-    // For edits, check for decision language in content
-    if (typeof content === 'string' && content.length > 50) {
-      const decisionInContent = this.detectDecisionLanguage(content)
-      if (decisionInContent) {
-        return {
-          type: 'decision',
-          confidence: 0.75,
-          content: decisionInContent,
-          project: this.extractProjectFromCwd(input.cwd),
-          technologies,
-          metadata: { filePath, role, action: 'edit' },
-          source: 'hook-passive',
-          timestamp: new Date().toISOString(),
-        }
-      }
-    }
-
-    // Check tool response for decision language
-    if (responseText) {
-      const decisionInResponse = this.detectDecisionLanguage(responseText)
-      if (decisionInResponse) {
-        return {
-          type: 'decision',
-          confidence: 0.7,
-          content: decisionInResponse,
-          project: this.extractProjectFromCwd(input.cwd),
-          technologies,
-          metadata: { filePath, role, action: 'edit' },
-          source: 'hook-passive',
-          timestamp: new Date().toISOString(),
-        }
-      }
-    }
-
-    // Fix 2: Capture meaningful edits even without decision language
-    const oldStr = (toolInput.old_string || '') as string
-    const newStr = (toolInput.new_string || '') as string
-    if (oldStr && newStr && oldStr.trim() !== newStr.trim()) {
-      const combinedLen = oldStr.length + newStr.length
-      if (combinedLen > 60) {
-        const oldPreview = oldStr.trim().slice(0, 60)
-        const newPreview = newStr.trim().slice(0, 60)
-        return {
-          type: 'pattern',
-          confidence: 0.7,
-          content: `Edited ${this.shortenPath(filePath)}: "${oldPreview}${oldStr.trim().length > 60 ? '...' : ''}" \u2192 "${newPreview}${newStr.trim().length > 60 ? '...' : ''}"`,
-          project: this.extractProjectFromCwd(input.cwd),
-          technologies,
-          metadata: { filePath, role, action: 'edit' },
-          source: 'hook-passive',
-          timestamp: new Date().toISOString(),
-        }
-      }
-    }
-
-    return null
-  }
-
-  private classifyBashCommand(input: HookInput): CapturedKnowledge | 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
-
-    // If all sub-commands are skip-worthy, bail
-    const firstWord = command.trim().split(/\s+/)[0]?.toLowerCase()
-    if (firstWord && SKIP_COMMANDS.has(firstWord)) return null
-
-    // Package installs
-    for (const pattern of INSTALL_PATTERNS) {
-      const match = command.match(pattern)
-      if (match) {
-        const packages = match[1]?.trim()
-        if (packages) {
-          return {
-            type: 'decision',
-            confidence: 0.85,
-            content: `Installed package(s): ${packages}`,
-            project: this.extractProjectFromCwd(input.cwd),
-            technologies: this.extractTechFromPackages(packages),
-            metadata: { command: rawCommand, action: 'install' },
-            source: 'hook-passive',
-            timestamp: new Date().toISOString(),
-          }
-        }
-      }
-    }
-
-    // Git operations
-    for (const pattern of GIT_PATTERNS) {
-      const match = command.match(pattern)
-      if (match) {
-        return {
-          type: 'progress',
-          confidence: 0.8,
-          content: `Git: ${command.trim().slice(0, 200)}`,
-          project: this.extractProjectFromCwd(input.cwd),
-          technologies: ['git'],
-          metadata: { command: rawCommand, action: 'git' },
-          source: 'hook-passive',
-          timestamp: new Date().toISOString(),
-        }
-      }
-    }
-
-    // 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(buildCommand)) {
-        const responseText = this.extractResponseText(input.tool_response)
-        const failed = responseText?.toLowerCase().includes('fail') ||
-                       responseText?.toLowerCase().includes('error')
-
-        if (failed) {
-          return {
-            type: 'correction',
-            confidence: 0.75,
-            content: `Build/test failure: ${buildCommand.trim().slice(0, 100)}`,
-            project: this.extractProjectFromCwd(input.cwd),
-            technologies: [],
-            metadata: { command: rawCommand, action: 'build', failed: true },
-            source: 'hook-passive',
-            timestamp: new Date().toISOString(),
-          }
-        }
-
-        return {
-          type: 'progress',
-          confidence: 0.7,
-          content: `Ran: ${buildCommand.trim().slice(0, 200)}`,
-          project: this.extractProjectFromCwd(input.cwd),
-          technologies: [],
-          metadata: { command: rawCommand, action: 'build', failed: false },
-          source: 'hook-passive',
-          timestamp: new Date().toISOString(),
-        }
-      }
-    }
-
-    // Fix 3: Server start patterns
-    for (const pattern of SERVER_PATTERNS) {
-      if (pattern.test(command)) {
-        return {
-          type: 'progress',
-          confidence: 0.7,
-          content: `Started server: ${command.trim().slice(0, 200)}`,
-          project: this.extractProjectFromCwd(input.cwd),
-          technologies: [],
-          metadata: { command: rawCommand, action: 'server' },
-          source: 'hook-passive',
-          timestamp: new Date().toISOString(),
-        }
-      }
-    }
-
-    // Fix 3: Process management patterns
-    for (const pattern of PROCESS_PATTERNS) {
-      if (pattern.test(command)) {
-        return {
-          type: 'pattern',
-          confidence: 0.7,
-          content: `Process management: ${command.trim().slice(0, 200)}`,
-          project: this.extractProjectFromCwd(input.cwd),
-          technologies: [],
-          metadata: { command: rawCommand, action: 'process' },
-          source: 'hook-passive',
-          timestamp: new Date().toISOString(),
-        }
-      }
-    }
-
-    // Fix 3: Docker patterns
-    for (const pattern of DOCKER_PATTERNS) {
-      if (pattern.test(command)) {
-        return {
-          type: 'progress',
-          confidence: 0.75,
-          content: `Docker: ${command.trim().slice(0, 200)}`,
-          project: this.extractProjectFromCwd(input.cwd),
-          technologies: ['docker'],
-          metadata: { command: rawCommand, action: 'docker' },
-          source: 'hook-passive',
-          timestamp: new Date().toISOString(),
-        }
-      }
-    }
-
-    // Check response text for decision/correction language
-    const responseText = this.extractResponseText(input.tool_response)
-    if (responseText) {
-      const correction = this.detectCorrectionLanguage(responseText)
-      if (correction) {
-        return {
-          type: 'correction',
-          confidence: 0.7,
-          content: correction,
-          project: this.extractProjectFromCwd(input.cwd),
-          technologies: [],
-          metadata: { command: rawCommand, action: 'bash' },
-          source: 'hook-passive',
-          timestamp: new Date().toISOString(),
-        }
-      }
-    }
-
-    return null
-  }
-
-  // --- Fix 6: Stop event handler ---
-
-  private classifySessionEnd(input: HookInput): CapturedKnowledge | null {
-    const responseText = this.extractResponseText(input.tool_response)
-    if (!responseText || responseText.length < 20) return null
-
-    return {
-      type: 'progress',
-      confidence: 0.75,
-      content: `Session summary: ${responseText.slice(0, 300)}`,
-      project: this.extractProjectFromCwd(input.cwd),
-      technologies: [],
-      metadata: { action: 'session-end' },
-      source: 'hook-passive',
-      timestamp: new Date().toISOString(),
-    }
-  }
-
-  // --- Fix 1: Smart content summarization ---
-
-  /** Extract meaningful summary from file content using fast regex/string parsing */
-  private summarizeFileContent(content: string, filePath: string): string {
-    const basename = filePath.split(/[/\\]/).pop() || filePath
-    const parts: string[] = []
-
-    // Detect file purpose from structure
-    const purpose = this.detectFilePurpose(content, filePath)
-    if (purpose) parts.push(purpose)
-
-    // Extract external imports/dependencies
-    const imports = this.extractImportNames(content)
-    if (imports.length > 0) parts.push(`uses ${imports.slice(0, 5).join(', ')}`)
-
-    // Extract exported names
-    const exports = this.extractExportNames(content)
-    if (exports.length > 0) parts.push(`exports ${exports.slice(0, 5).join(', ')}`)
-
-    // Extract key framework/API patterns
-    const patterns = this.extractKeyPatterns(content)
-    if (patterns.length > 0) parts.push(patterns.join(', '))
-
-    if (parts.length === 0) {
-      const role = this.extractRoleFromPath(filePath)
-      const techs = this.extractTechFromPath(filePath)
-      return `Created ${role ? role + ' ' : ''}file: ${this.shortenPath(filePath)}${techs.length ? ` (${techs.join(', ')})` : ''}`
-    }
-
-    return `Created ${basename}: ${parts.join(' \u2014 ')}`.slice(0, 300)
-  }
-
-  /** Detect file purpose from content patterns and path */
-  private detectFilePurpose(content: string, filePath: string): string | null {
-    const path = filePath.toLowerCase()
-
-    if (path.includes('test') || path.includes('spec') || /\b(?:describe|it|test)\s*\(/.test(content)) {
-      return 'test file'
-    }
-    if (/\b(?:createServer|Bun\.serve|express\s*\(\)|app\.listen|new\s+Hono|Fastify)\b/.test(content)) {
-      return 'server'
-    }
-    if (/\breturn\s*\(?\s*</.test(content) && /(?:function|const)\s+[A-Z]\w*/.test(content)) {
-      return 'React component'
-    }
-    if (/\b(?:eslint|prettier|jest|vite|webpack|tsconfig|babel)\b/i.test(path)) {
-      return 'configuration'
-    }
-    if (/\b(?:middleware)\b/i.test(path) || /\b(?:req\s*,\s*res\s*,\s*next)\b/.test(content)) {
-      return 'middleware'
-    }
-    if (/\b(?:interface|type)\s+[A-Z]\w+/.test(content) && !/\bfunction\b/.test(content)) {
-      return 'type definitions'
-    }
-    if (/(?:#!\/usr\/bin|process\.argv|yargs|commander)/.test(content)) {
-      return 'CLI script'
-    }
-
-    return null
-  }
-
-  /** Extract external package names from import/require statements */
-  private extractImportNames(content: string): string[] {
-    const names: string[] = []
-
-    // ES imports: from 'package'
-    const esImports = content.matchAll(/from\s+['"]([^'"./][^'"]*)['"]/g)
-    for (const match of esImports) {
-      const pkg = match[1].split('/')[0]
-      if (pkg && !names.includes(pkg)) names.push(pkg)
-    }
-
-    // require('package')
-    const requires = content.matchAll(/require\s*\(\s*['"]([^'"./][^'"]*)['"]\s*\)/g)
-    for (const match of requires) {
-      const pkg = match[1].split('/')[0]
-      if (pkg && !names.includes(pkg)) names.push(pkg)
-    }
-
-    // Python imports
-    const pyImports = content.matchAll(/^\s*(?:from|import)\s+(\w+)/gm)
-    for (const match of pyImports) {
-      if (match[1] && !names.includes(match[1]) && match[1] !== 'from' && match[1] !== 'import') {
-        names.push(match[1])
-      }
-    }
-
-    return names.slice(0, 8)
-  }
-
-  /** Extract exported function/class/const names */
-  private extractExportNames(content: string): string[] {
-    const names: string[] = []
-    const exportMatches = content.matchAll(/export\s+(?:default\s+)?(?:function|class|const|let|var|interface|type|enum)\s+(\w+)/g)
-    for (const match of exportMatches) {
-      if (match[1] && !names.includes(match[1])) names.push(match[1])
-    }
-    return names.slice(0, 8)
-  }
-
-  /** Detect key API/framework patterns in content */
-  private extractKeyPatterns(content: string): string[] {
-    const found: string[] = []
-    for (const [regex, label] of KEY_API_PATTERNS) {
-      if (regex.test(content)) found.push(label)
-      if (found.length >= 4) break
-    }
-    return found
-  }
-
-  // --- Fix 5: Pre-storage deduplication ---
-
-  /** Check if content was recently seen (LRU hash set) */
-  private isDuplicate(content: string): boolean {
-    const hash = this.simpleHash(content)
-    if (this.recentHashes.has(hash)) return true
-    this.recentHashes.add(hash)
-    if (this.recentHashes.size > this.maxRecent) {
-      const first = this.recentHashes.values().next().value
-      if (first !== undefined) this.recentHashes.delete(first)
-    }
-    return false
-  }
-
-  /** Fast 32-bit string hash */
-  private simpleHash(str: string): string {
-    let hash = 0
-    for (let i = 0; i < str.length; i++) {
-      const char = str.charCodeAt(i)
-      hash = ((hash << 5) - hash) + char
-      hash |= 0
-    }
-    return hash.toString(36)
-  }
-
-  // --- Existing helpers ---
-
-  /** Extract technology names from file path based on extension */
-  private extractTechFromPath(filePath: string): string[] {
-    const techs: string[] = []
-    const ext = filePath.match(/\.[a-z]+$/i)?.[0]?.toLowerCase()
-    if (ext && EXT_TO_TECH[ext]) {
-      techs.push(EXT_TO_TECH[ext])
-    }
-
-    // Check for Dockerfile without extension
-    const basename = filePath.split('/').pop()?.toLowerCase() || ''
-    if (basename === 'dockerfile' || basename.startsWith('dockerfile.')) {
-      techs.push('docker')
-    }
-    if (basename === 'docker-compose.yml' || basename === 'docker-compose.yaml') {
-      techs.push('docker')
-    }
-
-    return techs
-  }
-
-  /** Extract file role from path segments */
-  private extractRoleFromPath(filePath: string): string | undefined {
-    const segments = filePath.toLowerCase().split(/[/\\]/)
-    for (const segment of segments) {
-      if (PATH_ROLE_MAP[segment]) return PATH_ROLE_MAP[segment]
-    }
-    return undefined
-  }
-
-  /** Extract technology names from package install strings */
-  private extractTechFromPackages(packages: string): string[] {
-    return packages
-      .split(/\s+/)
-      .filter(p => !p.startsWith('-') && p.length > 1)
-      .map(p => p.replace(/@[^/]+$/, '')) // strip version
-      .slice(0, 10) // limit
-  }
-
-  /** Detect decision language in text, return the relevant sentence */
-  private detectDecisionLanguage(text: string): string | null {
-    const lower = text.toLowerCase()
-    for (const phrase of DECISION_PHRASES) {
-      const idx = lower.indexOf(phrase)
-      if (idx !== -1) {
-        // Extract surrounding context (up to 300 chars)
-        const start = Math.max(0, text.lastIndexOf('\n', idx) + 1)
-        const end = Math.min(text.length, text.indexOf('\n', idx + phrase.length))
-        const sentence = text.slice(start, end === -1 ? Math.min(idx + 300, text.length) : end).trim()
-        if (sentence.length > 10) return sentence
-      }
-    }
-    return null
-  }
-
-  /** Detect correction/lesson language in text */
-  private detectCorrectionLanguage(text: string): string | null {
-    const lower = text.toLowerCase()
-    for (const phrase of CORRECTION_PHRASES) {
-      const idx = lower.indexOf(phrase)
-      if (idx !== -1) {
-        const start = Math.max(0, text.lastIndexOf('\n', idx) + 1)
-        const end = Math.min(text.length, text.indexOf('\n', idx + phrase.length))
-        const sentence = text.slice(start, end === -1 ? Math.min(idx + 300, text.length) : end).trim()
-        if (sentence.length > 10) return sentence
-      }
-    }
-    return null
-  }
-
-  /** Extract project name from cwd (last directory segment) */
-  private extractProjectFromCwd(cwd: string): string | undefined {
-    if (!cwd) return undefined
-    // 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()
-    }
-    return undefined
-  }
-
-  /** Shorten a file path for display */
-  private shortenPath(filePath: string): string {
-    const parts = filePath.split(/[/\\]/)
-    if (parts.length <= 3) return filePath
-    return `.../${parts.slice(-3).join('/')}`
-  }
-
-  /** Extract text content from tool_response */
-  private extractResponseText(response: HookInput['tool_response']): string | null {
-    if (!response) return null
-
-    if (typeof response.content === 'string') {
-      return response.content.slice(0, 2000)
-    }
-
-    if (Array.isArray(response.content)) {
-      const texts = response.content
-        .filter(block => block.type === 'text' && block.text)
-        .map(block => block.text!)
-      return texts.join('\n').slice(0, 2000) || null
-    }
-
-    return null
-  }
-}
+/**
+ * Phase 17: Passive Classifier
+ * Extracts knowledge from tool outputs using lightweight pattern matching.
+ * No embeddings needed — runs fast enough for hook context (<200ms).
+ */
+
+import type { HookInput, CapturedKnowledge } from './types'
+
+/** Phrases that indicate a decision was made */
+const DECISION_PHRASES = [
+  'i recommend', 'you should use', 'the best approach', 'i suggest',
+  'better to use', 'prefer using', 'go with', 'choose', 'instead of',
+  'the right choice', 'decided to', "let's use", 'we will use',
+  'the solution is', 'implement using', 'going with', 'switching to',
+  'adopting', 'we chose', 'the plan is to'
+]
+
+/** Phrases indicating a correction or lesson */
+const CORRECTION_PHRASES = [
+  'the bug was', 'the issue was', 'the problem was', 'mistake was',
+  'should have', 'should not have', "shouldn't have",
+  'lesson learned', "don't use", 'avoid using', 'never use',
+  'the fix is', 'the fix was', 'fixed by', 'solved by'
+]
+
+/** Package install patterns for bash commands */
+const INSTALL_PATTERNS = [
+  /(?:npm|yarn|pnpm|bun)\s+(?:install|add|i)\s+(.+)/i,
+  /pip\s+install\s+(.+)/i,
+  /cargo\s+add\s+(.+)/i,
+  /go\s+get\s+(.+)/i,
+  /gem\s+install\s+(.+)/i,
+]
+
+/** Git operation patterns */
+const GIT_PATTERNS = [
+  /git\s+commit\s+.*-m\s+["'](.+?)["']/i,
+  /git\s+merge\s+(\S+)/i,
+  /git\s+checkout\s+-b\s+(\S+)/i,
+  /git\s+branch\s+(\S+)/i,
+]
+
+/** Test/build command patterns */
+const BUILD_PATTERNS = [
+  /(?:npm|yarn|pnpm|bun)\s+(?:run\s+)?(?:test|build|lint|typecheck|check)/i,
+  /(?:jest|vitest|pytest|cargo\s+test|go\s+test)/i,
+]
+
+/** Bash commands to skip (low signal) */
+const SKIP_COMMANDS = new Set([
+  'cd', 'ls', 'cat', 'head', 'tail', 'pwd', 'echo', 'clear', 'which', 'whoami',
+  'date', 'env', 'printenv', 'export', 'source', 'alias', 'history',
+])
+
+/** File extension to technology mapping */
+const EXT_TO_TECH: Record<string, string> = {
+  '.ts': 'typescript', '.tsx': 'typescript', '.js': 'javascript', '.jsx': 'javascript',
+  '.py': 'python', '.rs': 'rust', '.go': 'go', '.java': 'java',
+  '.rb': 'ruby', '.php': 'php', '.swift': 'swift', '.kt': 'kotlin',
+  '.vue': 'vue', '.svelte': 'svelte', '.astro': 'astro',
+  '.css': 'css', '.scss': 'sass', '.less': 'less',
+  '.sql': 'sql', '.graphql': 'graphql', '.gql': 'graphql',
+  '.yml': 'yaml', '.yaml': 'yaml', '.toml': 'toml',
+  '.dockerfile': 'docker', '.prisma': 'prisma',
+}
+
+/** Path segments that indicate file role */
+const PATH_ROLE_MAP: Record<string, string> = {
+  'test': 'testing', 'tests': 'testing', '__tests__': 'testing', 'spec': 'testing',
+  'src': 'source', 'lib': 'library', 'utils': 'utility', 'helpers': 'utility',
+  'components': 'component', 'pages': 'page', 'routes': 'routing',
+  'api': 'api', 'server': 'server', 'client': 'client',
+  'config': 'configuration', 'scripts': 'scripting',
+  'hooks': 'hooks', 'middleware': 'middleware', 'types': 'types',
+}
+
+export class PassiveClassifier {
+  /**
+   * Classify a hook event and extract knowledge if found.
+   * Returns null if no knowledge worth capturing.
+   */
+  classify(input: HookInput): CapturedKnowledge | null {
+    const toolName = input.tool_name?.toLowerCase()
+    if (!toolName) return null
+
+    switch (toolName) {
+      case 'edit':
+      case 'write':
+        return this.classifyFileEdit(input)
+      case 'bash':
+        return this.classifyBashCommand(input)
+      default:
+        // Read, Glob, Grep — skip (read-only, low signal)
+        return null
+    }
+  }
+
+  private classifyFileEdit(input: HookInput): CapturedKnowledge | null {
+    const toolInput = input.tool_input
+    if (!toolInput) return null
+
+    const filePath = (toolInput.file_path || toolInput.path || '') as string
+    if (!filePath) return null
+
+    const technologies = this.extractTechFromPath(filePath)
+    const role = this.extractRoleFromPath(filePath)
+
+    // Check if the edit content contains decision language
+    const content = toolInput.new_string || toolInput.content || ''
+    const responseText = this.extractResponseText(input.tool_response)
+
+    // For Write tool: only capture if content contains decision or correction language
+    // Plain file creations ("Created file: X") are noise — zero recall value
+    if (input.tool_name?.toLowerCase() === 'write') {
+      const writeContent = typeof content === 'string' ? content : ''
+      const writeResponse = responseText || ''
+      const combined = writeContent + ' ' + writeResponse
+
+      // Check for decision language in file content or response
+      const decisionInWrite = this.detectDecisionLanguage(combined)
+      if (decisionInWrite) {
+        return {
+          type: 'decision',
+          confidence: 0.75,
+          content: decisionInWrite,
+          project: this.extractProjectFromCwd(input.cwd),
+          technologies,
+          metadata: { filePath, role, action: 'create' },
+          source: 'hook-passive',
+          timestamp: new Date().toISOString(),
+        }
+      }
+
+      // Check for correction language
+      const correctionInWrite = this.detectCorrectionLanguage(combined)
+      if (correctionInWrite) {
+        return {
+          type: 'correction',
+          confidence: 0.75,
+          content: correctionInWrite,
+          project: this.extractProjectFromCwd(input.cwd),
+          technologies,
+          metadata: { filePath, role, action: 'create' },
+          source: 'hook-passive',
+          timestamp: new Date().toISOString(),
+        }
+      }
+
+      // No decision or correction language found — skip this file creation
+      return null
+    }
+
+    // For edits, only capture if they look significant
+    if (typeof content === 'string' && content.length > 50) {
+      const decisionInContent = this.detectDecisionLanguage(content)
+      if (decisionInContent) {
+        return {
+          type: 'decision',
+          confidence: 0.75,
+          content: decisionInContent,
+          project: this.extractProjectFromCwd(input.cwd),
+          technologies,
+          metadata: { filePath, role, action: 'edit' },
+          source: 'hook-passive',
+          timestamp: new Date().toISOString(),
+        }
+      }
+    }
+
+    // Check tool response for decision language
+    if (responseText) {
+      const decisionInResponse = this.detectDecisionLanguage(responseText)
+      if (decisionInResponse) {
+        return {
+          type: 'decision',
+          confidence: 0.7,
+          content: decisionInResponse,
+          project: this.extractProjectFromCwd(input.cwd),
+          technologies,
+          metadata: { filePath, role, action: 'edit' },
+          source: 'hook-passive',
+          timestamp: new Date().toISOString(),
+        }
+      }
+    }
+
+    return null
+  }
+
+  private classifyBashCommand(input: HookInput): CapturedKnowledge | 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
+
+    // If all sub-commands are skip-worthy, bail
+    const firstWord = command.trim().split(/\s+/)[0]?.toLowerCase()
+    if (firstWord && SKIP_COMMANDS.has(firstWord)) return null
+
+    // Package installs
+    for (const pattern of INSTALL_PATTERNS) {
+      const match = command.match(pattern)
+      if (match) {
+        const packages = match[1]?.trim()
+        if (packages) {
+          return {
+            type: 'decision',
+            confidence: 0.85,
+            content: `Installed package(s): ${packages}`,
+            project: this.extractProjectFromCwd(input.cwd),
+            technologies: this.extractTechFromPackages(packages),
+            metadata: { command: rawCommand, action: 'install' },
+            source: 'hook-passive',
+            timestamp: new Date().toISOString(),
+          }
+        }
+      }
+    }
+
+    // Git operations
+    for (const pattern of GIT_PATTERNS) {
+      const match = command.match(pattern)
+      if (match) {
+        return {
+          type: 'progress',
+          confidence: 0.8,
+          content: `Git: ${command.trim().slice(0, 200)}`,
+          project: this.extractProjectFromCwd(input.cwd),
+          technologies: ['git'],
+          metadata: { command: rawCommand, action: 'git' },
+          source: 'hook-passive',
+          timestamp: new Date().toISOString(),
+        }
+      }
+    }
+
+    // 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(buildCommand)) {
+        const responseText = this.extractResponseText(input.tool_response)
+        const failed = responseText?.toLowerCase().includes('fail') ||
+                       responseText?.toLowerCase().includes('error')
+
+        if (failed) {
+          return {
+            type: 'correction',
+            confidence: 0.75,
+            content: `Build/test failure: ${buildCommand.trim().slice(0, 100)}`,
+            project: this.extractProjectFromCwd(input.cwd),
+            technologies: [],
+            metadata: { command: rawCommand, action: 'build', failed: true },
+            source: 'hook-passive',
+            timestamp: new Date().toISOString(),
+          }
+        }
+
+        return {
+          type: 'progress',
+          confidence: 0.7,
+          content: `Ran: ${buildCommand.trim().slice(0, 200)}`,
+          project: this.extractProjectFromCwd(input.cwd),
+          technologies: [],
+          metadata: { command: rawCommand, action: 'build', failed: false },
+          source: 'hook-passive',
+          timestamp: new Date().toISOString(),
+        }
+      }
+    }
+
+    // Check response text for decision/correction language
+    const responseText = this.extractResponseText(input.tool_response)
+    if (responseText) {
+      const correction = this.detectCorrectionLanguage(responseText)
+      if (correction) {
+        return {
+          type: 'correction',
+          confidence: 0.7,
+          content: correction,
+          project: this.extractProjectFromCwd(input.cwd),
+          technologies: [],
+          metadata: { command: rawCommand, action: 'bash' },
+          source: 'hook-passive',
+          timestamp: new Date().toISOString(),
+        }
+      }
+    }
+
+    return null
+  }
+
+  /** Extract technology names from file path based on extension */
+  private extractTechFromPath(filePath: string): string[] {
+    const techs: string[] = []
+    const ext = filePath.match(/\.[a-z]+$/i)?.[0]?.toLowerCase()
+    if (ext && EXT_TO_TECH[ext]) {
+      techs.push(EXT_TO_TECH[ext])
+    }
+
+    // Check for Dockerfile without extension
+    const basename = filePath.split('/').pop()?.toLowerCase() || ''
+    if (basename === 'dockerfile' || basename.startsWith('dockerfile.')) {
+      techs.push('docker')
+    }
+    if (basename === 'docker-compose.yml' || basename === 'docker-compose.yaml') {
+      techs.push('docker')
+    }
+
+    return techs
+  }
+
+  /** Extract file role from path segments */
+  private extractRoleFromPath(filePath: string): string | undefined {
+    const segments = filePath.toLowerCase().split(/[/\\]/)
+    for (const segment of segments) {
+      if (PATH_ROLE_MAP[segment]) return PATH_ROLE_MAP[segment]
+    }
+    return undefined
+  }
+
+  /** Extract technology names from package install strings */
+  private extractTechFromPackages(packages: string): string[] {
+    return packages
+      .split(/\s+/)
+      .filter(p => !p.startsWith('-') && p.length > 1)
+      .map(p => p.replace(/@[^/]+$/, '')) // strip version
+      .slice(0, 10) // limit
+  }
+
+  /** Detect decision language in text, return the relevant sentence */
+  private detectDecisionLanguage(text: string): string | null {
+    const lower = text.toLowerCase()
+    for (const phrase of DECISION_PHRASES) {
+      const idx = lower.indexOf(phrase)
+      if (idx !== -1) {
+        // Extract surrounding context (up to 300 chars)
+        const start = Math.max(0, text.lastIndexOf('\n', idx) + 1)
+        const end = Math.min(text.length, text.indexOf('\n', idx + phrase.length))
+        const sentence = text.slice(start, end === -1 ? Math.min(idx + 300, text.length) : end).trim()
+        if (sentence.length > 10) return sentence
+      }
+    }
+    return null
+  }
+
+  /** Detect correction/lesson language in text */
+  private detectCorrectionLanguage(text: string): string | null {
+    const lower = text.toLowerCase()
+    for (const phrase of CORRECTION_PHRASES) {
+      const idx = lower.indexOf(phrase)
+      if (idx !== -1) {
+        const start = Math.max(0, text.lastIndexOf('\n', idx) + 1)
+        const end = Math.min(text.length, text.indexOf('\n', idx + phrase.length))
+        const sentence = text.slice(start, end === -1 ? Math.min(idx + 300, text.length) : end).trim()
+        if (sentence.length > 10) return sentence
+      }
+    }
+    return null
+  }
+
+  /** Extract project name from cwd (last directory segment) */
+  private extractProjectFromCwd(cwd: string): string | undefined {
+    if (!cwd) return undefined
+    // 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()
+    }
+    return undefined
+  }
+
+  /** Shorten a file path for display */
+  private shortenPath(filePath: string): string {
+    const parts = filePath.split(/[/\\]/)
+    if (parts.length <= 3) return filePath
+    return `.../${parts.slice(-3).join('/')}`
+  }
+
+  /** Extract text content from tool_response */
+  private extractResponseText(response: HookInput['tool_response']): string | null {
+    if (!response) return null
+
+    if (typeof response.content === 'string') {
+      return response.content.slice(0, 2000)
+    }
+
+    if (Array.isArray(response.content)) {
+      const texts = response.content
+        .filter(block => block.type === 'text' && block.text)
+        .map(block => block.text!)
+      return texts.join('\n').slice(0, 2000) || null
+    }
+
+    return null
+  }
+}