claude-brain 0.5.0 → 0.8.0

package/src/hooks/capture.ts

@@ -0,0 +1,161 @@
+/**
+ * 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',
+}
+
+export class BrainCapture {
+  private classifier: PassiveClassifier
+  private config: HooksConfig
+
+  constructor(config?: Partial<HooksConfig>) {
+    this.config = {
+      enabled: config?.enabled ?? false,
+      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 ?? [],
+        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)
+  }
+}

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
+  }
+}