claude-brain 0.5.1 → 0.9.0

package/src/hooks/deduplicator.ts

@@ -0,0 +1,72 @@
+/**
+ * Phase 17: Smart Deduplicator
+ * Three-tier dedup before storage:
+ *   >0.95 similarity → skip (exact duplicate)
+ *   0.85–0.95 similarity → merge (update existing)
+ *   <0.85 similarity → store_new
+ */
+
+import type { MemoryManager } from '@/memory'
+import type { CapturedKnowledge, StoreAction } from './types'
+import type { HooksConfig } from '@/config/schema'
+
+export class SmartDeduplicator {
+  private skipThreshold: number
+  private mergeThreshold: number
+
+  constructor(config?: HooksConfig['deduplication']) {
+    this.skipThreshold = config?.skipThreshold ?? 0.95
+    this.mergeThreshold = config?.mergeThreshold ?? 0.85
+  }
+
+  /**
+   * Check captured knowledge against existing memory
+   * and decide: store_new, merge, or skip
+   */
+  async beforeStore(
+    knowledge: CapturedKnowledge,
+    memoryManager: MemoryManager
+  ): Promise<StoreAction> {
+    try {
+      const results = await memoryManager.searchRaw(knowledge.content, {
+        project: knowledge.project,
+        limit: 3,
+        minSimilarity: this.mergeThreshold,
+      })
+
+      if (!results || results.length === 0) {
+        return { action: 'store_new' }
+      }
+
+      const topResult = results[0]
+      const similarity = topResult.similarity ?? 0
+
+      if (similarity >= this.skipThreshold) {
+        return {
+          action: 'skip',
+          reason: `Duplicate (similarity: ${similarity.toFixed(3)})`,
+        }
+      }
+
+      if (similarity >= this.mergeThreshold) {
+        const existingId = topResult.memory?.id || topResult.id
+        const existingContent = topResult.memory?.content ||
+          topResult.decision?.decision ||
+          ''
+        const datestamp = new Date().toISOString().split('T')[0]
+        const mergedContent = `${existingContent}\n[Updated ${datestamp}]: ${knowledge.content}`
+
+        return {
+          action: 'merge',
+          existingId,
+          mergedContent,
+        }
+      }
+
+      return { action: 'store_new' }
+    } catch {
+      // If search fails, store as new to avoid data loss
+      return { action: 'store_new' }
+    }
+  }
+}

package/src/hooks/index.ts

@@ -0,0 +1,19 @@
+/**
+ * Phase 17: Passive Learning via Hooks
+ * Module re-exports
+ */
+
+export type {
+  HookInput,
+  CapturedKnowledge,
+  KnowledgeType,
+  StoreAction,
+  HookStats,
+} from './types'
+
+export { PassiveClassifier } from './passive-classifier'
+export { BrainCapture } from './capture'
+export { SmartDeduplicator } from './deduplicator'
+export { HookSessionTracker } from './session-tracker'
+export { appendToQueue, readQueue, clearQueue, drainQueue, getQueuePath } from './queue'
+export { installHooks, uninstallHooks, isHooksInstalled, getHookScriptPath } from './installer'

package/src/hooks/installer.ts

