claude-brain 0.14.2 → 0.14.4

package/src/intelligence/reasoning/counterfactual.ts

@@ -1,248 +1,248 @@
-/**
- * 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')
-  }
-}
+/**
+ * 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/index.ts

@@ -1,13 +1,13 @@
-/**
- * Multi-Hop Reasoning Module
- * Phase 15.2 - Chain retrieval, result synthesis, counterfactual analysis
- */
-
-export { ChainRetrieval } from './chain-retrieval'
-export type { ChainStep, ChainResult, ChainRetrievalResult } from './chain-retrieval'
-
-export { ResultSynthesizer } from './synthesizer'
-export type { SynthesizedResult } from './synthesizer'
-
-export { CounterfactualAnalyzer } from './counterfactual'
-export type { WhatIfScenario } from './counterfactual'
+/**
+ * Multi-Hop Reasoning Module
+ * Phase 15.2 - Chain retrieval, result synthesis, counterfactual analysis
+ */
+
+export { ChainRetrieval } from './chain-retrieval'
+export type { ChainStep, ChainResult, ChainRetrievalResult } from './chain-retrieval'
+
+export { ResultSynthesizer } from './synthesizer'
+export type { SynthesizedResult } from './synthesizer'
+
+export { CounterfactualAnalyzer } from './counterfactual'
+export type { WhatIfScenario } from './counterfactual'