claude-brain 0.3.0

package/src/prediction/decision-predictor.ts

@@ -0,0 +1,184 @@
+/**
+ * Decision Predictor
+ * Predicts likely next decisions based on historical patterns
+ */
+
+import type { Logger } from 'pino'
+import type { CollectionManager } from '@/memory/chroma/collection-manager'
+import type { EmbeddingProvider } from '@/memory/chroma/embeddings'
+
+export interface PredictedDecision {
+  prediction: string
+  confidence: number
+  basedOn: Array<{
+    id: string
+    decision: string
+    similarity: number
+  }>
+  reasoning: string
+}
+
+export class DecisionPredictor {
+  private logger: Logger
+  private collections: CollectionManager
+  private embeddings?: EmbeddingProvider
+
+  constructor(logger: Logger, collections: CollectionManager, embeddings?: EmbeddingProvider) {
+    this.logger = logger.child({ component: 'decision-predictor' })
+    this.collections = collections
+    this.embeddings = embeddings
+  }
+
+  /**
+   * Predict likely decisions for a given context
+   */
+  async predict(context: string, options: {
+    project?: string
+    limit?: number
+  } = {}): Promise<PredictedDecision[]> {
+    const { project, limit = 5 } = options
+
+    // Find similar past contexts and their resulting decisions
+    const pastDecisions = await this.findSimilarContextDecisions(context, project, limit * 3)
+
+    if (pastDecisions.length === 0) {
+      return []
+    }
+
+    // Group by similar decisions
+    const grouped = this.groupSimilarDecisions(pastDecisions)
+
+    // Rank by frequency and similarity
+    const predictions = grouped
+      .map(group => this.buildPrediction(group, context))
+      .sort((a, b) => b.confidence - a.confidence)
+      .slice(0, limit)
+
+    return predictions
+  }
+
+  private async findSimilarContextDecisions(
+    context: string,
+    project?: string,
+    limit: number = 15
+  ): Promise<Array<{ id: string; decision: string; context: string; similarity: 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(context)
+        results = await collection.query({
+          queryEmbeddings: [embedding],
+          nResults: limit,
+          where,
+          include: ['documents', 'metadatas', 'distances']
+        })
+      } else {
+        results = await collection.query({
+          queryTexts: [context],
+          nResults: limit,
+          where,
+          include: ['documents', 'metadatas', 'distances']
+        })
+      }
+
+      if (!results.ids || !results.ids[0]) return []
+
+      const processed: Array<{ id: string; decision: string; context: string; similarity: number }> = []
+      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
+
+        processed.push({
+          id: ids[i],
+          decision: documents[i] || '',
+          context: (metadatas[i] as any)?.context || '',
+          similarity
+        })
+      }
+
+      return processed
+    } catch (error) {
+      this.logger.warn({ error }, 'Failed to find similar contexts for prediction')
+      return []
+    }
+  }
+
+  private groupSimilarDecisions(
+    decisions: Array<{ id: string; decision: string; context: string; similarity: number }>
+  ): Array<Array<{ id: string; decision: string; context: string; similarity: number }>> {
+    const groups: Array<Array<{ id: string; decision: string; context: string; similarity: number }>> = []
+
+    for (const decision of decisions) {
+      let addedToGroup = false
+
+      for (const group of groups) {
+        // Check if this decision is similar to the group leader
+        const leader = group[0]
+        const jaccardSim = this.jaccardSimilarity(
+          leader.decision.toLowerCase(),
+          decision.decision.toLowerCase()
+        )
+
+        if (jaccardSim > 0.4) {
+          group.push(decision)
+          addedToGroup = true
+          break
+        }
+      }
+
+      if (!addedToGroup) {
+        groups.push([decision])
+      }
+    }
+
+    return groups.sort((a, b) => b.length - a.length)
+  }
+
+  private buildPrediction(
+    group: Array<{ id: string; decision: string; context: string; similarity: number }>,
+    queryContext: string
+  ): PredictedDecision {
+    // Use the most similar decision as the prediction
+    const best = group.reduce((a, b) => a.similarity > b.similarity ? a : b)
+
+    // Confidence based on group size + similarity
+    const groupSizeFactor = Math.min(group.length / 3, 1) // Saturates at 3
+    const similarityFactor = best.similarity
+    const confidence = (groupSizeFactor * 0.4) + (similarityFactor * 0.6)
+
+    const basedOn = group.slice(0, 3).map(d => ({
+      id: d.id,
+      decision: d.decision.slice(0, 150),
+      similarity: d.similarity
+    }))
+
+    const reasoning = group.length > 1
+      ? `Based on ${group.length} similar past decisions with avg ${Math.round(group.reduce((s, d) => s + d.similarity, 0) / group.length * 100)}% match`
+      : `Based on a similar past decision with ${Math.round(best.similarity * 100)}% match`
+
+    return {
+      prediction: best.decision,
+      confidence,
+      basedOn,
+      reasoning
+    }
+  }
+
+  private jaccardSimilarity(a: string, b: string): number {
+    const setA = new Set(a.split(/\s+/))
+    const setB = new Set(b.split(/\s+/))
+    const intersection = new Set([...setA].filter(x => setB.has(x)))
+    const union = new Set([...setA, ...setB])
+    return union.size > 0 ? intersection.size / union.size : 0
+  }
+}

package/src/prediction/index.ts

@@ -0,0 +1,13 @@
+/**
+ * Predictive Intelligence Module
+ * Phase 15.3 - Decision prediction, context anticipation, recommendations
+ */
+
+export { DecisionPredictor } from './decision-predictor'
+export type { PredictedDecision } from './decision-predictor'
+
+export { ContextAnticipator } from './context-anticipator'
+export type { AnticipatedContext } from './context-anticipator'
+
+export { Recommender } from './recommender'
+export type { Recommendation, RecommendationResult } from './recommender'

package/src/prediction/recommender.ts

@@ -0,0 +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 }
+    }
+  }
+}