claude-brain 0.15.2 → 0.16.0

package/src/hooks/types.ts

@@ -1,47 +1,47 @@
-/**
- * Phase 17: Passive Learning via Hooks — Shared Types
- */
-
-/** Claude Code hook stdin JSON format */
-export interface HookInput {
-  session_id: string
-  hook_event_name: 'PostToolUse' | 'Stop' | 'PreToolUse' | 'GitCommit'
-  cwd: string
-  tool_name?: string
-  tool_input?: Record<string, any>
-  tool_response?: {
-    content?: string | Array<{ type: string; text?: string }>
-    [key: string]: any
-  }
-}
-
-/** Knowledge type classifications */
-export type KnowledgeType = 'decision' | 'pattern' | 'correction' | 'progress'
-
-/** A piece of knowledge captured from a hook event */
-export interface CapturedKnowledge {
-  type: KnowledgeType
-  confidence: number
-  content: string
-  project?: string
-  technologies: string[]
-  metadata: Record<string, any>
-  source: 'hook-passive'
-  timestamp: string
-}
-
-/** What to do with captured knowledge before storage */
-export type StoreAction =
-  | { action: 'store_new' }
-  | { action: 'merge'; existingId: string; mergedContent: string }
-  | { action: 'skip'; reason: string }
-
-/** Hook event stats for status reporting */
-export interface HookStats {
-  totalCaptured: number
-  totalSkipped: number
-  totalMerged: number
-  sessionsTracked: number
-  lastCaptureAt?: string
-  queueSize: number
-}
+/**
+ * Phase 17: Passive Learning via Hooks — Shared Types
+ */
+
+/** Claude Code hook stdin JSON format */
+export interface HookInput {
+  session_id: string
+  hook_event_name: 'PostToolUse' | 'Stop' | 'PreToolUse' | 'GitCommit'
+  cwd: string
+  tool_name?: string
+  tool_input?: Record<string, any>
+  tool_response?: {
+    content?: string | Array<{ type: string; text?: string }>
+    [key: string]: any
+  }
+}
+
+/** Knowledge type classifications */
+export type KnowledgeType = 'decision' | 'pattern' | 'correction' | 'progress'
+
+/** A piece of knowledge captured from a hook event */
+export interface CapturedKnowledge {
+  type: KnowledgeType
+  confidence: number
+  content: string
+  project?: string
+  technologies: string[]
+  metadata: Record<string, any>
+  source: 'hook-passive'
+  timestamp: string
+}
+
+/** What to do with captured knowledge before storage */
+export type StoreAction =
+  | { action: 'store_new' }
+  | { action: 'merge'; existingId: string; mergedContent: string }
+  | { action: 'skip'; reason: string }
+
+/** Hook event stats for status reporting */
+export interface HookStats {
+  totalCaptured: number
+  totalSkipped: number
+  totalMerged: number
+  sessionsTracked: number
+  lastCaptureAt?: string
+  queueSize: number
+}

package/src/index.ts

@@ -1,7 +1,7 @@
-#!/usr/bin/env bun
-import { runServe } from './cli/commands/serve'
-
-runServe().catch((error) => {
-  console.error('Fatal error:', error)
-  process.exit(1)
-})
+#!/usr/bin/env bun
+import { runServe } from './cli/commands/serve'
+
+runServe().catch((error) => {
+  console.error('Fatal error:', error)
+  process.exit(1)
+})

package/src/intelligence/cross-project/affinity.ts