@@ -0,0 +1,181 @@
+/**
+ * Phase 17: Hook Installer
+ * Manages installation/removal of Claude Code hooks in ~/.claude/settings.json.
+ */
+
+import { readFileSync, writeFileSync, existsSync, mkdirSync, renameSync } from 'node:fs'
+import { join, dirname } from 'node:path'
+import { homedir } from 'node:os'
+import { getClaudeBrainHome } from '@/config/home'
+
+const CLAUDE_SETTINGS_PATH = join(homedir(), '.claude', 'settings.json')
+const HOOK_MARKER = 'claude-brain-hook'
+
+/** Get the path where the hook script should be installed */
+export function getHookScriptPath(): string {
+  return join(getClaudeBrainHome(), 'hooks', 'brain-hook.ts')
+}
+
+/** Read Claude Code settings.json, creating if needed */
+function readSettings(): Record<string, any> {
+  if (!existsSync(CLAUDE_SETTINGS_PATH)) return {}
+  try {
+    return JSON.parse(readFileSync(CLAUDE_SETTINGS_PATH, 'utf-8'))
+  } catch {
+    return {}
+  }
+}
+
+/** Write settings.json atomically (write temp → rename) */
+function writeSettings(settings: Record<string, any>): void {
+  const dir = dirname(CLAUDE_SETTINGS_PATH)
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true })
+  }
+
+  const tmpPath = CLAUDE_SETTINGS_PATH + '.tmp'
+  writeFileSync(tmpPath, JSON.stringify(settings, null, 2) + '\n', 'utf-8')
+  renameSync(tmpPath, CLAUDE_SETTINGS_PATH)
+}
+
+/** Build the hook command string */
+function buildHookCommand(event: string): string {
+  const scriptPath = getHookScriptPath()
+  return `bun "${scriptPath}" --event ${event} # ${HOOK_MARKER}`
+}
+
+/**
+ * Install Claude Brain hooks into Claude Code settings.
+ * Adds PostToolUse and Stop hook entries.
+ */
+export function installHooks(): { installed: boolean; message: string } {
+  if (isHooksInstalled()) {
+    return { installed: true, message: 'Hooks already installed' }
+  }
+
+  const settings = readSettings()
+
+  // Ensure hooks object exists
+  if (!settings.hooks) settings.hooks = {}
+
+  // PostToolUse hook — runs on every tool completion
+  if (!settings.hooks.PostToolUse) settings.hooks.PostToolUse = []
+  settings.hooks.PostToolUse.push({
+    matcher: '',
+    hooks: [{
+      type: 'command',
+      command: buildHookCommand('PostToolUse'),
+    }],
+  })
+
+  // Stop hook — triggers session-end summary
+  if (!settings.hooks.Stop) settings.hooks.Stop = []
+  settings.hooks.Stop.push({
+    matcher: '',
+    hooks: [{
+      type: 'command',
+      command: buildHookCommand('Stop'),
+    }],
+  })
+
+  writeSettings(settings)
+
+  // Copy hook script to install location
+  copyHookScript()
+
+  return { installed: true, message: 'Hooks installed successfully' }
+}
+
+/**
+ * Remove Claude Brain hooks from Claude Code settings.
+ */
+export function uninstallHooks(): { uninstalled: boolean; message: string } {
+  if (!isHooksInstalled()) {
+    return { uninstalled: true, message: 'Hooks not installed' }
+  }
+
+  const settings = readSettings()
+
+  if (settings.hooks) {
+    // Remove our entries from PostToolUse
+    if (Array.isArray(settings.hooks.PostToolUse)) {
+      settings.hooks.PostToolUse = settings.hooks.PostToolUse.filter(
+        (entry: any) => !isOurHookEntry(entry)
+      )
+      if (settings.hooks.PostToolUse.length === 0) {
+        delete settings.hooks.PostToolUse
+      }
+    }
+
+    // Remove our entries from Stop
+    if (Array.isArray(settings.hooks.Stop)) {
+      settings.hooks.Stop = settings.hooks.Stop.filter(
+        (entry: any) => !isOurHookEntry(entry)
+      )
+      if (settings.hooks.Stop.length === 0) {
+        delete settings.hooks.Stop
+      }
+    }
+
+    // Clean up empty hooks object
+    if (Object.keys(settings.hooks).length === 0) {
+      delete settings.hooks
+    }
+  }
+
+  writeSettings(settings)
+
+  return { uninstalled: true, message: 'Hooks uninstalled successfully' }
+}
+
+/**
+ * Check if hooks are already installed.
+ */
+export function isHooksInstalled(): boolean {
+  const settings = readSettings()
+  if (!settings.hooks) return false
+
+  const hasPostToolUse = Array.isArray(settings.hooks.PostToolUse) &&
+    settings.hooks.PostToolUse.some((entry: any) => isOurHookEntry(entry))
+
+  const hasStop = Array.isArray(settings.hooks.Stop) &&
+    settings.hooks.Stop.some((entry: any) => isOurHookEntry(entry))
+
+  return hasPostToolUse || hasStop
+}
+
+/** Check if a hook entry belongs to us (by marker in command) */
+function isOurHookEntry(entry: any): boolean {
+  if (!entry || !Array.isArray(entry.hooks)) return false
+  return entry.hooks.some(
+    (h: any) => typeof h.command === 'string' && h.command.includes(HOOK_MARKER)
+  )
+}
+
+/** Copy the hook script to the install location */
+function copyHookScript(): void {
+  const destPath = getHookScriptPath()
+  const destDir = dirname(destPath)
+
+  if (!existsSync(destDir)) {
+    mkdirSync(destDir, { recursive: true })
+  }
+
+  // Find source script relative to this file
+  // In development: src/hooks/brain-hook.ts
+  // In production: dist/hooks/brain-hook.js
+  const srcPath = join(dirname(new URL(import.meta.url).pathname), 'brain-hook.ts')
+
+  if (existsSync(srcPath)) {
+    const content = readFileSync(srcPath, 'utf-8')
+    writeFileSync(destPath, content, 'utf-8')
+  } else {
+    // Try .js extension for compiled version
+    const jsSrcPath = srcPath.replace('.ts', '.js')
+    if (existsSync(jsSrcPath)) {
+      const content = readFileSync(jsSrcPath, 'utf-8')
+      writeFileSync(destPath, content, 'utf-8')
+    }
+    // If neither exists, the hook script will need to be installed separately
+  }
+}

package/src/hooks/passive-classifier.ts

@@ -0,0 +1,366 @@
+/**
+ * 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)
+
+    // Check for new file creation (Write tool)
+    if (input.tool_name?.toLowerCase() === 'write') {
+      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, 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 command = (input.tool_input?.command || '') as string
+    if (!command || command.length < 3) return null
+
+    // Skip low-signal commands
+    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, 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, action: 'git' },
+          source: 'hook-passive',
+          timestamp: new Date().toISOString(),
+        }
+      }
+    }
+
+    // Test/build runs
+    for (const pattern of BUILD_PATTERNS) {
+      if (pattern.test(command)) {
+        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: ${command.trim().slice(0, 100)}`,
+            project: this.extractProjectFromCwd(input.cwd),
+            technologies: [],
+            metadata: { command, action: 'build', failed: true },
+            source: 'hook-passive',
+            timestamp: new Date().toISOString(),
+          }
+        }
+
+        return {
+          type: 'progress',
+          confidence: 0.7,
+          content: `Ran: ${command.trim().slice(0, 200)}`,
+          project: this.extractProjectFromCwd(input.cwd),
+          technologies: [],
+          metadata: { command, 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, 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
+    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
+  }
+}