claude-brain 0.30.2 → 0.30.3

package/src/intelligence/temporal/timeline.ts

@@ -1,259 +1,272 @@
-/**
- * Timeline Construction
- * Builds chronological timelines from ChromaDB memories
- */
-
-import type { Logger } from 'pino'
-import type { CollectionManager } from '@/memory/chroma/collection-manager'
-import type { EmbeddingProvider } from '@/memory/chroma/embeddings'
-
-export interface TimelineEntry {
-  id: string
-  date: string
-  type: 'decision' | 'pattern' | 'correction'
-  project: string
-  content: string
-  metadata: Record<string, any>
-}
-
-export interface Timeline {
-  entries: TimelineEntry[]
-  project?: string
-  startDate?: string
-  endDate?: string
-  totalCount: number
-}
-
-export class TimelineBuilder {
-  private logger: Logger
-  private collections: CollectionManager
-  private embeddings?: EmbeddingProvider
-
-  constructor(logger: Logger, collections: CollectionManager, embeddings?: EmbeddingProvider) {
-    this.logger = logger.child({ component: 'timeline-builder' })
-    this.collections = collections
-    this.embeddings = embeddings
-  }
-
-  /**
-   * Build a timeline of decisions for a project or topic
-   */
-  async buildTimeline(options: {
-    project?: string
-    topic?: string
-    startDate?: string
-    endDate?: string
-    limit?: number
-    types?: Array<'decision' | 'pattern' | 'correction'>
-  } = {}): Promise<Timeline> {
-    const {
-      project,
-      topic,
-      startDate,
-      endDate,
-      limit = 50,
-      types = ['decision', 'pattern', 'correction']
-    } = options
-
-    const entries: TimelineEntry[] = []
-
-    // Fetch from each collection type
-    if (types.includes('decision')) {
-      const decisions = await this.fetchDecisions(project, topic, startDate, endDate, limit)
-      entries.push(...decisions)
-    }
-
-    if (types.includes('pattern')) {
-      const patterns = await this.fetchPatterns(project, topic, startDate, endDate, limit)
-      entries.push(...patterns)
-    }
-
-    if (types.includes('correction')) {
-      const corrections = await this.fetchCorrections(project, topic, startDate, endDate, limit)
-      entries.push(...corrections)
-    }
-
-    // Sort chronologically
-    entries.sort((a, b) => new Date(a.date).getTime() - new Date(b.date).getTime())
-
-    // Apply limit after merge
-    const limited = entries.slice(0, limit)
-
-    return {
-      entries: limited,
-      project,
-      startDate: limited[0]?.date,
-      endDate: limited[limited.length - 1]?.date,
-      totalCount: limited.length
-    }
-  }
-
-  private async fetchDecisions(
-    project?: string,
-    topic?: string,
-    startDate?: string,
-    endDate?: string,
-    limit: number = 50
-  ): Promise<TimelineEntry[]> {
-    try {
-      const collection = await this.collections.getDecisions()
-
-      if (topic && this.embeddings) {
-        // Semantic search by topic
-        const embedding = await this.embeddings.generate(topic)
-        const where = this.buildWhere(project, startDate, endDate)
-        const results = await collection.query({
-          queryEmbeddings: [embedding],
-          nResults: limit,
-          where: Object.keys(where).length > 0 ? where : undefined,
-          include: ['documents', 'metadatas', 'distances']
-        })
-
-        return this.processQueryResults(results, 'decision')
-      }
-
-      // Direct fetch
-      const where = this.buildWhere(project, startDate, endDate)
-      const results = await collection.get({
-        where: Object.keys(where).length > 0 ? where : undefined,
-        include: ['documents', 'metadatas'],
-        limit
-      })
-
-      return results.ids.map((id, i) => ({
-        id,
-        date: (results.metadatas![i] as any)?.created_at || new Date().toISOString(),
-        type: 'decision' as const,
-        project: (results.metadatas![i] as any)?.project || '',
-        content: results.documents![i] as string,
-        metadata: results.metadatas![i] as Record<string, any>
-      }))
-    } catch (error) {
-      this.logger.warn({ error }, 'Failed to fetch decisions for timeline')
-      return []
-    }
-  }
-
-  private async fetchPatterns(
-    project?: string,
-    topic?: string,
-    startDate?: string,
-    endDate?: string,
-    limit: number = 50
-  ): Promise<TimelineEntry[]> {
-    try {
-      const collection = await this.collections.getPatterns()
-
-      if (topic && this.embeddings) {
-        const embedding = await this.embeddings.generate(topic)
-        const where = this.buildWhere(project, startDate, endDate)
-        const results = await collection.query({
-          queryEmbeddings: [embedding],
-          nResults: limit,
-          where: Object.keys(where).length > 0 ? where : undefined,
-          include: ['documents', 'metadatas', 'distances']
-        })
-
-        return this.processQueryResults(results, 'pattern')
-      }
-
-      const where = this.buildWhere(project, startDate, endDate)
-      const results = await collection.get({
-        where: Object.keys(where).length > 0 ? where : undefined,
-        include: ['documents', 'metadatas'],
-        limit
-      })
-
-      return results.ids.map((id, i) => ({
-        id,
-        date: (results.metadatas![i] as any)?.created_at || new Date().toISOString(),
-        type: 'pattern' as const,
-        project: (results.metadatas![i] as any)?.project || '',
-        content: results.documents![i] as string,
-        metadata: results.metadatas![i] as Record<string, any>
-      }))
-    } catch (error) {
-      this.logger.warn({ error }, 'Failed to fetch patterns for timeline')
-      return []
-    }
-  }
-
-  private async fetchCorrections(
-    project?: string,
-    topic?: string,
-    startDate?: string,
-    endDate?: string,
-    limit: number = 50
-  ): Promise<TimelineEntry[]> {
-    try {
-      const collection = await this.collections.getCorrections()
-
-      if (topic && this.embeddings) {
-        const embedding = await this.embeddings.generate(topic)
-        const where = this.buildWhere(project, startDate, endDate)
-        const results = await collection.query({
-          queryEmbeddings: [embedding],
-          nResults: limit,
-          where: Object.keys(where).length > 0 ? where : undefined,
-          include: ['documents', 'metadatas', 'distances']
-        })
-
-        return this.processQueryResults(results, 'correction')
-      }
-
-      const where = this.buildWhere(project, startDate, endDate)
-      const results = await collection.get({
-        where: Object.keys(where).length > 0 ? where : undefined,
-        include: ['documents', 'metadatas'],
-        limit
-      })
-
-      return results.ids.map((id, i) => ({
-        id,
-        date: (results.metadatas![i] as any)?.created_at || new Date().toISOString(),
-        type: 'correction' as const,
-        project: (results.metadatas![i] as any)?.project || '',
-        content: results.documents![i] as string,
-        metadata: results.metadatas![i] as Record<string, any>
-      }))
-    } catch (error) {
-      this.logger.warn({ error }, 'Failed to fetch corrections for timeline')
-      return []
-    }
-  }
-
-  private buildWhere(project?: string, startDate?: string, endDate?: string): Record<string, any> {
-    const conditions: any[] = []
-
-    if (project) {
-      conditions.push({ project: { $eq: project } })
-    }
-    if (startDate) {
-      conditions.push({ created_at: { $gte: startDate } })
-    }
-    if (endDate) {
-      conditions.push({ created_at: { $lte: endDate } })
-    }
-
-    if (conditions.length === 0) return {}
-    if (conditions.length === 1) return conditions[0]
-    return { $and: conditions }
-  }
-
-  private processQueryResults(results: any, type: 'decision' | 'pattern' | 'correction'): TimelineEntry[] {
-    if (!results.ids || !results.ids[0]) return []
-
-    const ids = results.ids[0] || []
-    const documents = results.documents?.[0] || []
-    const metadatas = results.metadatas?.[0] || []
-
-    return ids.map((id: string, i: number) => ({
-      id,
-      date: metadatas[i]?.created_at || new Date().toISOString(),
-      type,
-      project: metadatas[i]?.project || '',
-      content: documents[i] || '',
-      metadata: metadatas[i] || {}
-    }))
-  }
-}
+/**
+ * Timeline Construction
+ * Builds chronological timelines from ChromaDB memories
+ */
+
+import type { QueryResult, 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 TimelineEntry {
+  id: string
+  date: string
+  type: 'decision' | 'pattern' | 'correction'
+  project: string
+  content: string
+  metadata: Record<string, unknown>
+}
+
+export interface Timeline {
+  entries: TimelineEntry[]
+  project?: string
+  startDate?: string
+  endDate?: string
+  totalCount: number
+}
+
+export class TimelineBuilder {
+  private logger: Logger
+  private collections: CollectionManager
+  private embeddings?: EmbeddingProvider
+
+  constructor(logger: Logger, collections: CollectionManager, embeddings?: EmbeddingProvider) {
+    this.logger = logger.child({ component: 'timeline-builder' })
+    this.collections = collections
+    this.embeddings = embeddings
+  }
+
+  /**
+   * Build a timeline of decisions for a project or topic
+   */
+  async buildTimeline(options: {
+    project?: string
+    topic?: string
+    startDate?: string
+    endDate?: string
+    limit?: number
+    types?: Array<'decision' | 'pattern' | 'correction'>
+  } = {}): Promise<Timeline> {
+    const {
+      project,
+      topic,
+      startDate,
+      endDate,
+      limit = 50,
+      types = ['decision', 'pattern', 'correction']
+    } = options
+
+    const entries: TimelineEntry[] = []
+
+    // Fetch from each collection type
+    if (types.includes('decision')) {
+      const decisions = await this.fetchDecisions(project, topic, startDate, endDate, limit)
+      entries.push(...decisions)
+    }
+
+    if (types.includes('pattern')) {
+      const patterns = await this.fetchPatterns(project, topic, startDate, endDate, limit)
+      entries.push(...patterns)
+    }
+
+    if (types.includes('correction')) {
+      const corrections = await this.fetchCorrections(project, topic, startDate, endDate, limit)
+      entries.push(...corrections)
+    }
+
+    // Sort chronologically
+    entries.sort((a, b) => new Date(a.date).getTime() - new Date(b.date).getTime())
+
+    // Apply limit after merge
+    const limited = entries.slice(0, limit)
+
+    return {
+      entries: limited,
+      project,
+      startDate: limited[0]?.date,
+      endDate: limited[limited.length - 1]?.date,
+      totalCount: limited.length
+    }
+  }
+
+  private async fetchDecisions(
+    project?: string,
+    topic?: string,
+    startDate?: string,
+    endDate?: string,
+    limit: number = 50
+  ): Promise<TimelineEntry[]> {
+    try {
+      const collection = await this.collections.getDecisions()
+
+      if (topic && this.embeddings) {
+        // Semantic search by topic
+        const embedding = await this.embeddings.generate(topic)
+        const where = this.buildWhere(project, startDate, endDate)
+        const results = await collection.query({
+          queryEmbeddings: [embedding],
+          nResults: limit,
+          where: Object.keys(where).length > 0 ? where : undefined,
+          include: ['documents', 'metadatas', 'distances']
+        })
+
+        return this.processQueryResults(results, 'decision')
+      }
+
+      // Direct fetch
+      const where = this.buildWhere(project, startDate, endDate)
+      const results = await collection.get({
+        where: Object.keys(where).length > 0 ? where : undefined,
+        include: ['documents', 'metadatas'],
+        limit
+      })
+
+      return results.ids.map((id, i) => {
+        const meta = (results.metadatas![i] || {}) as Record<string, unknown>
+        return {
+          id,
+          date: (meta.created_at as string) || new Date().toISOString(),
+          type: 'decision' as const,
+          project: (meta.project as string) || '',
+          content: (results.documents![i] as string) || '',
+          metadata: meta
+        }
+      })
+    } catch (error) {
+      this.logger.warn({ error }, 'Failed to fetch decisions for timeline')
+      return []
+    }
+  }
+
+  private async fetchPatterns(
+    project?: string,
+    topic?: string,
+    startDate?: string,
+    endDate?: string,
+    limit: number = 50
+  ): Promise<TimelineEntry[]> {
+    try {
+      const collection = await this.collections.getPatterns()
+
+      if (topic && this.embeddings) {
+        const embedding = await this.embeddings.generate(topic)
+        const where = this.buildWhere(project, startDate, endDate)
+        const results = await collection.query({
+          queryEmbeddings: [embedding],
+          nResults: limit,
+          where: Object.keys(where).length > 0 ? where : undefined,
+          include: ['documents', 'metadatas', 'distances']
+        })
+
+        return this.processQueryResults(results, 'pattern')
+      }
+
+      const where = this.buildWhere(project, startDate, endDate)
+      const results = await collection.get({
+        where: Object.keys(where).length > 0 ? where : undefined,
+        include: ['documents', 'metadatas'],
+        limit
+      })
+
+      return results.ids.map((id, i) => {
+        const meta = (results.metadatas![i] || {}) as Record<string, unknown>
+        return {
+          id,
+          date: (meta.created_at as string) || new Date().toISOString(),
+          type: 'pattern' as const,
+          project: (meta.project as string) || '',
+          content: (results.documents![i] as string) || '',
+          metadata: meta
+        }
+      })
+    } catch (error) {
+      this.logger.warn({ error }, 'Failed to fetch patterns for timeline')
+      return []
+    }
+  }
+
+  private async fetchCorrections(
+    project?: string,
+    topic?: string,
+    startDate?: string,
+    endDate?: string,
+    limit: number = 50
+  ): Promise<TimelineEntry[]> {
+    try {
+      const collection = await this.collections.getCorrections()
+
+      if (topic && this.embeddings) {
+        const embedding = await this.embeddings.generate(topic)
+        const where = this.buildWhere(project, startDate, endDate)
+        const results = await collection.query({
+          queryEmbeddings: [embedding],
+          nResults: limit,
+          where: Object.keys(where).length > 0 ? where : undefined,
+          include: ['documents', 'metadatas', 'distances']
+        })
+
+        return this.processQueryResults(results, 'correction')
+      }
+
+      const where = this.buildWhere(project, startDate, endDate)
+      const results = await collection.get({
+        where: Object.keys(where).length > 0 ? where : undefined,
+        include: ['documents', 'metadatas'],
+        limit
+      })
+
+      return results.ids.map((id, i) => {
+        const meta = (results.metadatas![i] || {}) as Record<string, unknown>
+        return {
+          id,
+          date: (meta.created_at as string) || new Date().toISOString(),
+          type: 'correction' as const,
+          project: (meta.project as string) || '',
+          content: (results.documents![i] as string) || '',
+          metadata: meta
+        }
+      })
+    } catch (error) {
+      this.logger.warn({ error }, 'Failed to fetch corrections for timeline')
+      return []
+    }
+  }
+
+  private buildWhere(project?: string, startDate?: string, endDate?: string): Where {
+    const conditions: Where[] = []
+
+    if (project) {
+      conditions.push({ project: { $eq: project } })
+    }
+    if (startDate) {
+      conditions.push({ created_at: { $gte: startDate } })
+    }
+    if (endDate) {
+      conditions.push({ created_at: { $lte: endDate } })
+    }
+
+    if (conditions.length === 0) return {} as Where
+    if (conditions.length === 1) return conditions[0]!
+    return { $and: conditions } as Where
+  }
+
+  private processQueryResults(
+    results: QueryResult,
+    type: 'decision' | 'pattern' | 'correction'
+  ): TimelineEntry[] {
+    if (!results.ids || !results.ids[0]) return []
+
+    const ids = results.ids[0] || []
+    const documents = results.documents?.[0] || []
+    const metadatas = results.metadatas?.[0] || []
+
+    return ids.map((id: string, i: number) => ({
+      id,
+      date: (metadatas[i]?.created_at as string) || new Date().toISOString(),
+      type,
+      project: (metadatas[i]?.project as string) || '',
+      content: (documents[i] as string) || '',
+      metadata: (metadatas[i] || {}) as Record<string, unknown>
+    }))
+  }
+}