claude-brain 0.17.13 → 0.22.0

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

@@ -1,184 +0,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/reasoning/counterfactual.ts

@@ -1,248 +0,0 @@
-/**
- * Counterfactual Analysis
- * What-if analysis using knowledge graph and decision history
- */
-
-import type { Logger } from 'pino'
-import type { InMemoryKnowledgeGraph } from '@/knowledge/graph/memory-graph'
-import type { CollectionManager } from '@/memory/chroma/collection-manager'
-import type { EmbeddingProvider } from '@/memory/chroma/embeddings'
-
-export interface WhatIfScenario {
-  change: string
-  affectedDecisions: Array<{
-    id: string
-    decision: string
-    impact: 'high' | 'medium' | 'low'
-    reason: string
-  }>
-  affectedTechnologies: string[]
-  riskLevel: 'high' | 'medium' | 'low'
-  summary: string
-}
-
-export class CounterfactualAnalyzer {
-  private logger: Logger
-  private graph: InMemoryKnowledgeGraph | null
-  private collections: CollectionManager
-  private embeddings?: EmbeddingProvider
-
-  constructor(
-    logger: Logger,
-    graph: InMemoryKnowledgeGraph | null,
-    collections: CollectionManager,
-    embeddings?: EmbeddingProvider
-  ) {
-    this.logger = logger.child({ component: 'counterfactual' })
-    this.graph = graph
-    this.collections = collections
-    this.embeddings = embeddings
-  }
-
-  /**
-   * Analyze what would happen if a technology/decision changed
-   */
-  async whatIf(change: string, options: {
-    project?: string
-    maxResults?: number
-  } = {}): Promise<WhatIfScenario> {
-    const { project, maxResults = 20 } = options
-
-    // Find decisions related to the change
-    const relatedDecisions = await this.findRelatedDecisions(change, project, maxResults)
-
-    // Find affected technologies via knowledge graph
-    const affectedTechnologies = this.findAffectedTechnologies(change)
-
-    // Assess impact on each decision
-    const affectedDecisions = relatedDecisions.map(d => ({
-      id: d.id,
-      decision: d.content.slice(0, 200),
-      impact: this.assessImpact(d, change),
-      reason: this.explainImpact(d, change)
-    }))
-
-    // Determine overall risk
-    const riskLevel = this.calculateRisk(affectedDecisions)
-
-    // Build summary
-    const summary = this.buildSummary(change, affectedDecisions, affectedTechnologies, riskLevel)
-
-    return {
-      change,
-      affectedDecisions,
-      affectedTechnologies,
-      riskLevel,
-      summary
-    }
-  }
-
-  private async findRelatedDecisions(
-    change: string,
-    project?: string,
-    limit: number = 20
-  ): Promise<Array<{ id: string; content: string; metadata: Record<string, any>; 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(change)
-        results = await collection.query({
-          queryEmbeddings: [embedding],
-          nResults: limit,
-          where,
-          include: ['documents', 'metadatas', 'distances']
-        })
-      } else {
-        results = await collection.query({
-          queryTexts: [change],
-          nResults: limit,
-          where,
-          include: ['documents', 'metadatas', 'distances']
-        })
-      }
-
-      if (!results.ids || !results.ids[0]) return []
-
-      const processed: Array<{ id: string; content: string; metadata: Record<string, any>; 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.2) continue
-
-        processed.push({
-          id: ids[i],
-          content: documents[i] || '',
-          metadata: metadatas[i] || {},
-          similarity
-        })
-      }
-
-      return processed
-    } catch (error) {
-      this.logger.warn({ error, change }, 'Failed to find related decisions for what-if')
-      return []
-    }
-  }
-
-  private findAffectedTechnologies(change: string): string[] {
-    if (!this.graph) return []
-
-    const technologies: string[] = []
-
-    try {
-      // Find nodes matching the change description
-      const changeWords = change.toLowerCase().split(/\s+/)
-
-      const matchingNodes = this.graph.findNodes({ type: 'technology' })
-        .filter(node => {
-          const name = node.name.toLowerCase()
-          return changeWords.some(w => name.includes(w) || w.includes(name))
-        })
-
-      for (const node of matchingNodes) {
-        technologies.push(node.name)
-
-        // Traverse to find connected technologies
-        const connected = this.graph.traverse(node.id, {
-          maxDepth: 2,
-          nodeTypes: ['technology']
-        })
-
-        for (const connNode of connected) {
-          if (connNode.id !== node.id && !technologies.includes(connNode.name)) {
-            technologies.push(connNode.name)
-          }
-        }
-      }
-    } catch (error) {
-      this.logger.debug({ error }, 'Failed to traverse knowledge graph')
-    }
-
-    return technologies.slice(0, 20)
-  }
-
-  private assessImpact(
-    decision: { content: string; metadata: Record<string, any>; similarity: number },
-    change: string
-  ): 'high' | 'medium' | 'low' {
-    // High similarity = high impact
-    if (decision.similarity > 0.7) return 'high'
-    if (decision.similarity > 0.5) return 'medium'
-
-    // Check if the decision directly references the change topic
-    const changeTerms = change.toLowerCase().split(/\s+/)
-    const content = decision.content.toLowerCase()
-    const directMentions = changeTerms.filter(t => t.length > 3 && content.includes(t)).length
-
-    if (directMentions >= 3) return 'high'
-    if (directMentions >= 1) return 'medium'
-
-    return 'low'
-  }
-
-  private explainImpact(
-    decision: { content: string; metadata: Record<string, any> },
-    _change: string
-  ): string {
-    const reasoning = decision.metadata.reasoning || ''
-    const context = decision.metadata.context || ''
-
-    if (reasoning) {
-      return `This decision was based on: "${reasoning.slice(0, 100)}..." which may need revision.`
-    }
-
-    if (context) {
-      return `Made in context: "${context.slice(0, 100)}..." which would be affected.`
-    }
-
-    return 'This decision may need to be reconsidered.'
-  }
-
-  private calculateRisk(
-    affectedDecisions: Array<{ impact: 'high' | 'medium' | 'low' }>
-  ): 'high' | 'medium' | 'low' {
-    const highCount = affectedDecisions.filter(d => d.impact === 'high').length
-    const medCount = affectedDecisions.filter(d => d.impact === 'medium').length
-
-    if (highCount >= 3) return 'high'
-    if (highCount >= 1 || medCount >= 5) return 'medium'
-    return 'low'
-  }
-
-  private buildSummary(
-    change: string,
-    affectedDecisions: Array<{ impact: string }>,
-    affectedTechnologies: string[],
-    riskLevel: string
-  ): string {
-    const parts: string[] = []
-
-    parts.push(`## What-If Analysis: "${change}"`)
-    parts.push('')
-    parts.push(`**Risk Level:** ${riskLevel.toUpperCase()}`)
-    parts.push(`**Affected Decisions:** ${affectedDecisions.length}`)
-
-    const highImpact = affectedDecisions.filter(d => d.impact === 'high').length
-    const medImpact = affectedDecisions.filter(d => d.impact === 'medium').length
-    const lowImpact = affectedDecisions.filter(d => d.impact === 'low').length
-
-    parts.push(`  - High impact: ${highImpact}`)
-    parts.push(`  - Medium impact: ${medImpact}`)
-    parts.push(`  - Low impact: ${lowImpact}`)
-
-    if (affectedTechnologies.length > 0) {
-      parts.push(`\n**Affected Technologies:** ${affectedTechnologies.join(', ')}`)
-    }
-
-    return parts.join('\n')
-  }
-}