@@ -1,162 +1,162 @@
-/**
- * Project Affinity
- * Computes similarity between projects based on decisions, patterns, and tech stack
- */
-
-import type { Logger } from 'pino'
-import type { CollectionManager } from '@/memory/chroma/collection-manager'
-import type { EmbeddingProvider } from '@/memory/chroma/embeddings'
-
-export interface ProjectAffinity {
-  projectA: string
-  projectB: string
-  similarity: number
-  sharedTopics: string[]
-  sharedTechnologies: string[]
-  decisionOverlap: number
-}
-
-export class AffinityCalculator {
-  private logger: Logger
-  private collections: CollectionManager
-  private embeddings?: EmbeddingProvider
-
-  constructor(logger: Logger, collections: CollectionManager, embeddings?: EmbeddingProvider) {
-    this.logger = logger.child({ component: 'affinity-calculator' })
-    this.collections = collections
-    this.embeddings = embeddings
-  }
-
-  /**
-   * Calculate affinity between all pairs of projects
-   */
-  async calculateAffinities(options: {
-    minDecisions?: number
-  } = {}): Promise<ProjectAffinity[]> {
-    const { minDecisions = 2 } = options
-
-    // Get all decisions grouped by project
-    const byProject = await this.getDecisionsByProject()
-
-    // Filter out projects with too few decisions
-    const projects = Array.from(byProject.entries())
-      .filter(([_, decisions]) => decisions.length >= minDecisions)
-
-    const affinities: ProjectAffinity[] = []
-
-    // Compare all pairs
-    for (let i = 0; i < projects.length; i++) {
-      for (let j = i + 1; j < projects.length; j++) {
-        const [projectA, decisionsA] = projects[i]
-        const [projectB, decisionsB] = projects[j]
-
-        const affinity = this.compareProjects(projectA, decisionsA, projectB, decisionsB)
-        if (affinity.similarity > 0.1) {
-          affinities.push(affinity)
-        }
-      }
-    }
-
-    return affinities.sort((a, b) => b.similarity - a.similarity)
-  }
-
-  /**
-   * Find most similar projects to a given project
-   */
-  async findSimilarProjects(project: string, limit: number = 5): Promise<ProjectAffinity[]> {
-    const affinities = await this.calculateAffinities()
-
-    return affinities
-      .filter(a => a.projectA === project || a.projectB === project)
-      .sort((a, b) => b.similarity - a.similarity)
-      .slice(0, limit)
-  }
-
-  private async getDecisionsByProject(): Promise<Map<string, Array<{ id: string; content: string; tags: string[] }>>> {
-    try {
-      const collection = await this.collections.getDecisions()
-
-      const results = await collection.get({
-        include: ['documents', 'metadatas']
-      })
-
-      const byProject = new Map<string, Array<{ id: string; content: string; tags: string[] }>>()
-
-      for (let i = 0; i < results.ids.length; i++) {
-        const project = (results.metadatas![i] as any)?.project || ''
-        if (!project) continue
-
-        if (!byProject.has(project)) byProject.set(project, [])
-
-        byProject.get(project)!.push({
-          id: results.ids[i],
-          content: results.documents![i] as string || '',
-          tags: String((results.metadatas![i] as any)?.tags || '').split(',').filter(t => t.trim())
-        })
-      }
-
-      return byProject
-    } catch (error) {
-      this.logger.warn({ error }, 'Failed to get decisions by project')
-      return new Map()
-    }
-  }
-
-  private compareProjects(
-    projectA: string,
-    decisionsA: Array<{ id: string; content: string; tags: string[] }>,
-    projectB: string,
-    decisionsB: Array<{ id: string; content: string; tags: string[] }>
-  ): ProjectAffinity {
-    // Term-based similarity
-    const termsA = this.extractAllTerms(decisionsA)
-    const termsB = this.extractAllTerms(decisionsB)
-
-    const sharedTopics = Array.from(termsA).filter(t => termsB.has(t))
-    const allTopics = new Set([...termsA, ...termsB])
-
-    const topicSimilarity = allTopics.size > 0 ? sharedTopics.length / allTopics.size : 0
-
-    // Tag-based similarity
-    const tagsA = new Set(decisionsA.flatMap(d => d.tags))
-    const tagsB = new Set(decisionsB.flatMap(d => d.tags))
-
-    const sharedTags = Array.from(tagsA).filter(t => tagsB.has(t))
-    const allTags = new Set([...tagsA, ...tagsB])
-    const tagSimilarity = allTags.size > 0 ? sharedTags.length / allTags.size : 0
-
-    // Combined similarity
-    const similarity = topicSimilarity * 0.7 + tagSimilarity * 0.3
-
-    return {
-      projectA,
-      projectB,
-      similarity,
-      sharedTopics: sharedTopics.slice(0, 20),
-      sharedTechnologies: sharedTags.slice(0, 10),
-      decisionOverlap: sharedTopics.length
-    }
-  }
-
-  private extractAllTerms(decisions: Array<{ content: string }>): Set<string> {
-    const terms = new Set<string>()
-    const stopWords = new Set([
-      'the', 'and', 'for', 'are', 'but', 'not', 'all', 'can', 'was',
-      'has', 'had', 'been', 'have', 'with', 'this', 'that', 'from',
-      'use', 'using', 'used', 'will', 'would', 'should', 'also',
-      'decision', 'decided', 'recommend', 'instead', 'because',
-      'project', 'context', 'reasoning', 'about', 'which', 'when'
-    ])
-
-    for (const d of decisions) {
-      const words = d.content.toLowerCase().replace(/[^a-z0-9\s]/g, ' ').split(/\s+/)
-      for (const w of words) {
-        if (w.length > 3 && !stopWords.has(w)) {
-          terms.add(w)
-        }
-      }
-    }
-
-    return terms
-  }
-}
+/**
+ * Project Affinity
+ * Computes similarity between projects based on decisions, patterns, and tech stack
+ */
+
+import type { Logger } from 'pino'
+import type { CollectionManager } from '@/memory/chroma/collection-manager'
+import type { EmbeddingProvider } from '@/memory/chroma/embeddings'
+
+export interface ProjectAffinity {
+  projectA: string
+  projectB: string
+  similarity: number
+  sharedTopics: string[]
+  sharedTechnologies: string[]
+  decisionOverlap: number
+}
+
+export class AffinityCalculator {
+  private logger: Logger
+  private collections: CollectionManager
+  private embeddings?: EmbeddingProvider
+
+  constructor(logger: Logger, collections: CollectionManager, embeddings?: EmbeddingProvider) {
+    this.logger = logger.child({ component: 'affinity-calculator' })
+    this.collections = collections
+    this.embeddings = embeddings
+  }
+
+  /**
+   * Calculate affinity between all pairs of projects
+   */
+  async calculateAffinities(options: {
+    minDecisions?: number
+  } = {}): Promise<ProjectAffinity[]> {
+    const { minDecisions = 2 } = options
+
+    // Get all decisions grouped by project
+    const byProject = await this.getDecisionsByProject()
+
+    // Filter out projects with too few decisions
+    const projects = Array.from(byProject.entries())
+      .filter(([_, decisions]) => decisions.length >= minDecisions)
+
+    const affinities: ProjectAffinity[] = []
+
+    // Compare all pairs
+    for (let i = 0; i < projects.length; i++) {
+      for (let j = i + 1; j < projects.length; j++) {
+        const [projectA, decisionsA] = projects[i]
+        const [projectB, decisionsB] = projects[j]
+
+        const affinity = this.compareProjects(projectA, decisionsA, projectB, decisionsB)
+        if (affinity.similarity > 0.1) {
+          affinities.push(affinity)
+        }
+      }
+    }
+
+    return affinities.sort((a, b) => b.similarity - a.similarity)
+  }
+
+  /**
+   * Find most similar projects to a given project
+   */
+  async findSimilarProjects(project: string, limit: number = 5): Promise<ProjectAffinity[]> {
+    const affinities = await this.calculateAffinities()
+
+    return affinities
+      .filter(a => a.projectA === project || a.projectB === project)
+      .sort((a, b) => b.similarity - a.similarity)
+      .slice(0, limit)
+  }
+
+  private async getDecisionsByProject(): Promise<Map<string, Array<{ id: string; content: string; tags: string[] }>>> {
+    try {
+      const collection = await this.collections.getDecisions()
+
+      const results = await collection.get({
+        include: ['documents', 'metadatas']
+      })
+
+      const byProject = new Map<string, Array<{ id: string; content: string; tags: string[] }>>()
+
+      for (let i = 0; i < results.ids.length; i++) {
+        const project = (results.metadatas![i] as any)?.project || ''
+        if (!project) continue
+
+        if (!byProject.has(project)) byProject.set(project, [])
+
+        byProject.get(project)!.push({
+          id: results.ids[i],
+          content: results.documents![i] as string || '',
+          tags: String((results.metadatas![i] as any)?.tags || '').split(',').filter(t => t.trim())
+        })
+      }
+
+      return byProject
+    } catch (error) {
+      this.logger.warn({ error }, 'Failed to get decisions by project')
+      return new Map()
+    }
+  }
+
+  private compareProjects(
+    projectA: string,
+    decisionsA: Array<{ id: string; content: string; tags: string[] }>,
+    projectB: string,
+    decisionsB: Array<{ id: string; content: string; tags: string[] }>
+  ): ProjectAffinity {
+    // Term-based similarity
+    const termsA = this.extractAllTerms(decisionsA)
+    const termsB = this.extractAllTerms(decisionsB)
+
+    const sharedTopics = Array.from(termsA).filter(t => termsB.has(t))
+    const allTopics = new Set([...termsA, ...termsB])
+
+    const topicSimilarity = allTopics.size > 0 ? sharedTopics.length / allTopics.size : 0
+
+    // Tag-based similarity
+    const tagsA = new Set(decisionsA.flatMap(d => d.tags))
+    const tagsB = new Set(decisionsB.flatMap(d => d.tags))
+
+    const sharedTags = Array.from(tagsA).filter(t => tagsB.has(t))
+    const allTags = new Set([...tagsA, ...tagsB])
+    const tagSimilarity = allTags.size > 0 ? sharedTags.length / allTags.size : 0
+
+    // Combined similarity
+    const similarity = topicSimilarity * 0.7 + tagSimilarity * 0.3
+
+    return {
+      projectA,
+      projectB,
+      similarity,
+      sharedTopics: sharedTopics.slice(0, 20),
+      sharedTechnologies: sharedTags.slice(0, 10),
+      decisionOverlap: sharedTopics.length
+    }
+  }
+
+  private extractAllTerms(decisions: Array<{ content: string }>): Set<string> {
+    const terms = new Set<string>()
+    const stopWords = new Set([
+      'the', 'and', 'for', 'are', 'but', 'not', 'all', 'can', 'was',
+      'has', 'had', 'been', 'have', 'with', 'this', 'that', 'from',
+      'use', 'using', 'used', 'will', 'would', 'should', 'also',
+      'decision', 'decided', 'recommend', 'instead', 'because',
+      'project', 'context', 'reasoning', 'about', 'which', 'when'
+    ])
+
+    for (const d of decisions) {
+      const words = d.content.toLowerCase().replace(/[^a-z0-9\s]/g, ' ').split(/\s+/)
+      for (const w of words) {
+        if (w.length > 3 && !stopWords.has(w)) {
+          terms.add(w)
+        }
+      }
+    }
+
+    return terms
+  }
+}