claude-brain 0.14.2 → 0.14.4

package/src/intelligence/prediction/recommender.ts

@@ -1,268 +1,268 @@
-/**
- * Recommender
- * Provides recommendations based on project history, patterns, and corrections
- */
-
-import type { Logger } from 'pino'
-import type { CollectionManager } from '@/memory/chroma/collection-manager'
-import type { EmbeddingProvider } from '@/memory/chroma/embeddings'
-
-export interface Recommendation {
-  type: 'pattern' | 'correction' | 'decision' | 'best-practice'
-  content: string
-  confidence: number
-  source: string
-  sourceId: string
-  reasoning: string
-}
-
-export interface RecommendationResult {
-  query: string
-  project?: string
-  recommendations: Recommendation[]
-  totalConsidered: number
-}
-
-export class Recommender {
-  private logger: Logger
-  private collections: CollectionManager
-  private embeddings?: EmbeddingProvider
-
-  constructor(logger: Logger, collections: CollectionManager, embeddings?: EmbeddingProvider) {
-    this.logger = logger.child({ component: 'recommender' })
-    this.collections = collections
-    this.embeddings = embeddings
-  }
-
-  /**
-   * Get recommendations for a given context
-   */
-  async getRecommendations(query: string, options: {
-    project?: string
-    limit?: number
-    types?: Array<'pattern' | 'correction' | 'decision'>
-  } = {}): Promise<RecommendationResult> {
-    const {
-      project,
-      limit = 10,
-      types = ['pattern', 'correction', 'decision']
-    } = options
-
-    const allRecommendations: Recommendation[] = []
-    let totalConsidered = 0
-
-    // Fetch from patterns
-    if (types.includes('pattern')) {
-      const patterns = await this.fetchPatternRecommendations(query, project, limit)
-      allRecommendations.push(...patterns.recommendations)
-      totalConsidered += patterns.considered
-    }
-
-    // Fetch from corrections (things to avoid)
-    if (types.includes('correction')) {
-      const corrections = await this.fetchCorrectionRecommendations(query, project, limit)
-      allRecommendations.push(...corrections.recommendations)
-      totalConsidered += corrections.considered
-    }
-
-    // Fetch from past decisions
-    if (types.includes('decision')) {
-      const decisions = await this.fetchDecisionRecommendations(query, project, limit)
-      allRecommendations.push(...decisions.recommendations)
-      totalConsidered += decisions.considered
-    }
-
-    // Sort by confidence and deduplicate
-    const sorted = allRecommendations
-      .sort((a, b) => b.confidence - a.confidence)
-      .slice(0, limit)
-
-    return {
-      query,
-      project,
-      recommendations: sorted,
-      totalConsidered
-    }
-  }
-
-  private async fetchPatternRecommendations(
-    query: string,
-    project?: string,
-    limit: number = 5
-  ): Promise<{ recommendations: Recommendation[]; considered: number }> {
-    try {
-      const collection = await this.collections.getPatterns()
-
-      const where: any = project ? { project: { $eq: project } } : undefined
-
-      let results: any
-
-      if (this.embeddings) {
-        const embedding = await this.embeddings.generate(query)
-        results = await collection.query({
-          queryEmbeddings: [embedding],
-          nResults: limit,
-          where,
-          include: ['documents', 'metadatas', 'distances']
-        })
-      } else {
-        results = await collection.query({
-          queryTexts: [query],
-          nResults: limit,
-          where,
-          include: ['documents', 'metadatas', 'distances']
-        })
-      }
-
-      if (!results.ids || !results.ids[0]) return { recommendations: [], considered: 0 }
-
-      const recommendations: Recommendation[] = []
-      const ids = results.ids[0]
-      const documents = results.documents?.[0] || []
-      const metadatas = results.metadatas?.[0] || []
-      const distances = results.distances?.[0] || []
-
-      for (let i = 0; i < ids.length; i++) {
-        const similarity = 1 - (distances[i] || 0)
-        if (similarity < 0.3) continue
-
-        const meta = metadatas[i] as any
-        const patternType = meta?.pattern_type || 'pattern'
-
-        recommendations.push({
-          type: patternType === 'best-practice' ? 'best-practice' : 'pattern',
-          content: documents[i] || '',
-          confidence: similarity * (meta?.confidence || 0.8),
-          source: `Pattern (${patternType})`,
-          sourceId: ids[i],
-          reasoning: meta?.context || `Relevant ${patternType} pattern found`
-        })
-      }
-
-      return { recommendations, considered: ids.length }
-    } catch (error) {
-      this.logger.debug({ error }, 'Failed to fetch pattern recommendations')
-      return { recommendations: [], considered: 0 }
-    }
-  }
-
-  private async fetchCorrectionRecommendations(
-    query: string,
-    project?: string,
-    limit: number = 5
-  ): Promise<{ recommendations: Recommendation[]; considered: number }> {
-    try {
-      const collection = await this.collections.getCorrections()
-
-      const where: any = project ? { project: { $eq: project } } : undefined
-
-      let results: any
-
-      if (this.embeddings) {
-        const embedding = await this.embeddings.generate(query)
-        results = await collection.query({
-          queryEmbeddings: [embedding],
-          nResults: limit,
-          where,
-          include: ['documents', 'metadatas', 'distances']
-        })
-      } else {
-        results = await collection.query({
-          queryTexts: [query],
-          nResults: limit,
-          where,
-          include: ['documents', 'metadatas', 'distances']
-        })
-      }
-
-      if (!results.ids || !results.ids[0]) return { recommendations: [], considered: 0 }
-
-      const recommendations: Recommendation[] = []
-      const ids = results.ids[0]
-      const documents = results.documents?.[0] || []
-      const metadatas = results.metadatas?.[0] || []
-      const distances = results.distances?.[0] || []
-
-      for (let i = 0; i < ids.length; i++) {
-        const similarity = 1 - (distances[i] || 0)
-        if (similarity < 0.3) continue
-
-        const meta = metadatas[i] as any
-
-        recommendations.push({
-          type: 'correction',
-          content: `Avoid: ${meta?.original || ''}\nDo instead: ${documents[i] || ''}`,
-          confidence: similarity * (meta?.confidence || 0.9),
-          source: 'Lesson Learned',
-          sourceId: ids[i],
-          reasoning: meta?.reasoning || 'Based on a past correction'
-        })
-      }
-
-      return { recommendations, considered: ids.length }
-    } catch (error) {
-      this.logger.debug({ error }, 'Failed to fetch correction recommendations')
-      return { recommendations: [], considered: 0 }
-    }
-  }
-
-  private async fetchDecisionRecommendations(
-    query: string,
-    project?: string,
-    limit: number = 5
-  ): Promise<{ recommendations: Recommendation[]; considered: number }> {
-    try {
-      const collection = await this.collections.getDecisions()
-
-      const where: any = project ? { project: { $eq: project } } : undefined
-
-      let results: any
-
-      if (this.embeddings) {
-        const embedding = await this.embeddings.generate(query)
-        results = await collection.query({
-          queryEmbeddings: [embedding],
-          nResults: limit,
-          where,
-          include: ['documents', 'metadatas', 'distances']
-        })
-      } else {
-        results = await collection.query({
-          queryTexts: [query],
-          nResults: limit,
-          where,
-          include: ['documents', 'metadatas', 'distances']
-        })
-      }
-
-      if (!results.ids || !results.ids[0]) return { recommendations: [], considered: 0 }
-
-      const recommendations: Recommendation[] = []
-      const ids = results.ids[0]
-      const documents = results.documents?.[0] || []
-      const metadatas = results.metadatas?.[0] || []
-      const distances = results.distances?.[0] || []
-
-      for (let i = 0; i < ids.length; i++) {
-        const similarity = 1 - (distances[i] || 0)
-        if (similarity < 0.5) continue // Higher threshold for past decisions
-
-        const meta = metadatas[i] as any
-
-        recommendations.push({
-          type: 'decision',
-          content: documents[i] || '',
-          confidence: similarity,
-          source: 'Past Decision',
-          sourceId: ids[i],
-          reasoning: meta?.reasoning || 'Based on a previous decision in similar context'
-        })
-      }
-
-      return { recommendations, considered: ids.length }
-    } catch (error) {
-      this.logger.debug({ error }, 'Failed to fetch decision recommendations')
-      return { recommendations: [], considered: 0 }
-    }
-  }
-}
+/**
+ * Recommender
+ * Provides recommendations based on project history, patterns, and corrections
+ */
+
+import type { Logger } from 'pino'
+import type { CollectionManager } from '@/memory/chroma/collection-manager'
+import type { EmbeddingProvider } from '@/memory/chroma/embeddings'
+
+export interface Recommendation {
+  type: 'pattern' | 'correction' | 'decision' | 'best-practice'
+  content: string
+  confidence: number
+  source: string
+  sourceId: string
+  reasoning: string
+}
+
+export interface RecommendationResult {
+  query: string
+  project?: string
+  recommendations: Recommendation[]
+  totalConsidered: number
+}
+
+export class Recommender {
+  private logger: Logger
+  private collections: CollectionManager
+  private embeddings?: EmbeddingProvider
+
+  constructor(logger: Logger, collections: CollectionManager, embeddings?: EmbeddingProvider) {
+    this.logger = logger.child({ component: 'recommender' })
+    this.collections = collections
+    this.embeddings = embeddings
+  }
+
+  /**
+   * Get recommendations for a given context
+   */
+  async getRecommendations(query: string, options: {
+    project?: string
+    limit?: number
+    types?: Array<'pattern' | 'correction' | 'decision'>
+  } = {}): Promise<RecommendationResult> {
+    const {
+      project,
+      limit = 10,
+      types = ['pattern', 'correction', 'decision']
+    } = options
+
+    const allRecommendations: Recommendation[] = []
+    let totalConsidered = 0
+
+    // Fetch from patterns
+    if (types.includes('pattern')) {
+      const patterns = await this.fetchPatternRecommendations(query, project, limit)
+      allRecommendations.push(...patterns.recommendations)
+      totalConsidered += patterns.considered
+    }
+
+    // Fetch from corrections (things to avoid)
+    if (types.includes('correction')) {
+      const corrections = await this.fetchCorrectionRecommendations(query, project, limit)
+      allRecommendations.push(...corrections.recommendations)
+      totalConsidered += corrections.considered
+    }
+
+    // Fetch from past decisions
+    if (types.includes('decision')) {
+      const decisions = await this.fetchDecisionRecommendations(query, project, limit)
+      allRecommendations.push(...decisions.recommendations)
+      totalConsidered += decisions.considered
+    }
+
+    // Sort by confidence and deduplicate
+    const sorted = allRecommendations
+      .sort((a, b) => b.confidence - a.confidence)
+      .slice(0, limit)
+
+    return {
+      query,
+      project,
+      recommendations: sorted,
+      totalConsidered
+    }
+  }
+
+  private async fetchPatternRecommendations(
+    query: string,
+    project?: string,
+    limit: number = 5
+  ): Promise<{ recommendations: Recommendation[]; considered: number }> {
+    try {
+      const collection = await this.collections.getPatterns()
+
+      const where: any = project ? { project: { $eq: project } } : undefined
+
+      let results: any
+
+      if (this.embeddings) {
+        const embedding = await this.embeddings.generate(query)
+        results = await collection.query({
+          queryEmbeddings: [embedding],
+          nResults: limit,
+          where,
+          include: ['documents', 'metadatas', 'distances']
+        })
+      } else {
+        results = await collection.query({
+          queryTexts: [query],
+          nResults: limit,
+          where,
+          include: ['documents', 'metadatas', 'distances']
+        })
+      }
+
+      if (!results.ids || !results.ids[0]) return { recommendations: [], considered: 0 }
+
+      const recommendations: Recommendation[] = []
+      const ids = results.ids[0]
+      const documents = results.documents?.[0] || []
+      const metadatas = results.metadatas?.[0] || []
+      const distances = results.distances?.[0] || []
+
+      for (let i = 0; i < ids.length; i++) {
+        const similarity = 1 - (distances[i] || 0)
+        if (similarity < 0.3) continue
+
+        const meta = metadatas[i] as any
+        const patternType = meta?.pattern_type || 'pattern'
+
+        recommendations.push({
+          type: patternType === 'best-practice' ? 'best-practice' : 'pattern',
+          content: documents[i] || '',
+          confidence: similarity * (meta?.confidence || 0.8),
+          source: `Pattern (${patternType})`,
+          sourceId: ids[i],
+          reasoning: meta?.context || `Relevant ${patternType} pattern found`
+        })
+      }
+
+      return { recommendations, considered: ids.length }
+    } catch (error) {
+      this.logger.debug({ error }, 'Failed to fetch pattern recommendations')
+      return { recommendations: [], considered: 0 }
+    }
+  }
+
+  private async fetchCorrectionRecommendations(
+    query: string,
+    project?: string,
+    limit: number = 5
+  ): Promise<{ recommendations: Recommendation[]; considered: number }> {
+    try {
+      const collection = await this.collections.getCorrections()
+
+      const where: any = project ? { project: { $eq: project } } : undefined
+
+      let results: any
+
+      if (this.embeddings) {
+        const embedding = await this.embeddings.generate(query)
+        results = await collection.query({
+          queryEmbeddings: [embedding],
+          nResults: limit,
+          where,
+          include: ['documents', 'metadatas', 'distances']
+        })
+      } else {
+        results = await collection.query({
+          queryTexts: [query],
+          nResults: limit,
+          where,
+          include: ['documents', 'metadatas', 'distances']
+        })
+      }
+
+      if (!results.ids || !results.ids[0]) return { recommendations: [], considered: 0 }
+
+      const recommendations: Recommendation[] = []
+      const ids = results.ids[0]
+      const documents = results.documents?.[0] || []
+      const metadatas = results.metadatas?.[0] || []
+      const distances = results.distances?.[0] || []
+
+      for (let i = 0; i < ids.length; i++) {
+        const similarity = 1 - (distances[i] || 0)
+        if (similarity < 0.3) continue
+
+        const meta = metadatas[i] as any
+
+        recommendations.push({
+          type: 'correction',
+          content: `Avoid: ${meta?.original || ''}\nDo instead: ${documents[i] || ''}`,
+          confidence: similarity * (meta?.confidence || 0.9),
+          source: 'Lesson Learned',
+          sourceId: ids[i],
+          reasoning: meta?.reasoning || 'Based on a past correction'
+        })
+      }
+
+      return { recommendations, considered: ids.length }
+    } catch (error) {
+      this.logger.debug({ error }, 'Failed to fetch correction recommendations')
+      return { recommendations: [], considered: 0 }
+    }
+  }
+
+  private async fetchDecisionRecommendations(
+    query: string,
+    project?: string,
+    limit: number = 5
+  ): Promise<{ recommendations: Recommendation[]; considered: number }> {
+    try {
+      const collection = await this.collections.getDecisions()
+
+      const where: any = project ? { project: { $eq: project } } : undefined
+
+      let results: any
+
+      if (this.embeddings) {
+        const embedding = await this.embeddings.generate(query)
+        results = await collection.query({
+          queryEmbeddings: [embedding],
+          nResults: limit,
+          where,
+          include: ['documents', 'metadatas', 'distances']
+        })
+      } else {
+        results = await collection.query({
+          queryTexts: [query],
+          nResults: limit,
+          where,
+          include: ['documents', 'metadatas', 'distances']
+        })
+      }
+
+      if (!results.ids || !results.ids[0]) return { recommendations: [], considered: 0 }
+
+      const recommendations: Recommendation[] = []
+      const ids = results.ids[0]
+      const documents = results.documents?.[0] || []
+      const metadatas = results.metadatas?.[0] || []
+      const distances = results.distances?.[0] || []
+
+      for (let i = 0; i < ids.length; i++) {
+        const similarity = 1 - (distances[i] || 0)
+        if (similarity < 0.5) continue // Higher threshold for past decisions
+
+        const meta = metadatas[i] as any
+
+        recommendations.push({
+          type: 'decision',
+          content: documents[i] || '',
+          confidence: similarity,
+          source: 'Past Decision',
+          sourceId: ids[i],
+          reasoning: meta?.reasoning || 'Based on a previous decision in similar context'
+        })
+      }
+
+      return { recommendations, considered: ids.length }
+    } catch (error) {
+      this.logger.debug({ error }, 'Failed to fetch decision recommendations')
+      return { recommendations: [], considered: 0 }
+    }
+  }
+}