claude-brain 0.14.2 → 0.14.4

package/src/intelligence/optimization/precompute.ts

@@ -1,202 +1,202 @@
-/**
- * Precomputation Engine
- * Precomputes common queries and project statistics on startup
- */
-
-import type { Logger } from 'pino'
-import type { CollectionManager } from '@/memory/chroma/collection-manager'
-import type { SemanticCache } from './semantic-cache'
-
-export interface PrecomputedStats {
-  projectStats: Map<string, ProjectStats>
-  lastUpdated: string
-}
-
-export interface ProjectStats {
-  project: string
-  decisionCount: number
-  patternCount: number
-  correctionCount: number
-  lastActivity: string
-  topTags: string[]
-}
-
-export class PrecomputeEngine {
-  private logger: Logger
-  private collections: CollectionManager
-  private cache: SemanticCache
-  private stats: PrecomputedStats | null = null
-  private refreshInterval: ReturnType<typeof setInterval> | null = null
-
-  constructor(logger: Logger, collections: CollectionManager, cache: SemanticCache) {
-    this.logger = logger.child({ component: 'precompute' })
-    this.collections = collections
-    this.cache = cache
-  }
-
-  /**
-   * Initialize precomputation (called on startup)
-   */
-  async initialize(): Promise<void> {
-    try {
-      await this.refresh()
-      this.logger.info('Precomputation initialized')
-    } catch (error) {
-      this.logger.warn({ error }, 'Failed to initialize precomputation')
-    }
-  }
-
-  /**
-   * Start periodic refresh of precomputed data
-   */
-  startAutoRefresh(intervalMs: number = 5 * 60 * 1000): void {
-    this.stopAutoRefresh()
-    this.refreshInterval = setInterval(async () => {
-      try {
-        await this.refresh()
-      } catch (error) {
-        this.logger.debug({ error }, 'Auto-refresh failed')
-      }
-    }, intervalMs)
-  }
-
-  /**
-   * Stop periodic refresh
-   */
-  stopAutoRefresh(): void {
-    if (this.refreshInterval) {
-      clearInterval(this.refreshInterval)
-      this.refreshInterval = null
-    }
-  }
-
-  /**
-   * Refresh precomputed data
-   */
-  async refresh(): Promise<void> {
-    const projectStats = new Map<string, ProjectStats>()
-
-    // Get decision counts by project
-    try {
-      const decisionsCollection = await this.collections.getDecisions()
-      const decisions = await decisionsCollection.get({
-        include: ['metadatas']
-      })
-
-      const projectDecisions = new Map<string, Array<Record<string, any>>>()
-
-      for (let i = 0; i < decisions.ids.length; i++) {
-        const meta = decisions.metadatas![i] as Record<string, any>
-        const project = meta?.project || 'unknown'
-
-        if (!projectDecisions.has(project)) projectDecisions.set(project, [])
-        projectDecisions.get(project)!.push(meta)
-      }
-
-      for (const [project, metas] of projectDecisions) {
-        const stats = projectStats.get(project) || {
-          project,
-          decisionCount: 0,
-          patternCount: 0,
-          correctionCount: 0,
-          lastActivity: '',
-          topTags: []
-        }
-
-        stats.decisionCount = metas.length
-
-        // Find last activity
-        const dates = metas
-          .map(m => m?.created_at || '')
-          .filter(d => d)
-          .sort()
-
-        if (dates.length > 0) {
-          stats.lastActivity = dates[dates.length - 1]
-        }
-
-        // Extract top tags
-        const tagCounts = new Map<string, number>()
-        for (const meta of metas) {
-          const tags = String(meta?.tags || '').split(',').filter(t => t.trim())
-          for (const tag of tags) {
-            tagCounts.set(tag.trim(), (tagCounts.get(tag.trim()) || 0) + 1)
-          }
-        }
-        stats.topTags = Array.from(tagCounts.entries())
-          .sort((a, b) => b[1] - a[1])
-          .slice(0, 10)
-          .map(([tag]) => tag)
-
-        projectStats.set(project, stats)
-      }
-    } catch (error) {
-      this.logger.debug({ error }, 'Failed to precompute decision stats')
-    }
-
-    // Get pattern counts
-    try {
-      const patternsCollection = await this.collections.getPatterns()
-      const patterns = await patternsCollection.get({
-        include: ['metadatas']
-      })
-
-      for (let i = 0; i < patterns.ids.length; i++) {
-        const project = (patterns.metadatas![i] as any)?.project || 'unknown'
-        const stats = projectStats.get(project)
-        if (stats) {
-          stats.patternCount++
-        }
-      }
-    } catch (error) {
-      this.logger.debug({ error }, 'Failed to precompute pattern stats')
-    }
-
-    // Get correction counts
-    try {
-      const correctionsCollection = await this.collections.getCorrections()
-      const corrections = await correctionsCollection.get({
-        include: ['metadatas']
-      })
-
-      for (let i = 0; i < corrections.ids.length; i++) {
-        const project = (corrections.metadatas![i] as any)?.project || 'unknown'
-        const stats = projectStats.get(project)
-        if (stats) {
-          stats.correctionCount++
-        }
-      }
-    } catch (error) {
-      this.logger.debug({ error }, 'Failed to precompute correction stats')
-    }
-
-    this.stats = {
-      projectStats,
-      lastUpdated: new Date().toISOString()
-    }
-
-    // Cache project stats
-    for (const [project, stats] of projectStats) {
-      await this.cache.set(`project_stats:${project}`, stats)
-    }
-
-    this.logger.debug(
-      { projects: projectStats.size },
-      'Precomputation complete'
-    )
-  }
-
-  /**
-   * Get precomputed project stats
-   */
-  getProjectStats(project: string): ProjectStats | undefined {
-    return this.stats?.projectStats.get(project)
-  }
-
-  /**
-   * Get all precomputed stats
-   */
-  getAllStats(): PrecomputedStats | null {
-    return this.stats
-  }
-}
+/**
+ * Precomputation Engine
+ * Precomputes common queries and project statistics on startup
+ */
+
+import type { Logger } from 'pino'
+import type { CollectionManager } from '@/memory/chroma/collection-manager'
+import type { SemanticCache } from './semantic-cache'
+
+export interface PrecomputedStats {
+  projectStats: Map<string, ProjectStats>
+  lastUpdated: string
+}
+
+export interface ProjectStats {
+  project: string
+  decisionCount: number
+  patternCount: number
+  correctionCount: number
+  lastActivity: string
+  topTags: string[]
+}
+
+export class PrecomputeEngine {
+  private logger: Logger
+  private collections: CollectionManager
+  private cache: SemanticCache
+  private stats: PrecomputedStats | null = null
+  private refreshInterval: ReturnType<typeof setInterval> | null = null
+
+  constructor(logger: Logger, collections: CollectionManager, cache: SemanticCache) {
+    this.logger = logger.child({ component: 'precompute' })
+    this.collections = collections
+    this.cache = cache
+  }
+
+  /**
+   * Initialize precomputation (called on startup)
+   */
+  async initialize(): Promise<void> {
+    try {
+      await this.refresh()
+      this.logger.info('Precomputation initialized')
+    } catch (error) {
+      this.logger.warn({ error }, 'Failed to initialize precomputation')
+    }
+  }
+
+  /**
+   * Start periodic refresh of precomputed data
+   */
+  startAutoRefresh(intervalMs: number = 5 * 60 * 1000): void {
+    this.stopAutoRefresh()
+    this.refreshInterval = setInterval(async () => {
+      try {
+        await this.refresh()
+      } catch (error) {
+        this.logger.debug({ error }, 'Auto-refresh failed')
+      }
+    }, intervalMs)
+  }
+
+  /**
+   * Stop periodic refresh
+   */
+  stopAutoRefresh(): void {
+    if (this.refreshInterval) {
+      clearInterval(this.refreshInterval)
+      this.refreshInterval = null
+    }
+  }
+
+  /**
+   * Refresh precomputed data
+   */
+  async refresh(): Promise<void> {
+    const projectStats = new Map<string, ProjectStats>()
+
+    // Get decision counts by project
+    try {
+      const decisionsCollection = await this.collections.getDecisions()
+      const decisions = await decisionsCollection.get({
+        include: ['metadatas']
+      })
+
+      const projectDecisions = new Map<string, Array<Record<string, any>>>()
+
+      for (let i = 0; i < decisions.ids.length; i++) {
+        const meta = decisions.metadatas![i] as Record<string, any>
+        const project = meta?.project || 'unknown'
+
+        if (!projectDecisions.has(project)) projectDecisions.set(project, [])
+        projectDecisions.get(project)!.push(meta)
+      }
+
+      for (const [project, metas] of projectDecisions) {
+        const stats = projectStats.get(project) || {
+          project,
+          decisionCount: 0,
+          patternCount: 0,
+          correctionCount: 0,
+          lastActivity: '',
+          topTags: []
+        }
+
+        stats.decisionCount = metas.length
+
+        // Find last activity
+        const dates = metas
+          .map(m => m?.created_at || '')
+          .filter(d => d)
+          .sort()
+
+        if (dates.length > 0) {
+          stats.lastActivity = dates[dates.length - 1]
+        }
+
+        // Extract top tags
+        const tagCounts = new Map<string, number>()
+        for (const meta of metas) {
+          const tags = String(meta?.tags || '').split(',').filter(t => t.trim())
+          for (const tag of tags) {
+            tagCounts.set(tag.trim(), (tagCounts.get(tag.trim()) || 0) + 1)
+          }
+        }
+        stats.topTags = Array.from(tagCounts.entries())
+          .sort((a, b) => b[1] - a[1])
+          .slice(0, 10)
+          .map(([tag]) => tag)
+
+        projectStats.set(project, stats)
+      }
+    } catch (error) {
+      this.logger.debug({ error }, 'Failed to precompute decision stats')
+    }
+
+    // Get pattern counts
+    try {
+      const patternsCollection = await this.collections.getPatterns()
+      const patterns = await patternsCollection.get({
+        include: ['metadatas']
+      })
+
+      for (let i = 0; i < patterns.ids.length; i++) {
+        const project = (patterns.metadatas![i] as any)?.project || 'unknown'
+        const stats = projectStats.get(project)
+        if (stats) {
+          stats.patternCount++
+        }
+      }
+    } catch (error) {
+      this.logger.debug({ error }, 'Failed to precompute pattern stats')
+    }
+
+    // Get correction counts
+    try {
+      const correctionsCollection = await this.collections.getCorrections()
+      const corrections = await correctionsCollection.get({
+        include: ['metadatas']
+      })
+
+      for (let i = 0; i < corrections.ids.length; i++) {
+        const project = (corrections.metadatas![i] as any)?.project || 'unknown'
+        const stats = projectStats.get(project)
+        if (stats) {
+          stats.correctionCount++
+        }
+      }
+    } catch (error) {
+      this.logger.debug({ error }, 'Failed to precompute correction stats')
+    }
+
+    this.stats = {
+      projectStats,
+      lastUpdated: new Date().toISOString()
+    }
+
+    // Cache project stats
+    for (const [project, stats] of projectStats) {
+      await this.cache.set(`project_stats:${project}`, stats)
+    }
+
+    this.logger.debug(
+      { projects: projectStats.size },
+      'Precomputation complete'
+    )
+  }
+
+  /**
+   * Get precomputed project stats
+   */
+  getProjectStats(project: string): ProjectStats | undefined {
+    return this.stats?.projectStats.get(project)
+  }
+
+  /**
+   * Get all precomputed stats
+   */
+  getAllStats(): PrecomputedStats | null {
+    return this.stats
+  }
+}