claude-brain 0.14.2 → 0.14.4

package/src/intelligence/prediction/context-anticipator.ts

@@ -1,198 +1,198 @@
-/**
- * Context Anticipator
- * Anticipates what context will be needed based on current activity
- */
-
-import type { Logger } from 'pino'
-import type { CollectionManager } from '@/memory/chroma/collection-manager'
-import type { EmbeddingProvider } from '@/memory/chroma/embeddings'
-
-export interface AnticipatedContext {
-  topic: string
-  relevance: number
-  relatedDecisions: number
-  suggestedQueries: string[]
-}
-
-export class ContextAnticipator {
-  private logger: Logger
-  private collections: CollectionManager
-  private embeddings?: EmbeddingProvider
-  private recentTopics: Array<{ topic: string; timestamp: number }> = []
-
-  constructor(logger: Logger, collections: CollectionManager, embeddings?: EmbeddingProvider) {
-    this.logger = logger.child({ component: 'context-anticipator' })
-    this.collections = collections
-    this.embeddings = embeddings
-  }
-
-  /**
-   * Record a topic being worked on for anticipation
-   */
-  recordActivity(topic: string): void {
-    this.recentTopics.push({ topic, timestamp: Date.now() })
-    // Keep last 50 topics
-    if (this.recentTopics.length > 50) {
-      this.recentTopics = this.recentTopics.slice(-50)
-    }
-  }
-
-  /**
-   * Anticipate what context might be needed next
-   */
-  async anticipate(currentTask: string, options: {
-    project?: string
-    limit?: number
-  } = {}): Promise<AnticipatedContext[]> {
-    const { project, limit = 5 } = options
-
-    // Get patterns of what typically follows similar tasks
-    const followUpTopics = await this.findFollowUpPatterns(currentTask, project)
-
-    // Get related but not-yet-accessed topics
-    const relatedTopics = await this.findRelatedTopics(currentTask, project)
-
-    // Merge and rank
-    const merged = new Map<string, AnticipatedContext>()
-
-    for (const t of followUpTopics) {
-      merged.set(t.topic, t)
-    }
-
-    for (const t of relatedTopics) {
-      if (merged.has(t.topic)) {
-        const existing = merged.get(t.topic)!
-        existing.relevance = Math.max(existing.relevance, t.relevance)
-        existing.relatedDecisions = Math.max(existing.relatedDecisions, t.relatedDecisions)
-      } else {
-        merged.set(t.topic, t)
-      }
-    }
-
-    return Array.from(merged.values())
-      .sort((a, b) => b.relevance - a.relevance)
-      .slice(0, limit)
-  }
-
-  private async findFollowUpPatterns(
-    currentTask: string,
-    project?: string
-  ): Promise<AnticipatedContext[]> {
-    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(currentTask)
-        results = await collection.query({
-          queryEmbeddings: [embedding],
-          nResults: 10,
-          where,
-          include: ['documents', 'metadatas', 'distances']
-        })
-      } else {
-        results = await collection.query({
-          queryTexts: [currentTask],
-          nResults: 10,
-          where,
-          include: ['documents', 'metadatas', 'distances']
-        })
-      }
-
-      if (!results.ids || !results.ids[0]) return []
-
-      // Extract unique topics from the results
-      const topicCounts = new Map<string, { count: number; similarity: number }>()
-      const metadatas = results.metadatas?.[0] || []
-      const distances = results.distances?.[0] || []
-
-      for (let i = 0; i < metadatas.length; i++) {
-        const tags = String((metadatas[i] as any)?.tags || '').split(',').filter((t: string) => t.trim())
-        const similarity = 1 - (distances[i] || 0)
-
-        for (const tag of tags) {
-          const trimmed = tag.trim().toLowerCase()
-          if (!trimmed) continue
-
-          const existing = topicCounts.get(trimmed)
-          if (existing) {
-            existing.count++
-            existing.similarity = Math.max(existing.similarity, similarity)
-          } else {
-            topicCounts.set(trimmed, { count: 1, similarity })
-          }
-        }
-      }
-
-      return Array.from(topicCounts.entries()).map(([topic, data]) => ({
-        topic,
-        relevance: data.similarity * (1 + Math.log(data.count + 1) / 5),
-        relatedDecisions: data.count,
-        suggestedQueries: [`What decisions were made about ${topic}?`, `Show patterns for ${topic}`]
-      }))
-    } catch (error) {
-      this.logger.debug({ error }, 'Failed to find follow-up patterns')
-      return []
-    }
-  }
-
-  private async findRelatedTopics(
-    currentTask: string,
-    project?: string
-  ): Promise<AnticipatedContext[]> {
-    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(currentTask)
-        results = await collection.query({
-          queryEmbeddings: [embedding],
-          nResults: 5,
-          where,
-          include: ['documents', 'metadatas', 'distances']
-        })
-      } else {
-        results = await collection.query({
-          queryTexts: [currentTask],
-          nResults: 5,
-          where,
-          include: ['documents', 'metadatas', 'distances']
-        })
-      }
-
-      if (!results.ids || !results.ids[0]) return []
-
-      const topics: AnticipatedContext[] = []
-      const documents = results.documents?.[0] || []
-      const metadatas = results.metadatas?.[0] || []
-      const distances = results.distances?.[0] || []
-
-      for (let i = 0; i < documents.length; i++) {
-        const similarity = 1 - (distances[i] || 0)
-        if (similarity < 0.3) continue
-
-        const content = (documents[i] || '').slice(0, 100)
-        const patternType = (metadatas[i] as any)?.pattern_type || 'unknown'
-
-        topics.push({
-          topic: `${patternType}: ${content}`,
-          relevance: similarity,
-          relatedDecisions: 1,
-          suggestedQueries: [`Show ${patternType} patterns related to this`]
-        })
-      }
-
-      return topics
-    } catch (error) {
-      this.logger.debug({ error }, 'Failed to find related topics')
-      return []
-    }
-  }
-}
+/**
+ * Context Anticipator
+ * Anticipates what context will be needed based on current activity
+ */
+
+import type { Logger } from 'pino'
+import type { CollectionManager } from '@/memory/chroma/collection-manager'
+import type { EmbeddingProvider } from '@/memory/chroma/embeddings'
+
+export interface AnticipatedContext {
+  topic: string
+  relevance: number
+  relatedDecisions: number
+  suggestedQueries: string[]
+}
+
+export class ContextAnticipator {
+  private logger: Logger
+  private collections: CollectionManager
+  private embeddings?: EmbeddingProvider
+  private recentTopics: Array<{ topic: string; timestamp: number }> = []
+
+  constructor(logger: Logger, collections: CollectionManager, embeddings?: EmbeddingProvider) {
+    this.logger = logger.child({ component: 'context-anticipator' })
+    this.collections = collections
+    this.embeddings = embeddings
+  }
+
+  /**
+   * Record a topic being worked on for anticipation
+   */
+  recordActivity(topic: string): void {
+    this.recentTopics.push({ topic, timestamp: Date.now() })
+    // Keep last 50 topics
+    if (this.recentTopics.length > 50) {
+      this.recentTopics = this.recentTopics.slice(-50)
+    }
+  }
+
+  /**
+   * Anticipate what context might be needed next
+   */
+  async anticipate(currentTask: string, options: {
+    project?: string
+    limit?: number
+  } = {}): Promise<AnticipatedContext[]> {
+    const { project, limit = 5 } = options
+
+    // Get patterns of what typically follows similar tasks
+    const followUpTopics = await this.findFollowUpPatterns(currentTask, project)
+
+    // Get related but not-yet-accessed topics
+    const relatedTopics = await this.findRelatedTopics(currentTask, project)
+
+    // Merge and rank
+    const merged = new Map<string, AnticipatedContext>()
+
+    for (const t of followUpTopics) {
+      merged.set(t.topic, t)
+    }
+
+    for (const t of relatedTopics) {
+      if (merged.has(t.topic)) {
+        const existing = merged.get(t.topic)!
+        existing.relevance = Math.max(existing.relevance, t.relevance)
+        existing.relatedDecisions = Math.max(existing.relatedDecisions, t.relatedDecisions)
+      } else {
+        merged.set(t.topic, t)
+      }
+    }
+
+    return Array.from(merged.values())
+      .sort((a, b) => b.relevance - a.relevance)
+      .slice(0, limit)
+  }
+
+  private async findFollowUpPatterns(
+    currentTask: string,
+    project?: string
+  ): Promise<AnticipatedContext[]> {
+    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(currentTask)
+        results = await collection.query({
+          queryEmbeddings: [embedding],
+          nResults: 10,
+          where,
+          include: ['documents', 'metadatas', 'distances']
+        })
+      } else {
+        results = await collection.query({
+          queryTexts: [currentTask],
+          nResults: 10,
+          where,
+          include: ['documents', 'metadatas', 'distances']
+        })
+      }
+
+      if (!results.ids || !results.ids[0]) return []
+
+      // Extract unique topics from the results
+      const topicCounts = new Map<string, { count: number; similarity: number }>()
+      const metadatas = results.metadatas?.[0] || []
+      const distances = results.distances?.[0] || []
+
+      for (let i = 0; i < metadatas.length; i++) {
+        const tags = String((metadatas[i] as any)?.tags || '').split(',').filter((t: string) => t.trim())
+        const similarity = 1 - (distances[i] || 0)
+
+        for (const tag of tags) {
+          const trimmed = tag.trim().toLowerCase()
+          if (!trimmed) continue
+
+          const existing = topicCounts.get(trimmed)
+          if (existing) {
+            existing.count++
+            existing.similarity = Math.max(existing.similarity, similarity)
+          } else {
+            topicCounts.set(trimmed, { count: 1, similarity })
+          }
+        }
+      }
+
+      return Array.from(topicCounts.entries()).map(([topic, data]) => ({
+        topic,
+        relevance: data.similarity * (1 + Math.log(data.count + 1) / 5),
+        relatedDecisions: data.count,
+        suggestedQueries: [`What decisions were made about ${topic}?`, `Show patterns for ${topic}`]
+      }))
+    } catch (error) {
+      this.logger.debug({ error }, 'Failed to find follow-up patterns')
+      return []
+    }
+  }
+
+  private async findRelatedTopics(
+    currentTask: string,
+    project?: string
+  ): Promise<AnticipatedContext[]> {
+    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(currentTask)
+        results = await collection.query({
+          queryEmbeddings: [embedding],
+          nResults: 5,
+          where,
+          include: ['documents', 'metadatas', 'distances']
+        })
+      } else {
+        results = await collection.query({
+          queryTexts: [currentTask],
+          nResults: 5,
+          where,
+          include: ['documents', 'metadatas', 'distances']
+        })
+      }
+
+      if (!results.ids || !results.ids[0]) return []
+
+      const topics: AnticipatedContext[] = []
+      const documents = results.documents?.[0] || []
+      const metadatas = results.metadatas?.[0] || []
+      const distances = results.distances?.[0] || []
+
+      for (let i = 0; i < documents.length; i++) {
+        const similarity = 1 - (distances[i] || 0)
+        if (similarity < 0.3) continue
+
+        const content = (documents[i] || '').slice(0, 100)
+        const patternType = (metadatas[i] as any)?.pattern_type || 'unknown'
+
+        topics.push({
+          topic: `${patternType}: ${content}`,
+          relevance: similarity,
+          relatedDecisions: 1,
+          suggestedQueries: [`Show ${patternType} patterns related to this`]
+        })
+      }
+
+      return topics
+    } catch (error) {
+      this.logger.debug({ error }, 'Failed to find related topics')
+      return []
+    }
+  }
+}