claude-brain 0.15.2 → 0.16.0

package/src/retrieval/feedback/store.ts

@@ -1,283 +1,283 @@
-/**
- * Feedback Store
- * Stores and retrieves memory feedback for adaptive learning
- */
-
-import type { Logger } from 'pino'
-import type { CollectionManager } from '@/memory/chroma/collection-manager'
-import type { EmbeddingProvider } from '@/memory/chroma/embeddings'
-import type { MemoryFeedback, RateMemoryInput } from '../types'
-
-export class FeedbackStore {
-  private logger: Logger
-  private collections: CollectionManager
-  private embeddings: EmbeddingProvider
-
-  constructor(
-    logger: Logger,
-    collections: CollectionManager,
-    embeddings: EmbeddingProvider
-  ) {
-    this.logger = logger.child({ component: 'feedback-store' })
-    this.collections = collections
-    this.embeddings = embeddings
-  }
-
-  /**
-   * Store feedback for a memory retrieval
-   */
-  async storeFeedback(input: RateMemoryInput): Promise<string> {
-    const feedbackId = `feedback_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`
-    const queryId = `query_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`
-    const timestamp = new Date().toISOString()
-
-    this.logger.debug({
-      feedbackId,
-      memoryId: input.memory_id,
-      rating: input.rating
-    }, 'Storing feedback')
-
-    try {
-      const collection = await this.collections.getFeedback()
-
-      // Generate embedding for the query to enable similarity search
-      const embedding = await this.embeddings.generate(input.query)
-
-      // Determine collection type from memory_id prefix
-      const collectionType = this.inferCollectionType(input.memory_id)
-
-      await collection.add({
-        ids: [feedbackId],
-        embeddings: [embedding],
-        documents: [input.query],
-        metadatas: [{
-          memory_id: input.memory_id,
-          query_id: queryId,
-          query: input.query,
-          rating: input.rating,
-          was_used: input.was_used ?? true,
-          feedback_text: input.feedback_text || '',
-          project: input.project_name || '',
-          created_at: timestamp,
-          collection_type: collectionType
-        }]
-      })
-
-      this.logger.info({
-        feedbackId,
-        memoryId: input.memory_id,
-        rating: input.rating
-      }, 'Feedback stored successfully')
-
-      return feedbackId
-
-    } catch (error) {
-      this.logger.error({ error, input }, 'Failed to store feedback')
-      throw error
-    }
-  }
-
-  /**
-   * Get feedback for a specific memory
-   */
-  async getFeedbackForMemory(memoryId: string): Promise<MemoryFeedback[]> {
-    try {
-      const collection = await this.collections.getFeedback()
-
-      const results = await collection.get({
-        where: { memory_id: { $eq: memoryId } },
-        include: ['documents', 'metadatas']
-      })
-
-      if (!results.ids.length) {
-        return []
-      }
-
-      return results.ids.map((id, index) => ({
-        id,
-        memoryId: results.metadatas?.[index]?.memory_id as string || '',
-        queryId: results.metadatas?.[index]?.query_id as string || '',
-        query: results.documents?.[index] || '',
-        rating: results.metadatas?.[index]?.rating as 1 | 2 | 3 | 4 | 5,
-        wasUsed: results.metadatas?.[index]?.was_used as boolean ?? true,
-        feedbackText: results.metadatas?.[index]?.feedback_text as string | undefined,
-        project: results.metadatas?.[index]?.project as string | undefined,
-        timestamp: results.metadatas?.[index]?.created_at as string || '',
-        collectionType: results.metadatas?.[index]?.collection_type as 'decisions' | 'memories' | 'patterns' | 'corrections'
-      }))
-
-    } catch (error) {
-      this.logger.error({ error, memoryId }, 'Failed to get feedback for memory')
-      return []
-    }
-  }
-
-  /**
-   * Get all feedback for a project
-   */
-  async getFeedbackForProject(project: string, limit: number = 100): Promise<MemoryFeedback[]> {
-    try {
-      const collection = await this.collections.getFeedback()
-
-      const results = await collection.get({
-        where: { project: { $eq: project } },
-        include: ['documents', 'metadatas'],
-        limit
-      })
-
-      if (!results.ids.length) {
-        return []
-      }
-
-      return results.ids.map((id, index) => ({
-        id,
-        memoryId: results.metadatas?.[index]?.memory_id as string || '',
-        queryId: results.metadatas?.[index]?.query_id as string || '',
-        query: results.documents?.[index] || '',
-        rating: results.metadatas?.[index]?.rating as 1 | 2 | 3 | 4 | 5,
-        wasUsed: results.metadatas?.[index]?.was_used as boolean ?? true,
-        feedbackText: results.metadatas?.[index]?.feedback_text as string | undefined,
-        project: results.metadatas?.[index]?.project as string | undefined,
-        timestamp: results.metadatas?.[index]?.created_at as string || '',
-        collectionType: results.metadatas?.[index]?.collection_type as 'decisions' | 'memories' | 'patterns' | 'corrections'
-      }))
-
-    } catch (error) {
-      this.logger.error({ error, project }, 'Failed to get feedback for project')
-      return []
-    }
-  }
-
-  /**
-   * Get recent feedback (for adaptive learning)
-   */
-  async getRecentFeedback(limit: number = 100): Promise<MemoryFeedback[]> {
-    try {
-      const collection = await this.collections.getFeedback()
-
-      // Get all feedback - ChromaDB doesn't support ordering, so we'll sort in memory
-      const results = await collection.get({
-        include: ['documents', 'metadatas'],
-        limit: limit * 2 // Get more to allow for sorting
-      })
-
-      if (!results.ids.length) {
-        return []
-      }
-
-      const feedback: MemoryFeedback[] = results.ids.map((id, index) => ({
-        id,
-        memoryId: results.metadatas?.[index]?.memory_id as string || '',
-        queryId: results.metadatas?.[index]?.query_id as string || '',
-        query: results.documents?.[index] || '',
-        rating: results.metadatas?.[index]?.rating as 1 | 2 | 3 | 4 | 5,
-        wasUsed: results.metadatas?.[index]?.was_used as boolean ?? true,
-        feedbackText: results.metadatas?.[index]?.feedback_text as string | undefined,
-        project: results.metadatas?.[index]?.project as string | undefined,
-        timestamp: results.metadatas?.[index]?.created_at as string || '',
-        collectionType: results.metadatas?.[index]?.collection_type as 'decisions' | 'memories' | 'patterns' | 'corrections'
-      }))
-
-      // Sort by timestamp descending and take limit
-      return feedback
-        .sort((a, b) => new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime())
-        .slice(0, limit)
-
-    } catch (error) {
-      this.logger.error({ error }, 'Failed to get recent feedback')
-      return []
-    }
-  }
-
-  /**
-   * Get feedback statistics
-   */
-  async getStats(): Promise<{
-    totalFeedback: number
-    avgRating: number
-    positiveRate: number
-    usageRate: number
-    byCollection: Record<string, { count: number; avgRating: number }>
-  }> {
-    try {
-      const collection = await this.collections.getFeedback()
-      const totalCount = await collection.count()
-
-      if (totalCount === 0) {
-        return {
-          totalFeedback: 0,
-          avgRating: 0,
-          positiveRate: 0,
-          usageRate: 0,
-          byCollection: {}
-        }
-      }
-
-      const results = await collection.get({
-        include: ['metadatas'],
-        limit: 1000 // Sample for stats
-      })
-
-      let totalRating = 0
-      let positiveCount = 0
-      let usedCount = 0
-      const byCollection: Record<string, { count: number; totalRating: number }> = {}
-
-      for (const metadata of results.metadatas || []) {
-        const rating = metadata?.rating as number
-        const wasUsed = metadata?.was_used as boolean
-        const collectionType = (metadata?.collection_type as string) || 'unknown'
-
-        totalRating += rating
-        if (rating >= 4) positiveCount++
-        if (wasUsed) usedCount++
-
-        if (!byCollection[collectionType]) {
-          byCollection[collectionType] = { count: 0, totalRating: 0 }
-        }
-        byCollection[collectionType].count++
-        byCollection[collectionType].totalRating += rating
-      }
-
-      const count = results.ids.length
-
-      return {
-        totalFeedback: totalCount,
-        avgRating: count > 0 ? totalRating / count : 0,
-        positiveRate: count > 0 ? positiveCount / count : 0,
-        usageRate: count > 0 ? usedCount / count : 0,
-        byCollection: Object.fromEntries(
-          Object.entries(byCollection).map(([key, value]) => [
-            key,
-            {
-              count: value.count,
-              avgRating: value.count > 0 ? value.totalRating / value.count : 0
-            }
-          ])
-        )
-      }
-
-    } catch (error) {
-      this.logger.error({ error }, 'Failed to get feedback stats')
-      return {
-        totalFeedback: 0,
-        avgRating: 0,
-        positiveRate: 0,
-        usageRate: 0,
-        byCollection: {}
-      }
-    }
-  }
-
-  /**
-   * Infer collection type from memory ID prefix
-   */
-  private inferCollectionType(memoryId: string): 'decisions' | 'memories' | 'patterns' | 'corrections' {
-    if (memoryId.startsWith('dec_')) return 'decisions'
-    if (memoryId.startsWith('mem_')) return 'memories'
-    if (memoryId.startsWith('pat_')) return 'patterns'
-    if (memoryId.startsWith('cor_')) return 'corrections'
-    // Default to decisions if unknown
-    return 'decisions'
-  }
-}
+/**
+ * Feedback Store
+ * Stores and retrieves memory feedback for adaptive learning
+ */
+
+import type { Logger } from 'pino'
+import type { CollectionManager } from '@/memory/chroma/collection-manager'
+import type { EmbeddingProvider } from '@/memory/chroma/embeddings'
+import type { MemoryFeedback, RateMemoryInput } from '../types'
+
+export class FeedbackStore {
+  private logger: Logger
+  private collections: CollectionManager
+  private embeddings: EmbeddingProvider
+
+  constructor(
+    logger: Logger,
+    collections: CollectionManager,
+    embeddings: EmbeddingProvider
+  ) {
+    this.logger = logger.child({ component: 'feedback-store' })
+    this.collections = collections
+    this.embeddings = embeddings
+  }
+
+  /**
+   * Store feedback for a memory retrieval
+   */
+  async storeFeedback(input: RateMemoryInput): Promise<string> {
+    const feedbackId = `feedback_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`
+    const queryId = `query_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`
+    const timestamp = new Date().toISOString()
+
+    this.logger.debug({
+      feedbackId,
+      memoryId: input.memory_id,
+      rating: input.rating
+    }, 'Storing feedback')
+
+    try {
+      const collection = await this.collections.getFeedback()
+
+      // Generate embedding for the query to enable similarity search
+      const embedding = await this.embeddings.generate(input.query)
+
+      // Determine collection type from memory_id prefix
+      const collectionType = this.inferCollectionType(input.memory_id)
+
+      await collection.add({
+        ids: [feedbackId],
+        embeddings: [embedding],
+        documents: [input.query],
+        metadatas: [{
+          memory_id: input.memory_id,
+          query_id: queryId,
+          query: input.query,
+          rating: input.rating,
+          was_used: input.was_used ?? true,
+          feedback_text: input.feedback_text || '',
+          project: input.project_name || '',
+          created_at: timestamp,
+          collection_type: collectionType
+        }]
+      })
+
+      this.logger.info({
+        feedbackId,
+        memoryId: input.memory_id,
+        rating: input.rating
+      }, 'Feedback stored successfully')
+
+      return feedbackId
+
+    } catch (error) {
+      this.logger.error({ error, input }, 'Failed to store feedback')
+      throw error
+    }
+  }
+
+  /**
+   * Get feedback for a specific memory
+   */
+  async getFeedbackForMemory(memoryId: string): Promise<MemoryFeedback[]> {
+    try {
+      const collection = await this.collections.getFeedback()
+
+      const results = await collection.get({
+        where: { memory_id: { $eq: memoryId } },
+        include: ['documents', 'metadatas']
+      })
+
+      if (!results.ids.length) {
+        return []
+      }
+
+      return results.ids.map((id, index) => ({
+        id,
+        memoryId: results.metadatas?.[index]?.memory_id as string || '',
+        queryId: results.metadatas?.[index]?.query_id as string || '',
+        query: results.documents?.[index] || '',
+        rating: results.metadatas?.[index]?.rating as 1 | 2 | 3 | 4 | 5,
+        wasUsed: results.metadatas?.[index]?.was_used as boolean ?? true,
+        feedbackText: results.metadatas?.[index]?.feedback_text as string | undefined,
+        project: results.metadatas?.[index]?.project as string | undefined,
+        timestamp: results.metadatas?.[index]?.created_at as string || '',
+        collectionType: results.metadatas?.[index]?.collection_type as 'decisions' | 'memories' | 'patterns' | 'corrections'
+      }))
+
+    } catch (error) {
+      this.logger.error({ error, memoryId }, 'Failed to get feedback for memory')
+      return []
+    }
+  }
+
+  /**
+   * Get all feedback for a project
+   */
+  async getFeedbackForProject(project: string, limit: number = 100): Promise<MemoryFeedback[]> {
+    try {
+      const collection = await this.collections.getFeedback()
+
+      const results = await collection.get({
+        where: { project: { $eq: project } },
+        include: ['documents', 'metadatas'],
+        limit
+      })
+
+      if (!results.ids.length) {
+        return []
+      }
+
+      return results.ids.map((id, index) => ({
+        id,
+        memoryId: results.metadatas?.[index]?.memory_id as string || '',
+        queryId: results.metadatas?.[index]?.query_id as string || '',
+        query: results.documents?.[index] || '',
+        rating: results.metadatas?.[index]?.rating as 1 | 2 | 3 | 4 | 5,
+        wasUsed: results.metadatas?.[index]?.was_used as boolean ?? true,
+        feedbackText: results.metadatas?.[index]?.feedback_text as string | undefined,
+        project: results.metadatas?.[index]?.project as string | undefined,
+        timestamp: results.metadatas?.[index]?.created_at as string || '',
+        collectionType: results.metadatas?.[index]?.collection_type as 'decisions' | 'memories' | 'patterns' | 'corrections'
+      }))
+
+    } catch (error) {
+      this.logger.error({ error, project }, 'Failed to get feedback for project')
+      return []
+    }
+  }
+
+  /**
+   * Get recent feedback (for adaptive learning)
+   */
+  async getRecentFeedback(limit: number = 100): Promise<MemoryFeedback[]> {
+    try {
+      const collection = await this.collections.getFeedback()
+
+      // Get all feedback - ChromaDB doesn't support ordering, so we'll sort in memory
+      const results = await collection.get({
+        include: ['documents', 'metadatas'],
+        limit: limit * 2 // Get more to allow for sorting
+      })
+
+      if (!results.ids.length) {
+        return []
+      }
+
+      const feedback: MemoryFeedback[] = results.ids.map((id, index) => ({
+        id,
+        memoryId: results.metadatas?.[index]?.memory_id as string || '',
+        queryId: results.metadatas?.[index]?.query_id as string || '',
+        query: results.documents?.[index] || '',
+        rating: results.metadatas?.[index]?.rating as 1 | 2 | 3 | 4 | 5,
+        wasUsed: results.metadatas?.[index]?.was_used as boolean ?? true,
+        feedbackText: results.metadatas?.[index]?.feedback_text as string | undefined,
+        project: results.metadatas?.[index]?.project as string | undefined,
+        timestamp: results.metadatas?.[index]?.created_at as string || '',
+        collectionType: results.metadatas?.[index]?.collection_type as 'decisions' | 'memories' | 'patterns' | 'corrections'
+      }))
+
+      // Sort by timestamp descending and take limit
+      return feedback
+        .sort((a, b) => new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime())
+        .slice(0, limit)
+
+    } catch (error) {
+      this.logger.error({ error }, 'Failed to get recent feedback')
+      return []
+    }
+  }
+
+  /**
+   * Get feedback statistics
+   */
+  async getStats(): Promise<{
+    totalFeedback: number
+    avgRating: number
+    positiveRate: number
+    usageRate: number
+    byCollection: Record<string, { count: number; avgRating: number }>
+  }> {
+    try {
+      const collection = await this.collections.getFeedback()
+      const totalCount = await collection.count()
+
+      if (totalCount === 0) {
+        return {
+          totalFeedback: 0,
+          avgRating: 0,
+          positiveRate: 0,
+          usageRate: 0,
+          byCollection: {}
+        }
+      }
+
+      const results = await collection.get({
+        include: ['metadatas'],
+        limit: 1000 // Sample for stats
+      })
+
+      let totalRating = 0
+      let positiveCount = 0
+      let usedCount = 0
+      const byCollection: Record<string, { count: number; totalRating: number }> = {}
+
+      for (const metadata of results.metadatas || []) {
+        const rating = metadata?.rating as number
+        const wasUsed = metadata?.was_used as boolean
+        const collectionType = (metadata?.collection_type as string) || 'unknown'
+
+        totalRating += rating
+        if (rating >= 4) positiveCount++
+        if (wasUsed) usedCount++
+
+        if (!byCollection[collectionType]) {
+          byCollection[collectionType] = { count: 0, totalRating: 0 }
+        }
+        byCollection[collectionType].count++
+        byCollection[collectionType].totalRating += rating
+      }
+
+      const count = results.ids.length
+
+      return {
+        totalFeedback: totalCount,
+        avgRating: count > 0 ? totalRating / count : 0,
+        positiveRate: count > 0 ? positiveCount / count : 0,
+        usageRate: count > 0 ? usedCount / count : 0,
+        byCollection: Object.fromEntries(
+          Object.entries(byCollection).map(([key, value]) => [
+            key,
+            {
+              count: value.count,
+              avgRating: value.count > 0 ? value.totalRating / value.count : 0
+            }
+          ])
+        )
+      }
+
+    } catch (error) {
+      this.logger.error({ error }, 'Failed to get feedback stats')
+      return {
+        totalFeedback: 0,
+        avgRating: 0,
+        positiveRate: 0,
+        usageRate: 0,
+        byCollection: {}
+      }
+    }
+  }
+
+  /**
+   * Infer collection type from memory ID prefix
+   */
+  private inferCollectionType(memoryId: string): 'decisions' | 'memories' | 'patterns' | 'corrections' {
+    if (memoryId.startsWith('dec_')) return 'decisions'
+    if (memoryId.startsWith('mem_')) return 'memories'
+    if (memoryId.startsWith('pat_')) return 'patterns'
+    if (memoryId.startsWith('cor_')) return 'corrections'
+    // Default to decisions if unknown
+    return 'decisions'
+  }
+}