claude-brain 0.30.2 → 0.30.3

package/src/intelligence/temporal/evolution.ts

@@ -1,197 +1,193 @@
-/**
- * Decision Evolution Tracker
- * Tracks how decisions change over time per topic
- */
-
-import type { Logger } from 'pino'
-import type { CollectionManager } from '@/memory/chroma/collection-manager'
-import type { EmbeddingProvider } from '@/memory/chroma/embeddings'
-
-export interface EvolutionEntry {
-  id: string
-  date: string
-  decision: string
-  reasoning: string
-  context: string
-  tags: string[]
-}
-
-export interface EvolutionAnalysis {
-  topic: string
-  project?: string
-  totalDecisions: number
-  timeline: EvolutionEntry[]
-  changes: EvolutionChange[]
-  currentState: string
-  stability: 'stable' | 'evolving' | 'volatile'
-}
-
-export interface EvolutionChange {
-  from: EvolutionEntry
-  to: EvolutionEntry
-  daysBetween: number
-  summary: string
-}
-
-export class DecisionEvolutionTracker {
-  private logger: Logger
-  private collections: CollectionManager
-  private embeddings?: EmbeddingProvider
-
-  constructor(logger: Logger, collections: CollectionManager, embeddings?: EmbeddingProvider) {
-    this.logger = logger.child({ component: 'decision-evolution' })
-    this.collections = collections
-    this.embeddings = embeddings
-  }
-
-  /**
-   * Analyze how decisions on a topic have evolved over time
-   */
-  async analyzeEvolution(topic: string, options: {
-    project?: string
-    limit?: number
-  } = {}): Promise<EvolutionAnalysis> {
-    const { project, limit = 20 } = options
-
-    // Find all decisions related to this topic
-    const decisions = await this.findRelatedDecisions(topic, project, limit)
-
-    // Sort chronologically
-    decisions.sort((a, b) => new Date(a.date).getTime() - new Date(b.date).getTime())
-
-    // Detect changes between consecutive decisions
-    const changes = this.detectChanges(decisions)
-
-    // Determine stability
-    const stability = this.assessStability(decisions, changes)
-
-    // Current state is the most recent decision
-    const currentState = decisions.length > 0
-      ? decisions[decisions.length - 1]!.decision
-      : 'No decisions found for this topic'
-
-    return {
-      topic,
-      project,
-      totalDecisions: decisions.length,
-      timeline: decisions,
-      changes,
-      currentState,
-      stability
-    }
-  }
-
-  private async findRelatedDecisions(
-    topic: string,
-    project?: string,
-    limit: number = 20
-  ): Promise<EvolutionEntry[]> {
-    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(topic)
-        results = await collection.query({
-          queryEmbeddings: [embedding],
-          nResults: limit,
-          where,
-          include: ['documents', 'metadatas', 'distances']
-        })
-      } else {
-        results = await collection.query({
-          queryTexts: [topic],
-          nResults: limit,
-          where,
-          include: ['documents', 'metadatas', 'distances']
-        })
-      }
-
-      if (!results.ids || !results.ids[0]) return []
-
-      const entries: EvolutionEntry[] = []
-      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)
-        // Only include reasonably relevant results
-        if (similarity < 0.3) continue
-
-        const meta = metadatas[i] || {}
-        entries.push({
-          id: ids[i],
-          date: meta.created_at || new Date().toISOString(),
-          decision: documents[i] || '',
-          reasoning: meta.reasoning || '',
-          context: meta.context || '',
-          tags: (meta.tags || '').split(',').filter((t: string) => t)
-        })
-      }
-
-      return entries
-    } catch (error) {
-      this.logger.warn({ error, topic }, 'Failed to find related decisions')
-      return []
-    }
-  }
-
-  private detectChanges(entries: EvolutionEntry[]): EvolutionChange[] {
-    const changes: EvolutionChange[] = []
-
-    for (let i = 1; i < entries.length; i++) {
-      const prev = entries[i - 1]!
-      const curr = entries[i]!
-
-      const daysBetween = Math.round(
-        (new Date(curr.date).getTime() - new Date(prev.date).getTime()) / (1000 * 60 * 60 * 24)
-      )
-
-      // Simple heuristic: if decisions differ substantially, it's a change
-      const prevWords = new Set(prev.decision.toLowerCase().split(/\s+/))
-      const currWords = new Set(curr.decision.toLowerCase().split(/\s+/))
-
-      const intersection = new Set([...prevWords].filter(w => currWords.has(w)))
-      const union = new Set([...prevWords, ...currWords])
-      const jaccard = union.size > 0 ? intersection.size / union.size : 1
-
-      // If less than 60% overlap, consider it a meaningful change
-      if (jaccard < 0.6) {
-        const summary = this.summarizeChange(prev!, curr!)
-        changes.push({
-          from: prev!,
-          to: curr!,
-          daysBetween,
-          summary
-        })
-      }
-    }
-
-    return changes
-  }
-
-  private summarizeChange(from: EvolutionEntry, to: EvolutionEntry): string {
-    const fromDate = new Date(from.date).toLocaleDateString()
-    const toDate = new Date(to.date).toLocaleDateString()
-
-    return `Changed from "${from.decision.slice(0, 80)}..." to "${to.decision.slice(0, 80)}..." (${fromDate} -> ${toDate})`
-  }
-
-  private assessStability(
-    entries: EvolutionEntry[],
-    changes: EvolutionChange[]
-  ): 'stable' | 'evolving' | 'volatile' {
-    if (entries.length <= 1) return 'stable'
-
-    const changeRatio = changes.length / (entries.length - 1)
-
-    if (changeRatio <= 0.2) return 'stable'
-    if (changeRatio <= 0.5) return 'evolving'
-    return 'volatile'
-  }
-}
+/**
+ * Decision Evolution Tracker
+ * Tracks how decisions change over time per topic
+ */
+
+import type { Where } from 'chromadb'
+import type { Logger } from 'pino'
+import type { CollectionManager } from '@/memory/chroma/collection-manager'
+import type { EmbeddingProvider } from '@/memory/chroma/embeddings'
+
+export interface EvolutionEntry {
+  id: string
+  date: string
+  decision: string
+  reasoning: string
+  context: string
+  tags: string[]
+}
+
+export interface EvolutionAnalysis {
+  topic: string
+  project?: string
+  totalDecisions: number
+  timeline: EvolutionEntry[]
+  changes: EvolutionChange[]
+  currentState: string
+  stability: 'stable' | 'evolving' | 'volatile'
+}
+
+export interface EvolutionChange {
+  from: EvolutionEntry
+  to: EvolutionEntry
+  daysBetween: number
+  summary: string
+}
+
+export class DecisionEvolutionTracker {
+  private logger: Logger
+  private collections: CollectionManager
+  private embeddings?: EmbeddingProvider
+
+  constructor(logger: Logger, collections: CollectionManager, embeddings?: EmbeddingProvider) {
+    this.logger = logger.child({ component: 'decision-evolution' })
+    this.collections = collections
+    this.embeddings = embeddings
+  }
+
+  /**
+   * Analyze how decisions on a topic have evolved over time
+   */
+  async analyzeEvolution(topic: string, options: {
+    project?: string
+    limit?: number
+  } = {}): Promise<EvolutionAnalysis> {
+    const { project, limit = 20 } = options
+
+    // Find all decisions related to this topic
+    const decisions = await this.findRelatedDecisions(topic, project, limit)
+
+    // Sort chronologically
+    decisions.sort((a, b) => new Date(a.date).getTime() - new Date(b.date).getTime())
+
+    // Detect changes between consecutive decisions
+    const changes = this.detectChanges(decisions)
+
+    // Determine stability
+    const stability = this.assessStability(decisions, changes)
+
+    // Current state is the most recent decision
+    const currentState = decisions.length > 0
+      ? decisions[decisions.length - 1]!.decision
+      : 'No decisions found for this topic'
+
+    return {
+      topic,
+      project,
+      totalDecisions: decisions.length,
+      timeline: decisions,
+      changes,
+      currentState,
+      stability
+    }
+  }
+
+  private async findRelatedDecisions(
+    topic: string,
+    project?: string,
+    limit: number = 20
+  ): Promise<EvolutionEntry[]> {
+    try {
+      const collection = await this.collections.getDecisions()
+
+      const where: Where | undefined = project ? { project: { $eq: project } } as Where : undefined
+
+      const results = this.embeddings
+        ? await collection.query({
+            queryEmbeddings: [await this.embeddings.generate(topic)],
+            nResults: limit,
+            where,
+            include: ['documents', 'metadatas', 'distances']
+          })
+        : await collection.query({
+            queryTexts: [topic],
+            nResults: limit,
+            where,
+            include: ['documents', 'metadatas', 'distances']
+          })
+
+      if (!results.ids || !results.ids[0]) return []
+
+      const entries: EvolutionEntry[] = []
+      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)
+        // Only include reasonably relevant results
+        if (similarity < 0.3) continue
+
+        const meta = metadatas[i] || {}
+        entries.push({
+          id: ids[i]!,
+          date: (meta.created_at as string) || new Date().toISOString(),
+          decision: (documents[i] as string) || '',
+          reasoning: (meta.reasoning as string) || '',
+          context: (meta.context as string) || '',
+          tags: String(meta.tags || '').split(',').filter((t: string) => t)
+        })
+      }
+
+      return entries
+    } catch (error) {
+      this.logger.warn({ error, topic }, 'Failed to find related decisions')
+      return []
+    }
+  }
+
+  private detectChanges(entries: EvolutionEntry[]): EvolutionChange[] {
+    const changes: EvolutionChange[] = []
+
+    for (let i = 1; i < entries.length; i++) {
+      const prev = entries[i - 1]!
+      const curr = entries[i]!
+
+      const daysBetween = Math.round(
+        (new Date(curr.date).getTime() - new Date(prev.date).getTime()) / (1000 * 60 * 60 * 24)
+      )
+
+      // Simple heuristic: if decisions differ substantially, it's a change
+      const prevWords = new Set(prev.decision.toLowerCase().split(/\s+/))
+      const currWords = new Set(curr.decision.toLowerCase().split(/\s+/))
+
+      const intersection = new Set([...prevWords].filter(w => currWords.has(w)))
+      const union = new Set([...prevWords, ...currWords])
+      const jaccard = union.size > 0 ? intersection.size / union.size : 1
+
+      // If less than 60% overlap, consider it a meaningful change
+      if (jaccard < 0.6) {
+        const summary = this.summarizeChange(prev!, curr!)
+        changes.push({
+          from: prev!,
+          to: curr!,
+          daysBetween,
+          summary
+        })
+      }
+    }
+
+    return changes
+  }
+
+  private summarizeChange(from: EvolutionEntry, to: EvolutionEntry): string {
+    const fromDate = new Date(from.date).toLocaleDateString()
+    const toDate = new Date(to.date).toLocaleDateString()
+
+    return `Changed from "${from.decision.slice(0, 80)}..." to "${to.decision.slice(0, 80)}..." (${fromDate} -> ${toDate})`
+  }
+
+  private assessStability(
+    entries: EvolutionEntry[],
+    changes: EvolutionChange[]
+  ): 'stable' | 'evolving' | 'volatile' {
+    if (entries.length <= 1) return 'stable'
+
+    const changeRatio = changes.length / (entries.length - 1)
+
+    if (changeRatio <= 0.2) return 'stable'
+    if (changeRatio <= 0.5) return 'evolving'
+    return 'volatile'
+  }
+}