package/src/intelligence/reasoning/synthesizer.ts

@@ -1,167 +0,0 @@
-/**
- * Result Synthesizer
- * Combines multiple retrieved sources into coherent answers using heuristics
- */
-
-import type { Logger } from 'pino'
-import type { ChainResult } from './chain-retrieval'
-
-export interface SynthesizedResult {
-  summary: string
-  sources: Array<{
-    id: string
-    relevance: number
-    excerpt: string
-  }>
-  confidence: number
-  themes: string[]
-}
-
-export class ResultSynthesizer {
-  constructor(_logger: Logger) {
-    // Logger available for future use
-  }
-
-  /**
-   * Synthesize multiple sources into a coherent answer
-   */
-  synthesize(query: string, results: ChainResult[]): SynthesizedResult {
-    if (results.length === 0) {
-      return {
-        summary: 'No relevant information found.',
-        sources: [],
-        confidence: 0,
-        themes: []
-      }
-    }
-
-    // Sort by relevance
-    const sorted = [...results].sort((a, b) => b.similarity - a.similarity)
-
-    // Extract themes
-    const themes = this.extractThemes(sorted)
-
-    // Build summary from top results
-    const summary = this.buildSummary(query, sorted, themes)
-
-    // Calculate confidence based on result quality
-    const confidence = this.calculateConfidence(sorted)
-
-    // Build source list
-    const sources = sorted.slice(0, 10).map(r => ({
-      id: r.id,
-      relevance: r.similarity,
-      excerpt: r.content.slice(0, 200)
-    }))
-
-    return {
-      summary,
-      sources,
-      confidence,
-      themes
-    }
-  }
-
-  private extractThemes(results: ChainResult[]): string[] {
-    const termFreq = new Map<string, number>()
-
-    for (const result of results) {
-      const words = result.content
-        .toLowerCase()
-        .replace(/[^a-z0-9\s]/g, ' ')
-        .split(/\s+/)
-        .filter(w => w.length > 3 && !this.isCommonWord(w))
-
-      const seen = new Set<string>()
-      for (const word of words) {
-        if (seen.has(word)) continue
-        seen.add(word)
-        termFreq.set(word, (termFreq.get(word) || 0) + 1)
-      }
-    }
-
-    // Return terms appearing in multiple results
-    return Array.from(termFreq.entries())
-      .filter(([_, count]) => count >= Math.max(2, results.length * 0.3))
-      .sort((a, b) => b[1] - a[1])
-      .slice(0, 10)
-      .map(([term]) => term)
-  }
-
-  private buildSummary(_query: string, results: ChainResult[], themes: string[]): string {
-    const parts: string[] = []
-
-    // Group by type
-    const decisions = results.filter(r => r.metadata.type === 'decision' || r.metadata.source === 'remember_decision')
-    const patterns = results.filter(r => r.metadata.type === 'pattern' || r.metadata.source === 'recognize_pattern')
-    const corrections = results.filter(r => r.metadata.type === 'correction' || r.metadata.source === 'record_correction')
-    const other = results.filter(r =>
-      !decisions.includes(r) && !patterns.includes(r) && !corrections.includes(r)
-    )
-
-    if (decisions.length > 0) {
-      parts.push(`**Decisions (${decisions.length}):**`)
-      for (const d of decisions.slice(0, 3)) {
-        parts.push(`- ${d.content.slice(0, 150)}`)
-      }
-    }
-
-    if (patterns.length > 0) {
-      parts.push(`\n**Patterns (${patterns.length}):**`)
-      for (const p of patterns.slice(0, 3)) {
-        parts.push(`- ${p.content.slice(0, 150)}`)
-      }
-    }
-
-    if (corrections.length > 0) {
-      parts.push(`\n**Corrections (${corrections.length}):**`)
-      for (const c of corrections.slice(0, 3)) {
-        parts.push(`- ${c.content.slice(0, 150)}`)
-      }
-    }
-
-    if (other.length > 0) {
-      parts.push(`\n**Other (${other.length}):**`)
-      for (const o of other.slice(0, 3)) {
-        parts.push(`- ${o.content.slice(0, 150)}`)
-      }
-    }
-
-    if (themes.length > 0) {
-      parts.push(`\n**Key themes:** ${themes.join(', ')}`)
-    }
-
-    return parts.join('\n')
-  }
-
-  private calculateConfidence(results: ChainResult[]): number {
-    if (results.length === 0) return 0
-
-    // Average similarity of top results
-    const top = results.slice(0, 5)
-    const avgSimilarity = top.reduce((sum, r) => sum + r.similarity, 0) / top.length
-
-    // Factor in number of results
-    const countFactor = Math.min(results.length / 5, 1) // More results = higher confidence, up to 5
-
-    return Math.min(avgSimilarity * countFactor, 1)
-  }
-
-  private isCommonWord(word: string): boolean {
-    const common = new Set([
-      'the', 'and', 'for', 'are', 'but', 'not', 'you', 'all', 'can',
-      'was', 'one', 'our', 'out', 'has', 'had', 'been', 'have', 'with',
-      'this', 'that', 'from', 'they', 'will', 'would', 'there', 'their',
-      'what', 'about', 'which', 'when', 'make', 'like', 'time', 'just',
-      'know', 'take', 'into', 'year', 'your', 'good', 'some', 'could',
-      'them', 'than', 'other', 'then', 'also', 'back', 'after', 'work',
-      'first', 'well', 'even', 'most', 'find', 'here', 'thing', 'many',
-      'should', 'because', 'does', 'each', 'much', 'before', 'must',
-      'through', 'being', 'using', 'used', 'decision', 'decided',
-      'recommend', 'instead', 'project', 'context', 'reasoning', 'pattern',
-      'correction', 'original', 'still', 'between', 'think', 'over',
-      'come', 'only', 'give', 'look', 'people'
-    ])
-    return common.has(word)
-  }
-}