claude-brain 0.30.2 → 0.30.3

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

@@ -1,283 +1,283 @@
-/**
- * Pattern Generalizer
- * Finds common patterns across multiple projects
- */
-
-import type { Logger } from 'pino'
-import type { CollectionManager } from '@/memory/chroma/collection-manager'
-import type { EmbeddingProvider } from '@/memory/chroma/embeddings'
-
-export interface GeneralizedPattern {
-  description: string
-  projects: string[]
-  occurrences: number
-  confidence: number
-  examples: Array<{
-    project: string
-    content: string
-    id: string
-  }>
-}
-
-export interface GeneralizationResult {
-  patterns: GeneralizedPattern[]
-  projectsAnalyzed: string[]
-  totalDecisionsAnalyzed: number
-}
-
-export class PatternGeneralizer {
-  private logger: Logger
-  private collections: CollectionManager
-  private embeddings?: EmbeddingProvider
-
-  constructor(logger: Logger, collections: CollectionManager, embeddings?: EmbeddingProvider) {
-    this.logger = logger.child({ component: 'pattern-generalizer' })
-    this.collections = collections
-    this.embeddings = embeddings
-  }
-
-  /**
-   * Find patterns that appear across multiple projects
-   */
-  async findCrossProjectPatterns(options: {
-    minProjects?: number
-    limit?: number
-    query?: string
-  } = {}): Promise<GeneralizationResult> {
-    const { minProjects = 2, limit = 20, query } = options
-
-    // Fetch all decisions
-    const allDecisions = await this.fetchAllDecisions(query)
-
-    // Group by project
-    const byProject = new Map<string, Array<{ id: string; content: string }>>()
-    for (const d of allDecisions) {
-      const project = d.project
-      if (!byProject.has(project)) byProject.set(project, [])
-      byProject.get(project)!.push({ id: d.id, content: d.content })
-    }
-
-    const projects = Array.from(byProject.keys())
-
-    if (projects.length < minProjects) {
-      return {
-        patterns: [],
-        projectsAnalyzed: projects,
-        totalDecisionsAnalyzed: allDecisions.length
-      }
-    }
-
-    // Find cross-project patterns using term overlap
-    const crossPatterns = this.findCommonTermPatterns(byProject, minProjects)
-
-    // If embeddings are available, also do semantic clustering
-    if (this.embeddings && allDecisions.length > 0) {
-      const semanticPatterns = await this.findSemanticClusters(allDecisions, minProjects)
-      crossPatterns.push(...semanticPatterns)
-    }
-
-    // Deduplicate and rank
-    const deduped = this.deduplicatePatterns(crossPatterns)
-    const ranked = deduped
-      .sort((a, b) => b.occurrences * b.confidence - a.occurrences * a.confidence)
-      .slice(0, limit)
-
-    return {
-      patterns: ranked,
-      projectsAnalyzed: projects,
-      totalDecisionsAnalyzed: allDecisions.length
-    }
-  }
-
-  private async fetchAllDecisions(query?: string): Promise<Array<{
-    id: string
-    content: string
-    project: string
-  }>> {
-    try {
-      const collection = await this.collections.getDecisions()
-
-      if (query && this.embeddings) {
-        const embedding = await this.embeddings.generate(query)
-        const results = await collection.query({
-          queryEmbeddings: [embedding],
-          nResults: 100,
-          include: ['documents', 'metadatas', 'distances']
-        })
-
-        if (!results.ids || !results.ids[0]) return []
-
-        return results.ids[0].map((id: string, i: number) => ({
-          id,
-          content: results.documents?.[0]?.[i] || '',
-          project: (results.metadatas?.[0]?.[i] as any)?.project || ''
-        }))
-      }
-
-      const results = await collection.get({
-        include: ['documents', 'metadatas']
-      })
-
-      return results.ids.map((id, i) => ({
-        id,
-        content: results.documents![i] as string || '',
-        project: (results.metadatas![i] as any)?.project || ''
-      }))
-    } catch (error) {
-      this.logger.warn({ error }, 'Failed to fetch decisions for generalization')
-      return []
-    }
-  }
-
-  private findCommonTermPatterns(
-    byProject: Map<string, Array<{ id: string; content: string }>>,
-    minProjects: number
-  ): GeneralizedPattern[] {
-    // Extract key terms per project
-    const projectTerms = new Map<string, Map<string, Array<{ id: string; content: string }>>>()
-
-    for (const [project, decisions] of byProject) {
-      const terms = new Map<string, Array<{ id: string; content: string }>>()
-
-      for (const d of decisions) {
-        const words = this.extractKeyTerms(d.content)
-
-        for (const word of words) {
-          if (!terms.has(word)) terms.set(word, [])
-          terms.get(word)!.push(d)
-        }
-      }
-
-      projectTerms.set(project, terms)
-    }
-
-    // Find terms that appear across multiple projects
-    const allTerms = new Map<string, { projects: Set<string>; examples: Array<{ project: string; content: string; id: string }> }>()
-
-    for (const [project, terms] of projectTerms) {
-      for (const [term, decisions] of terms) {
-        if (!allTerms.has(term)) {
-          allTerms.set(term, { projects: new Set(), examples: [] })
-        }
-        const entry = allTerms.get(term)!
-        entry.projects.add(project)
-        for (const d of decisions.slice(0, 2)) {
-          entry.examples.push({ project, content: d.content.slice(0, 150), id: d.id })
-        }
-      }
-    }
-
-    // Filter to terms appearing in multiple projects
-    const patterns: GeneralizedPattern[] = []
-
-    for (const [term, data] of allTerms) {
-      if (data.projects.size >= minProjects) {
-        patterns.push({
-          description: `Common pattern around: "${term}"`,
-          projects: Array.from(data.projects),
-          occurrences: data.examples.length,
-          confidence: Math.min(data.projects.size / byProject.size, 1),
-          examples: data.examples.slice(0, 5)
-        })
-      }
-    }
-
-    return patterns
-  }
-
-  private async findSemanticClusters(
-    decisions: Array<{ id: string; content: string; project: string }>,
-    minProjects: number
-  ): Promise<GeneralizedPattern[]> {
-    if (!this.embeddings) return []
-
-    const patterns: GeneralizedPattern[] = []
-
-    try {
-      // Simple approach: for each decision, find similar ones across projects
-      const sample = decisions.slice(0, 20) // Limit to avoid too many embedding calls
-
-      for (const decision of sample) {
-        const collection = await this.collections.getDecisions()
-        const embedding = await this.embeddings.generate(decision.content)
-
-        const results = await collection.query({
-          queryEmbeddings: [embedding],
-          nResults: 10,
-          include: ['documents', 'metadatas', 'distances']
-        })
-
-        if (!results.ids || !results.ids[0]) continue
-
-        const crossProjectMatches: Array<{ project: string; content: string; id: string }> = []
-        const matchProjects = new Set<string>()
-
-        for (let i = 0; i < results.ids[0].length; i++) {
-          const similarity = 1 - (results.distances?.[0]?.[i] || 0)
-          if (similarity < 0.6) continue
-
-          const matchProject = (results.metadatas?.[0]?.[i] as any)?.project || ''
-          if (matchProject && matchProject !== decision.project) {
-            matchProjects.add(matchProject)
-            crossProjectMatches.push({
-              project: matchProject,
-              content: (results.documents?.[0]?.[i] || '').slice(0, 150),
-              id: results.ids[0]![i]!
-            })
-          }
-        }
-
-        matchProjects.add(decision.project)
-
-        if (matchProjects.size >= minProjects) {
-          patterns.push({
-            description: `Similar approaches: "${decision.content.slice(0, 100)}..."`,
-            projects: Array.from(matchProjects),
-            occurrences: crossProjectMatches.length + 1,
-            confidence: 0.7,
-            examples: [
-              { project: decision.project, content: decision.content.slice(0, 150), id: decision.id },
-              ...crossProjectMatches.slice(0, 4)
-            ]
-          })
-        }
-      }
-    } catch (error) {
-      this.logger.debug({ error }, 'Failed to find semantic clusters')
-    }
-
-    return patterns
-  }
-
-  private deduplicatePatterns(patterns: GeneralizedPattern[]): GeneralizedPattern[] {
-    const seen = new Set<string>()
-    const deduped: GeneralizedPattern[] = []
-
-    for (const pattern of patterns) {
-      const key = pattern.description.toLowerCase().slice(0, 50)
-      if (!seen.has(key)) {
-        seen.add(key)
-        deduped.push(pattern)
-      }
-    }
-
-    return deduped
-  }
-
-  private extractKeyTerms(text: string): string[] {
-    const stopWords = new Set([
-      'the', 'and', 'for', 'are', 'but', 'not', 'all', 'can', 'was',
-      'has', 'had', 'been', 'have', 'with', 'this', 'that', 'from',
-      'they', 'will', 'would', 'there', 'their', 'what', 'about',
-      'which', 'when', 'make', 'like', 'just', 'also', 'should',
-      'use', 'using', 'used', 'because', 'instead', 'project',
-      'decision', 'decided', 'recommend', 'context', 'reasoning'
-    ])
-
-    return text
-      .toLowerCase()
-      .replace(/[^a-z0-9\s-]/g, ' ')
-      .split(/\s+/)
-      .filter(w => w.length > 3 && !stopWords.has(w))
-  }
-}
+/**
+ * Pattern Generalizer
+ * Finds common patterns across multiple projects
+ */
+
+import type { Logger } from 'pino'
+import type { CollectionManager } from '@/memory/chroma/collection-manager'
+import type { EmbeddingProvider } from '@/memory/chroma/embeddings'
+
+export interface GeneralizedPattern {
+  description: string
+  projects: string[]
+  occurrences: number
+  confidence: number
+  examples: Array<{
+    project: string
+    content: string
+    id: string
+  }>
+}
+
+export interface GeneralizationResult {
+  patterns: GeneralizedPattern[]
+  projectsAnalyzed: string[]
+  totalDecisionsAnalyzed: number
+}
+
+export class PatternGeneralizer {
+  private logger: Logger
+  private collections: CollectionManager
+  private embeddings?: EmbeddingProvider
+
+  constructor(logger: Logger, collections: CollectionManager, embeddings?: EmbeddingProvider) {
+    this.logger = logger.child({ component: 'pattern-generalizer' })
+    this.collections = collections
+    this.embeddings = embeddings
+  }
+
+  /**
+   * Find patterns that appear across multiple projects
+   */
+  async findCrossProjectPatterns(options: {
+    minProjects?: number
+    limit?: number
+    query?: string
+  } = {}): Promise<GeneralizationResult> {
+    const { minProjects = 2, limit = 20, query } = options
+
+    // Fetch all decisions
+    const allDecisions = await this.fetchAllDecisions(query)
+
+    // Group by project
+    const byProject = new Map<string, Array<{ id: string; content: string }>>()
+    for (const d of allDecisions) {
+      const project = d.project
+      if (!byProject.has(project)) byProject.set(project, [])
+      byProject.get(project)!.push({ id: d.id, content: d.content })
+    }
+
+    const projects = Array.from(byProject.keys())
+
+    if (projects.length < minProjects) {
+      return {
+        patterns: [],
+        projectsAnalyzed: projects,
+        totalDecisionsAnalyzed: allDecisions.length
+      }
+    }
+
+    // Find cross-project patterns using term overlap
+    const crossPatterns = this.findCommonTermPatterns(byProject, minProjects)
+
+    // If embeddings are available, also do semantic clustering
+    if (this.embeddings && allDecisions.length > 0) {
+      const semanticPatterns = await this.findSemanticClusters(allDecisions, minProjects)
+      crossPatterns.push(...semanticPatterns)
+    }
+
+    // Deduplicate and rank
+    const deduped = this.deduplicatePatterns(crossPatterns)
+    const ranked = deduped
+      .sort((a, b) => b.occurrences * b.confidence - a.occurrences * a.confidence)
+      .slice(0, limit)
+
+    return {
+      patterns: ranked,
+      projectsAnalyzed: projects,
+      totalDecisionsAnalyzed: allDecisions.length
+    }
+  }
+
+  private async fetchAllDecisions(query?: string): Promise<Array<{
+    id: string
+    content: string
+    project: string
+  }>> {
+    try {
+      const collection = await this.collections.getDecisions()
+
+      if (query && this.embeddings) {
+        const embedding = await this.embeddings.generate(query)
+        const results = await collection.query({
+          queryEmbeddings: [embedding],
+          nResults: 100,
+          include: ['documents', 'metadatas', 'distances']
+        })
+
+        if (!results.ids || !results.ids[0]) return []
+
+        return results.ids[0].map((id: string, i: number) => ({
+          id,
+          content: results.documents?.[0]?.[i] || '',
+          project: (results.metadatas?.[0]?.[i] as any)?.project || ''
+        }))
+      }
+
+      const results = await collection.get({
+        include: ['documents', 'metadatas']
+      })
+
+      return results.ids.map((id, i) => ({
+        id,
+        content: results.documents![i] as string || '',
+        project: (results.metadatas![i] as any)?.project || ''
+      }))
+    } catch (error) {
+      this.logger.warn({ error }, 'Failed to fetch decisions for generalization')
+      return []
+    }
+  }
+
+  private findCommonTermPatterns(
+    byProject: Map<string, Array<{ id: string; content: string }>>,
+    minProjects: number
+  ): GeneralizedPattern[] {
+    // Extract key terms per project
+    const projectTerms = new Map<string, Map<string, Array<{ id: string; content: string }>>>()
+
+    for (const [project, decisions] of byProject) {
+      const terms = new Map<string, Array<{ id: string; content: string }>>()
+
+      for (const d of decisions) {
+        const words = this.extractKeyTerms(d.content)
+
+        for (const word of words) {
+          if (!terms.has(word)) terms.set(word, [])
+          terms.get(word)!.push(d)
+        }
+      }
+
+      projectTerms.set(project, terms)
+    }
+
+    // Find terms that appear across multiple projects
+    const allTerms = new Map<string, { projects: Set<string>; examples: Array<{ project: string; content: string; id: string }> }>()
+
+    for (const [project, terms] of projectTerms) {
+      for (const [term, decisions] of terms) {
+        if (!allTerms.has(term)) {
+          allTerms.set(term, { projects: new Set(), examples: [] })
+        }
+        const entry = allTerms.get(term)!
+        entry.projects.add(project)
+        for (const d of decisions.slice(0, 2)) {
+          entry.examples.push({ project, content: d.content.slice(0, 150), id: d.id })
+        }
+      }
+    }
+
+    // Filter to terms appearing in multiple projects
+    const patterns: GeneralizedPattern[] = []
+
+    for (const [term, data] of allTerms) {
+      if (data.projects.size >= minProjects) {
+        patterns.push({
+          description: `Common pattern around: "${term}"`,
+          projects: Array.from(data.projects),
+          occurrences: data.examples.length,
+          confidence: Math.min(data.projects.size / byProject.size, 1),
+          examples: data.examples.slice(0, 5)
+        })
+      }
+    }
+
+    return patterns
+  }
+
+  private async findSemanticClusters(
+    decisions: Array<{ id: string; content: string; project: string }>,
+    minProjects: number
+  ): Promise<GeneralizedPattern[]> {
+    if (!this.embeddings) return []
+
+    const patterns: GeneralizedPattern[] = []
+
+    try {
+      // Simple approach: for each decision, find similar ones across projects
+      const sample = decisions.slice(0, 20) // Limit to avoid too many embedding calls
+
+      for (const decision of sample) {
+        const collection = await this.collections.getDecisions()
+        const embedding = await this.embeddings.generate(decision.content)
+
+        const results = await collection.query({
+          queryEmbeddings: [embedding],
+          nResults: 10,
+          include: ['documents', 'metadatas', 'distances']
+        })
+
+        if (!results.ids || !results.ids[0]) continue
+
+        const crossProjectMatches: Array<{ project: string; content: string; id: string }> = []
+        const matchProjects = new Set<string>()
+
+        for (let i = 0; i < results.ids[0].length; i++) {
+          const similarity = 1 - (results.distances?.[0]?.[i] || 0)
+          if (similarity < 0.6) continue
+
+          const matchProject = (results.metadatas?.[0]?.[i] as any)?.project || ''
+          if (matchProject && matchProject !== decision.project) {
+            matchProjects.add(matchProject)
+            crossProjectMatches.push({
+              project: matchProject,
+              content: (results.documents?.[0]?.[i] || '').slice(0, 150),
+              id: results.ids[0]![i]!
+            })
+          }
+        }
+
+        matchProjects.add(decision.project)
+
+        if (matchProjects.size >= minProjects) {
+          patterns.push({
+            description: `Similar approaches: "${decision.content.slice(0, 100)}..."`,
+            projects: Array.from(matchProjects),
+            occurrences: crossProjectMatches.length + 1,
+            confidence: 0.7,
+            examples: [
+              { project: decision.project, content: decision.content.slice(0, 150), id: decision.id },
+              ...crossProjectMatches.slice(0, 4)
+            ]
+          })
+        }
+      }
+    } catch (error) {
+      this.logger.debug({ error }, 'Failed to find semantic clusters')
+    }
+
+    return patterns
+  }
+
+  private deduplicatePatterns(patterns: GeneralizedPattern[]): GeneralizedPattern[] {
+    const seen = new Set<string>()
+    const deduped: GeneralizedPattern[] = []
+
+    for (const pattern of patterns) {
+      const key = pattern.description.toLowerCase().slice(0, 50)
+      if (!seen.has(key)) {
+        seen.add(key)
+        deduped.push(pattern)
+      }
+    }
+
+    return deduped
+  }
+
+  private extractKeyTerms(text: string): string[] {
+    const stopWords = new Set([
+      'the', 'and', 'for', 'are', 'but', 'not', 'all', 'can', 'was',
+      'has', 'had', 'been', 'have', 'with', 'this', 'that', 'from',
+      'they', 'will', 'would', 'there', 'their', 'what', 'about',
+      'which', 'when', 'make', 'like', 'just', 'also', 'should',
+      'use', 'using', 'used', 'because', 'instead', 'project',
+      'decision', 'decided', 'recommend', 'context', 'reasoning'
+    ])
+
+    return text
+      .toLowerCase()
+      .replace(/[^a-z0-9\s-]/g, ' ')
+      .split(/\s+/)
+      .filter(w => w.length > 3 && !stopWords.has(w))
+  }
+}

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

@@ -1,7 +1,7 @@
-/**
- * Cross-Project Intelligence Module
- * Phase 15.4 - Pattern generalization
- */
-
-export { PatternGeneralizer } from './generalizer'
-export type { GeneralizedPattern, GeneralizationResult } from './generalizer'
+/**
+ * Cross-Project Intelligence Module
+ * Phase 15.4 - Pattern generalization
+ */
+
+export { PatternGeneralizer } from './generalizer'
+export type { GeneralizedPattern, GeneralizationResult } from './generalizer'