package/src/intelligence/temporal/index.ts

@@ -1,16 +1,16 @@
-/**
- * Temporal Intelligence Module
- * Phase 15.1 - Timeline construction, temporal queries, evolution tracking, trend detection
- */
-
-export { TimelineBuilder } from './timeline'
-export type { TimelineEntry, Timeline } from './timeline'
-
-export { TemporalQueryProcessor } from './query-processor'
-export type { TemporalQuery } from './query-processor'
-
-export { DecisionEvolutionTracker } from './evolution'
-export type { EvolutionAnalysis, EvolutionChange, EvolutionEntry } from './evolution'
-
-export { TrendDetector } from './trends'
-export type { TrendAnalysis, TrendItem } from './trends'
+/**
+ * Temporal Intelligence Module
+ * Phase 15.1 - Timeline construction, temporal queries, evolution tracking, trend detection
+ */
+
+export { TimelineBuilder } from './timeline'
+export type { TimelineEntry, Timeline } from './timeline'
+
+export { TemporalQueryProcessor } from './query-processor'
+export type { TemporalQuery } from './query-processor'
+
+export { DecisionEvolutionTracker } from './evolution'
+export type { EvolutionAnalysis, EvolutionChange, EvolutionEntry } from './evolution'
+
+export { TrendDetector } from './trends'
+export type { TrendAnalysis, TrendItem } from './trends'