claude-brain 0.14.0 → 0.14.2

package/src/hooks/capture.ts

@@ -1,168 +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/**'
-]
-
-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)
-  }
-}
+/**
+ * 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)
+  }
+}

package/src/hooks/deduplicator.ts

@@ -1,72 +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' }
-    }
-  }
-}
+/**
+ * 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' }
+    }
+  }
+}