claude-brain 0.14.2 → 0.14.4

package/src/intelligence/temporal/trends.ts

@@ -1,263 +1,263 @@
-/**
- * Trend Detection
- * Detect technology, pattern, and concern trends across decisions
- */
-
-import type { Logger } from 'pino'
-import type { CollectionManager } from '@/memory/chroma/collection-manager'
-
-export interface TrendItem {
-  term: string
-  occurrences: number
-  firstSeen: string
-  lastSeen: string
-  projects: string[]
-  trend: 'rising' | 'stable' | 'declining'
-  momentum: number // -1 to 1, positive = rising
-}
-
-export interface TrendAnalysis {
-  project?: string
-  period: string
-  topTrends: TrendItem[]
-  emergingTopics: TrendItem[]
-  decliningTopics: TrendItem[]
-  totalDecisionsAnalyzed: number
-}
-
-export class TrendDetector {
-  private logger: Logger
-  private collections: CollectionManager
-
-  // Common stop words to exclude from trend analysis
-  private stopWords = new Set([
-    'the', 'a', 'an', 'is', 'are', 'was', 'were', 'be', 'been', 'being',
-    'have', 'has', 'had', 'do', 'does', 'did', 'will', 'would', 'could',
-    'should', 'may', 'might', 'must', 'shall', 'can', 'need', 'dare',
-    'ought', 'used', 'to', 'of', 'in', 'for', 'on', 'with', 'at', 'by',
-    'from', 'as', 'into', 'through', 'during', 'before', 'after', 'above',
-    'below', 'between', 'out', 'off', 'over', 'under', 'again', 'further',
-    'then', 'once', 'here', 'there', 'when', 'where', 'why', 'how', 'all',
-    'both', 'each', 'few', 'more', 'most', 'other', 'some', 'such', 'no',
-    'nor', 'not', 'only', 'own', 'same', 'so', 'than', 'too', 'very',
-    'just', 'because', 'but', 'and', 'or', 'if', 'while', 'this', 'that',
-    'these', 'those', 'it', 'its', 'we', 'our', 'use', 'using', 'which',
-    'what', 'about', 'also', 'make', 'like', 'well', 'back', 'even',
-    'want', 'give', 'day', 'take', 'come', 'made', 'get', 'set', 'new',
-    'way', 'work', 'project', 'decision', 'decided', 'recommend', 'instead'
-  ])
-
-  constructor(logger: Logger, collections: CollectionManager) {
-    this.logger = logger.child({ component: 'trend-detector' })
-    this.collections = collections
-  }
-
-  /**
-   * Detect trends across decisions
-   */
-  async detectTrends(options: {
-    project?: string
-    periodDays?: number
-    minOccurrences?: number
-    limit?: number
-  } = {}): Promise<TrendAnalysis> {
-    const {
-      project,
-      periodDays = 90,
-      minOccurrences = 2,
-      limit = 20
-    } = options
-
-    // Fetch all decisions within the period
-    const endDate = new Date()
-    const startDate = new Date(endDate)
-    startDate.setDate(startDate.getDate() - periodDays)
-
-    const midDate = new Date(startDate.getTime() + (endDate.getTime() - startDate.getTime()) / 2)
-
-    const allDecisions = await this.fetchAllDecisions(project)
-
-    // Split decisions into two halves for trend detection
-    const firstHalf: Array<{ content: string; date: string; project: string }> = []
-    const secondHalf: Array<{ content: string; date: string; project: string }> = []
-    const withinPeriod: Array<{ content: string; date: string; project: string }> = []
-
-    for (const d of allDecisions) {
-      const date = new Date(d.date)
-      if (date >= startDate && date <= endDate) {
-        withinPeriod.push(d)
-        if (date < midDate) {
-          firstHalf.push(d)
-        } else {
-          secondHalf.push(d)
-        }
-      }
-    }
-
-    // Extract terms from each half
-    const firstTerms = this.extractTermFrequency(firstHalf)
-    const secondTerms = this.extractTermFrequency(secondHalf)
-    const allTerms = this.extractTermFrequency(withinPeriod)
-
-    // Build trend items
-    const trendItems: TrendItem[] = []
-    const allTermKeys = new Set([...firstTerms.keys(), ...secondTerms.keys()])
-
-    for (const term of allTermKeys) {
-      const total = allTerms.get(term)
-      if (!total || total.count < minOccurrences) continue
-
-      const firstCount = firstTerms.get(term)?.count || 0
-      const secondCount = secondTerms.get(term)?.count || 0
-
-      // Calculate momentum
-      const totalCount = firstCount + secondCount
-      const momentum = totalCount > 0 ? (secondCount - firstCount) / totalCount : 0
-
-      let trend: 'rising' | 'stable' | 'declining'
-      if (momentum > 0.2) trend = 'rising'
-      else if (momentum < -0.2) trend = 'declining'
-      else trend = 'stable'
-
-      trendItems.push({
-        term,
-        occurrences: total.count,
-        firstSeen: total.firstSeen,
-        lastSeen: total.lastSeen,
-        projects: total.projects,
-        trend,
-        momentum
-      })
-    }
-
-    // Sort by occurrences
-    trendItems.sort((a, b) => b.occurrences - a.occurrences)
-
-    const topTrends = trendItems.slice(0, limit)
-    const emergingTopics = trendItems
-      .filter(t => t.trend === 'rising')
-      .sort((a, b) => b.momentum - a.momentum)
-      .slice(0, limit)
-    const decliningTopics = trendItems
-      .filter(t => t.trend === 'declining')
-      .sort((a, b) => a.momentum - b.momentum)
-      .slice(0, limit)
-
-    return {
-      project,
-      period: `${periodDays} days`,
-      topTrends,
-      emergingTopics,
-      decliningTopics,
-      totalDecisionsAnalyzed: withinPeriod.length
-    }
-  }
-
-  private async fetchAllDecisions(project?: string): Promise<Array<{
-    content: string
-    date: string
-    project: string
-  }>> {
-    try {
-      const collection = await this.collections.getDecisions()
-
-      const where: any = project ? { project: { $eq: project } } : undefined
-
-      const results = await collection.get({
-        where,
-        include: ['documents', 'metadatas']
-      })
-
-      return results.ids.map((_, i) => ({
-        content: (results.documents![i] as string) || '',
-        date: (results.metadatas![i] as any)?.created_at || new Date().toISOString(),
-        project: (results.metadatas![i] as any)?.project || ''
-      }))
-    } catch (error) {
-      this.logger.warn({ error }, 'Failed to fetch decisions for trend analysis')
-      return []
-    }
-  }
-
-  private extractTermFrequency(
-    items: Array<{ content: string; date: string; project: string }>
-  ): Map<string, { count: number; firstSeen: string; lastSeen: string; projects: string[] }> {
-    const terms = new Map<string, { count: number; firstSeen: string; lastSeen: string; projects: Set<string> }>()
-
-    for (const item of items) {
-      const words = this.tokenize(item.content)
-
-      // Extract meaningful terms (bigrams + unigrams)
-      const seen = new Set<string>()
-
-      for (let i = 0; i < words.length; i++) {
-        const word = words[i]
-        if (word.length < 3 || this.stopWords.has(word)) continue
-
-        if (!seen.has(word)) {
-          seen.add(word)
-          const existing = terms.get(word)
-          if (existing) {
-            existing.count++
-            if (item.date < existing.firstSeen) existing.firstSeen = item.date
-            if (item.date > existing.lastSeen) existing.lastSeen = item.date
-            existing.projects.add(item.project)
-          } else {
-            terms.set(word, {
-              count: 1,
-              firstSeen: item.date,
-              lastSeen: item.date,
-              projects: new Set([item.project])
-            })
-          }
-        }
-
-        // Bigrams
-        if (i < words.length - 1) {
-          const next = words[i + 1]
-          if (next.length >= 3 && !this.stopWords.has(next)) {
-            const bigram = `${word} ${next}`
-            if (!seen.has(bigram)) {
-              seen.add(bigram)
-              const existing = terms.get(bigram)
-              if (existing) {
-                existing.count++
-                if (item.date < existing.firstSeen) existing.firstSeen = item.date
-                if (item.date > existing.lastSeen) existing.lastSeen = item.date
-                existing.projects.add(item.project)
-              } else {
-                terms.set(bigram, {
-                  count: 1,
-                  firstSeen: item.date,
-                  lastSeen: item.date,
-                  projects: new Set([item.project])
-                })
-              }
-            }
-          }
-        }
-      }
-    }
-
-    // Convert to output format
-    const result = new Map<string, { count: number; firstSeen: string; lastSeen: string; projects: string[] }>()
-    for (const [term, data] of terms) {
-      result.set(term, {
-        count: data.count,
-        firstSeen: data.firstSeen,
-        lastSeen: data.lastSeen,
-        projects: Array.from(data.projects)
-      })
-    }
-
-    return result
-  }
-
-  private tokenize(text: string): string[] {
-    return text
-      .toLowerCase()
-      .replace(/[^a-z0-9\s-]/g, ' ')
-      .split(/\s+/)
-      .filter(w => w.length > 0)
-  }
-}
+/**
+ * Trend Detection
+ * Detect technology, pattern, and concern trends across decisions
+ */
+
+import type { Logger } from 'pino'
+import type { CollectionManager } from '@/memory/chroma/collection-manager'
+
+export interface TrendItem {
+  term: string
+  occurrences: number
+  firstSeen: string
+  lastSeen: string
+  projects: string[]
+  trend: 'rising' | 'stable' | 'declining'
+  momentum: number // -1 to 1, positive = rising
+}
+
+export interface TrendAnalysis {
+  project?: string
+  period: string
+  topTrends: TrendItem[]
+  emergingTopics: TrendItem[]
+  decliningTopics: TrendItem[]
+  totalDecisionsAnalyzed: number
+}
+
+export class TrendDetector {
+  private logger: Logger
+  private collections: CollectionManager
+
+  // Common stop words to exclude from trend analysis
+  private stopWords = new Set([
+    'the', 'a', 'an', 'is', 'are', 'was', 'were', 'be', 'been', 'being',
+    'have', 'has', 'had', 'do', 'does', 'did', 'will', 'would', 'could',
+    'should', 'may', 'might', 'must', 'shall', 'can', 'need', 'dare',
+    'ought', 'used', 'to', 'of', 'in', 'for', 'on', 'with', 'at', 'by',
+    'from', 'as', 'into', 'through', 'during', 'before', 'after', 'above',
+    'below', 'between', 'out', 'off', 'over', 'under', 'again', 'further',
+    'then', 'once', 'here', 'there', 'when', 'where', 'why', 'how', 'all',
+    'both', 'each', 'few', 'more', 'most', 'other', 'some', 'such', 'no',
+    'nor', 'not', 'only', 'own', 'same', 'so', 'than', 'too', 'very',
+    'just', 'because', 'but', 'and', 'or', 'if', 'while', 'this', 'that',
+    'these', 'those', 'it', 'its', 'we', 'our', 'use', 'using', 'which',
+    'what', 'about', 'also', 'make', 'like', 'well', 'back', 'even',
+    'want', 'give', 'day', 'take', 'come', 'made', 'get', 'set', 'new',
+    'way', 'work', 'project', 'decision', 'decided', 'recommend', 'instead'
+  ])
+
+  constructor(logger: Logger, collections: CollectionManager) {
+    this.logger = logger.child({ component: 'trend-detector' })
+    this.collections = collections
+  }
+
+  /**
+   * Detect trends across decisions
+   */
+  async detectTrends(options: {
+    project?: string
+    periodDays?: number
+    minOccurrences?: number
+    limit?: number
+  } = {}): Promise<TrendAnalysis> {
+    const {
+      project,
+      periodDays = 90,
+      minOccurrences = 2,
+      limit = 20
+    } = options
+
+    // Fetch all decisions within the period
+    const endDate = new Date()
+    const startDate = new Date(endDate)
+    startDate.setDate(startDate.getDate() - periodDays)
+
+    const midDate = new Date(startDate.getTime() + (endDate.getTime() - startDate.getTime()) / 2)
+
+    const allDecisions = await this.fetchAllDecisions(project)
+
+    // Split decisions into two halves for trend detection
+    const firstHalf: Array<{ content: string; date: string; project: string }> = []
+    const secondHalf: Array<{ content: string; date: string; project: string }> = []
+    const withinPeriod: Array<{ content: string; date: string; project: string }> = []
+
+    for (const d of allDecisions) {
+      const date = new Date(d.date)
+      if (date >= startDate && date <= endDate) {
+        withinPeriod.push(d)
+        if (date < midDate) {
+          firstHalf.push(d)
+        } else {
+          secondHalf.push(d)
+        }
+      }
+    }
+
+    // Extract terms from each half
+    const firstTerms = this.extractTermFrequency(firstHalf)
+    const secondTerms = this.extractTermFrequency(secondHalf)
+    const allTerms = this.extractTermFrequency(withinPeriod)
+
+    // Build trend items
+    const trendItems: TrendItem[] = []
+    const allTermKeys = new Set([...firstTerms.keys(), ...secondTerms.keys()])
+
+    for (const term of allTermKeys) {
+      const total = allTerms.get(term)
+      if (!total || total.count < minOccurrences) continue
+
+      const firstCount = firstTerms.get(term)?.count || 0
+      const secondCount = secondTerms.get(term)?.count || 0
+
+      // Calculate momentum
+      const totalCount = firstCount + secondCount
+      const momentum = totalCount > 0 ? (secondCount - firstCount) / totalCount : 0
+
+      let trend: 'rising' | 'stable' | 'declining'
+      if (momentum > 0.2) trend = 'rising'
+      else if (momentum < -0.2) trend = 'declining'
+      else trend = 'stable'
+
+      trendItems.push({
+        term,
+        occurrences: total.count,
+        firstSeen: total.firstSeen,
+        lastSeen: total.lastSeen,
+        projects: total.projects,
+        trend,
+        momentum
+      })
+    }
+
+    // Sort by occurrences
+    trendItems.sort((a, b) => b.occurrences - a.occurrences)
+
+    const topTrends = trendItems.slice(0, limit)
+    const emergingTopics = trendItems
+      .filter(t => t.trend === 'rising')
+      .sort((a, b) => b.momentum - a.momentum)
+      .slice(0, limit)
+    const decliningTopics = trendItems
+      .filter(t => t.trend === 'declining')
+      .sort((a, b) => a.momentum - b.momentum)
+      .slice(0, limit)
+
+    return {
+      project,
+      period: `${periodDays} days`,
+      topTrends,
+      emergingTopics,
+      decliningTopics,
+      totalDecisionsAnalyzed: withinPeriod.length
+    }
+  }
+
+  private async fetchAllDecisions(project?: string): Promise<Array<{
+    content: string
+    date: string
+    project: string
+  }>> {
+    try {
+      const collection = await this.collections.getDecisions()
+
+      const where: any = project ? { project: { $eq: project } } : undefined
+
+      const results = await collection.get({
+        where,
+        include: ['documents', 'metadatas']
+      })
+
+      return results.ids.map((_, i) => ({
+        content: (results.documents![i] as string) || '',
+        date: (results.metadatas![i] as any)?.created_at || new Date().toISOString(),
+        project: (results.metadatas![i] as any)?.project || ''
+      }))
+    } catch (error) {
+      this.logger.warn({ error }, 'Failed to fetch decisions for trend analysis')
+      return []
+    }
+  }
+
+  private extractTermFrequency(
+    items: Array<{ content: string; date: string; project: string }>
+  ): Map<string, { count: number; firstSeen: string; lastSeen: string; projects: string[] }> {
+    const terms = new Map<string, { count: number; firstSeen: string; lastSeen: string; projects: Set<string> }>()
+
+    for (const item of items) {
+      const words = this.tokenize(item.content)
+
+      // Extract meaningful terms (bigrams + unigrams)
+      const seen = new Set<string>()
+
+      for (let i = 0; i < words.length; i++) {
+        const word = words[i]
+        if (word.length < 3 || this.stopWords.has(word)) continue
+
+        if (!seen.has(word)) {
+          seen.add(word)
+          const existing = terms.get(word)
+          if (existing) {
+            existing.count++
+            if (item.date < existing.firstSeen) existing.firstSeen = item.date
+            if (item.date > existing.lastSeen) existing.lastSeen = item.date
+            existing.projects.add(item.project)
+          } else {
+            terms.set(word, {
+              count: 1,
+              firstSeen: item.date,
+              lastSeen: item.date,
+              projects: new Set([item.project])
+            })
+          }
+        }
+
+        // Bigrams
+        if (i < words.length - 1) {
+          const next = words[i + 1]
+          if (next.length >= 3 && !this.stopWords.has(next)) {
+            const bigram = `${word} ${next}`
+            if (!seen.has(bigram)) {
+              seen.add(bigram)
+              const existing = terms.get(bigram)
+              if (existing) {
+                existing.count++
+                if (item.date < existing.firstSeen) existing.firstSeen = item.date
+                if (item.date > existing.lastSeen) existing.lastSeen = item.date
+                existing.projects.add(item.project)
+              } else {
+                terms.set(bigram, {
+                  count: 1,
+                  firstSeen: item.date,
+                  lastSeen: item.date,
+                  projects: new Set([item.project])
+                })
+              }
+            }
+          }
+        }
+      }
+    }
+
+    // Convert to output format
+    const result = new Map<string, { count: number; firstSeen: string; lastSeen: string; projects: string[] }>()
+    for (const [term, data] of terms) {
+      result.set(term, {
+        count: data.count,
+        firstSeen: data.firstSeen,
+        lastSeen: data.lastSeen,
+        projects: Array.from(data.projects)
+      })
+    }
+
+    return result
+  }
+
+  private tokenize(text: string): string[] {
+    return text
+      .toLowerCase()
+      .replace(/[^a-z0-9\s-]/g, ' ')
+      .split(/\s+/)
+      .filter(w => w.length > 0)
+  }
+}