claude-brain 0.14.2 → 0.14.4

package/src/intelligence/prediction/decision-predictor.ts

@@ -1,184 +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
-  }
-}
+/**
+ * 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/intelligence/prediction/index.ts

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