@stackmemoryai/stackmemory 0.3.0 → 0.3.3

package/dist/core/retrieval/hierarchical-retrieval.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/core/retrieval/hierarchical-retrieval.ts"],
+  "sourcesContent": ["/**\n * Hierarchical Retrieval System with Progressive Summarization\n * Implements multi-level tree structure to prevent semantic collapse at scale\n *\n * Based on: Encyclopedia \u2192 Chapter \u2192 Section \u2192 Paragraph model\n * Reduces search space from 50K to ~200 at each hop\n */\n\nimport Database from 'better-sqlite3';\nimport { logger } from '../monitoring/logger.js';\nimport { Trace, CompressedTrace } from '../trace/types.js';\nimport { Frame, Anchor, Event } from '../context/frame-manager.js';\nimport * as zlib from 'zlib';\nimport { promisify } from 'util';\nimport crypto from 'crypto';\n\nconst gzipAsync = promisify(zlib.gzip);\nconst gunzipAsync = promisify(zlib.gunzip);\n\nexport interface HierarchyLevel {\n  level: 'encyclopedia' | 'chapter' | 'section' | 'paragraph' | 'atom';\n  id: string;\n  parentId?: string;\n  title: string;\n  summary: string;\n  embeddings?: number[];\n  childCount: number;\n  tokenCount: number;\n  score: number;\n  timeRange: {\n    start: number;\n    end: number;\n  };\n  metadata: {\n    compressionRatio?: number;\n    semanticDensity?: number;\n    accessPattern?: 'hot' | 'warm' | 'cold';\n    lastAccessed?: number;\n  };\n}\n\nexport interface RetrievalNode {\n  id: string;\n  level: HierarchyLevel;\n  children?: RetrievalNode[];\n  content?: string; // Only for leaf nodes\n  compressed?: boolean;\n}\n\nexport interface HierarchicalConfig {\n  maxEncyclopediaSize: number; // Total documents (~50K)\n  maxChapterSize: number; // Documents per chapter (~6K)\n  maxSectionSize: number; // Docs per section (~250)\n  maxParagraphSize: number; // Docs per paragraph (~10-20)\n  compressionThreshold: number; // Token threshold for compression\n  semanticThreshold: number; // Similarity threshold for grouping\n}\n\nexport const DEFAULT_HIERARCHY_CONFIG: HierarchicalConfig = {\n  maxEncyclopediaSize: 50000,\n  maxChapterSize: 6000,\n  maxSectionSize: 250,\n  maxParagraphSize: 20,\n  compressionThreshold: 1000,\n  semanticThreshold: 0.7,\n};\n\n/**\n * Manages hierarchical retrieval with progressive summarization\n */\nexport class HierarchicalRetrieval {\n  private db: Database.Database;\n  private config: HierarchicalConfig;\n  private hierarchyCache: Map<string, RetrievalNode> = new Map();\n  private summaryCache: Map<string, string> = new Map();\n\n  constructor(db: Database.Database, config: Partial<HierarchicalConfig> = {}) {\n    this.db = db;\n    this.config = { ...DEFAULT_HIERARCHY_CONFIG, ...config };\n    this.initializeSchema();\n  }\n\n  private initializeSchema(): void {\n    this.db.exec(`\n      CREATE TABLE IF NOT EXISTS hierarchy_nodes (\n        id TEXT PRIMARY KEY,\n        level TEXT NOT NULL,\n        parent_id TEXT,\n        title TEXT NOT NULL,\n        summary TEXT,\n        embeddings BLOB,\n        child_count INTEGER DEFAULT 0,\n        token_count INTEGER DEFAULT 0,\n        score REAL DEFAULT 0,\n        time_start INTEGER,\n        time_end INTEGER,\n        compression_ratio REAL,\n        semantic_density REAL,\n        access_pattern TEXT DEFAULT 'cold',\n        last_accessed INTEGER,\n        created_at INTEGER DEFAULT (unixepoch() * 1000),\n        FOREIGN KEY (parent_id) REFERENCES hierarchy_nodes(id) ON DELETE CASCADE\n      )\n    `);\n\n    this.db.exec(`\n      CREATE INDEX IF NOT EXISTS idx_hierarchy_level ON hierarchy_nodes(level);\n      CREATE INDEX IF NOT EXISTS idx_hierarchy_parent ON hierarchy_nodes(parent_id);\n      CREATE INDEX IF NOT EXISTS idx_hierarchy_score ON hierarchy_nodes(score DESC);\n      CREATE INDEX IF NOT EXISTS idx_hierarchy_time ON hierarchy_nodes(time_start, time_end);\n    `);\n\n    // Content storage for leaf nodes\n    this.db.exec(`\n      CREATE TABLE IF NOT EXISTS hierarchy_content (\n        node_id TEXT PRIMARY KEY,\n        content TEXT,\n        compressed BOOLEAN DEFAULT 0,\n        original_size INTEGER,\n        compressed_size INTEGER,\n        FOREIGN KEY (node_id) REFERENCES hierarchy_nodes(id) ON DELETE CASCADE\n      )\n    `);\n  }\n\n  /**\n   * Build hierarchical structure from traces\n   */\n  async buildHierarchy(traces: Trace[]): Promise<RetrievalNode> {\n    logger.info('Building hierarchical retrieval structure', {\n      traceCount: traces.length,\n    });\n\n    // Sort traces by time and score\n    traces.sort((a, b) => {\n      const timeDiff = b.metadata.startTime - a.metadata.startTime;\n      return timeDiff !== 0 ? timeDiff : b.score - a.score;\n    });\n\n    // Create root encyclopedia node\n    const encyclopediaId = this.generateId('encyclopedia');\n    const encyclopedia: RetrievalNode = {\n      id: encyclopediaId,\n      level: {\n        level: 'encyclopedia',\n        id: encyclopediaId,\n        title: 'Knowledge Base',\n        summary: await this.generateSummary(traces, 'encyclopedia'),\n        childCount: 0,\n        tokenCount: traces.reduce((sum, t) => sum + (t.tokenCount || 0), 0),\n        score: Math.max(...traces.map((t) => t.score)),\n        timeRange: {\n          start: Math.min(...traces.map((t) => t.metadata.startTime)),\n          end: Math.max(...traces.map((t) => t.metadata.endTime)),\n        },\n        metadata: {\n          semanticDensity: 1.0,\n          accessPattern: 'hot',\n        },\n      },\n      children: [],\n    };\n\n    // Partition into chapters\n    const chapters = await this.partitionIntoChapters(traces);\n\n    for (const chapterTraces of chapters) {\n      const chapter = await this.buildChapter(chapterTraces, encyclopediaId);\n      encyclopedia.children!.push(chapter);\n    }\n\n    // Update child count\n    encyclopedia.level.childCount = encyclopedia.children!.length;\n\n    // Store in database\n    await this.storeNode(encyclopedia);\n\n    return encyclopedia;\n  }\n\n  /**\n   * Partition traces into chapters based on semantic similarity and time\n   */\n  private async partitionIntoChapters(traces: Trace[]): Promise<Trace[][]> {\n    const chapters: Trace[][] = [];\n    let currentChapter: Trace[] = [];\n\n    for (const trace of traces) {\n      if (currentChapter.length >= this.config.maxChapterSize) {\n        chapters.push(currentChapter);\n        currentChapter = [trace];\n      } else if (currentChapter.length > 0) {\n        // Check semantic similarity with chapter\n        const similarity = await this.calculateSimilarity(\n          trace,\n          currentChapter[currentChapter.length - 1]\n        );\n\n        if (similarity < this.config.semanticThreshold) {\n          // Start new chapter if semantically different\n          chapters.push(currentChapter);\n          currentChapter = [trace];\n        } else {\n          currentChapter.push(trace);\n        }\n      } else {\n        currentChapter.push(trace);\n      }\n    }\n\n    if (currentChapter.length > 0) {\n      chapters.push(currentChapter);\n    }\n\n    return chapters;\n  }\n\n  /**\n   * Build a chapter node\n   */\n  private async buildChapter(\n    traces: Trace[],\n    parentId: string\n  ): Promise<RetrievalNode> {\n    const chapterId = this.generateId('chapter');\n\n    const chapter: RetrievalNode = {\n      id: chapterId,\n      level: {\n        level: 'chapter',\n        id: chapterId,\n        parentId,\n        title: this.generateChapterTitle(traces),\n        summary: await this.generateSummary(traces, 'chapter'),\n        childCount: 0,\n        tokenCount: traces.reduce((sum, t) => sum + (t.tokenCount || 0), 0),\n        score: Math.max(...traces.map((t) => t.score)),\n        timeRange: {\n          start: Math.min(...traces.map((t) => t.metadata.startTime)),\n          end: Math.max(...traces.map((t) => t.metadata.endTime)),\n        },\n        metadata: {\n          compressionRatio: 0.8,\n          semanticDensity: 0.8,\n          accessPattern: 'warm',\n        },\n      },\n      children: [],\n    };\n\n    // Partition into sections\n    const sections = await this.partitionIntoSections(traces);\n\n    for (const sectionTraces of sections) {\n      const section = await this.buildSection(sectionTraces, chapterId);\n      chapter.children!.push(section);\n    }\n\n    chapter.level.childCount = chapter.children!.length;\n    return chapter;\n  }\n\n  /**\n   * Build a section node\n   */\n  private async buildSection(\n    traces: Trace[],\n    parentId: string\n  ): Promise<RetrievalNode> {\n    const sectionId = this.generateId('section');\n\n    const section: RetrievalNode = {\n      id: sectionId,\n      level: {\n        level: 'section',\n        id: sectionId,\n        parentId,\n        title: this.generateSectionTitle(traces),\n        summary: await this.generateSummary(traces, 'section'),\n        childCount: 0,\n        tokenCount: traces.reduce((sum, t) => sum + (t.tokenCount || 0), 0),\n        score: Math.max(...traces.map((t) => t.score)),\n        timeRange: {\n          start: Math.min(...traces.map((t) => t.metadata.startTime)),\n          end: Math.max(...traces.map((t) => t.metadata.endTime)),\n        },\n        metadata: {\n          compressionRatio: 0.6,\n          semanticDensity: 0.6,\n          accessPattern: 'cold',\n        },\n      },\n      children: [],\n    };\n\n    // Partition into paragraphs\n    const paragraphs = await this.partitionIntoParagraphs(traces);\n\n    for (const paragraphTraces of paragraphs) {\n      const paragraph = await this.buildParagraph(paragraphTraces, sectionId);\n      section.children!.push(paragraph);\n    }\n\n    section.level.childCount = section.children!.length;\n    return section;\n  }\n\n  /**\n   * Build a paragraph (leaf) node\n   */\n  private async buildParagraph(\n    traces: Trace[],\n    parentId: string\n  ): Promise<RetrievalNode> {\n    const paragraphId = this.generateId('paragraph');\n\n    // Combine trace content\n    const content = traces\n      .map((t) => {\n        return `[${new Date(t.metadata.startTime).toISOString()}] ${t.type}: ${t.summary}`;\n      })\n      .join('\\n\\n');\n\n    // Compress if large\n    let storedContent = content;\n    let compressed = false;\n\n    if (content.length > this.config.compressionThreshold) {\n      const compressedData = await gzipAsync(content);\n      storedContent = compressedData.toString('base64');\n      compressed = true;\n    }\n\n    const paragraph: RetrievalNode = {\n      id: paragraphId,\n      level: {\n        level: 'paragraph',\n        id: paragraphId,\n        parentId,\n        title: this.generateParagraphTitle(traces),\n        summary: await this.generateSummary(traces, 'paragraph'),\n        childCount: traces.length,\n        tokenCount: traces.reduce((sum, t) => sum + (t.tokenCount || 0), 0),\n        score: Math.max(...traces.map((t) => t.score)),\n        timeRange: {\n          start: Math.min(...traces.map((t) => t.metadata.startTime)),\n          end: Math.max(...traces.map((t) => t.metadata.endTime)),\n        },\n        metadata: {\n          compressionRatio: compressed ? 0.3 : 1.0,\n          semanticDensity: 0.4,\n          accessPattern: 'cold',\n        },\n      },\n      content: storedContent,\n      compressed,\n    };\n\n    return paragraph;\n  }\n\n  /**\n   * Partition traces into sections\n   */\n  private async partitionIntoSections(traces: Trace[]): Promise<Trace[][]> {\n    const sections: Trace[][] = [];\n    const sectionSize = Math.ceil(\n      traces.length / Math.ceil(traces.length / this.config.maxSectionSize)\n    );\n\n    for (let i = 0; i < traces.length; i += sectionSize) {\n      sections.push(traces.slice(i, i + sectionSize));\n    }\n\n    return sections;\n  }\n\n  /**\n   * Partition traces into paragraphs\n   */\n  private async partitionIntoParagraphs(traces: Trace[]): Promise<Trace[][]> {\n    const paragraphs: Trace[][] = [];\n    const paragraphSize = Math.ceil(\n      traces.length / Math.ceil(traces.length / this.config.maxParagraphSize)\n    );\n\n    for (let i = 0; i < traces.length; i += paragraphSize) {\n      paragraphs.push(traces.slice(i, i + paragraphSize));\n    }\n\n    return paragraphs;\n  }\n\n  /**\n   * Traverse hierarchy to retrieve relevant content\n   */\n  async retrieve(\n    query: string,\n    maxDepth: number = 4,\n    tokenBudget: number = 4000\n  ): Promise<string> {\n    logger.info('Hierarchical retrieval', { query, maxDepth, tokenBudget });\n\n    // Start from encyclopedia\n    const encyclopedia = await this.loadRootNode();\n    if (!encyclopedia) {\n      return 'No content available';\n    }\n\n    const path: RetrievalNode[] = [encyclopedia];\n    let currentNode = encyclopedia;\n    let tokensUsed = 0;\n\n    // Traverse down the hierarchy\n    for (let depth = 1; depth < maxDepth && tokensUsed < tokenBudget; depth++) {\n      if (!currentNode.children || currentNode.children.length === 0) {\n        break;\n      }\n\n      // Select best matching child\n      const bestChild = await this.selectBestChild(\n        currentNode.children,\n        query,\n        tokenBudget - tokensUsed\n      );\n\n      if (!bestChild) break;\n\n      path.push(bestChild);\n      currentNode = bestChild;\n      tokensUsed += bestChild.level.tokenCount;\n\n      // Update access pattern\n      await this.updateAccessPattern(bestChild.id);\n    }\n\n    // Build context from path\n    return this.buildContextFromPath(path, tokenBudget);\n  }\n\n  /**\n   * Select best matching child node\n   */\n  private async selectBestChild(\n    children: RetrievalNode[],\n    query: string,\n    remainingBudget: number\n  ): Promise<RetrievalNode | null> {\n    let bestChild: RetrievalNode | null = null;\n    let bestScore = 0;\n\n    for (const child of children) {\n      if (child.level.tokenCount > remainingBudget) {\n        continue;\n      }\n\n      // Calculate relevance score\n      const score = await this.calculateRelevance(child, query);\n\n      if (score > bestScore) {\n        bestScore = score;\n        bestChild = child;\n      }\n    }\n\n    return bestChild;\n  }\n\n  /**\n   * Calculate relevance of node to query\n   */\n  private async calculateRelevance(\n    node: RetrievalNode,\n    query: string\n  ): Promise<number> {\n    // Simple keyword matching for now\n    // In production, use embeddings\n    const queryWords = query.toLowerCase().split(/\\s+/);\n    const nodeText = `${node.level.title} ${node.level.summary}`.toLowerCase();\n\n    let matches = 0;\n    for (const word of queryWords) {\n      if (nodeText.includes(word)) {\n        matches++;\n      }\n    }\n\n    const keywordScore = matches / queryWords.length;\n    const recencyScore =\n      1 / (1 + (Date.now() - node.level.timeRange.end) / (1000 * 60 * 60 * 24));\n    const importanceScore = node.level.score;\n\n    return keywordScore * 0.5 + recencyScore * 0.3 + importanceScore * 0.2;\n  }\n\n  /**\n   * Build context string from retrieval path\n   */\n  private async buildContextFromPath(\n    path: RetrievalNode[],\n    tokenBudget: number\n  ): Promise<string> {\n    const sections: string[] = [];\n\n    sections.push('## Retrieval Path');\n    sections.push(path.map((n) => n.level.title).join(' \u2192 '));\n    sections.push('');\n\n    // Add summaries from each level\n    for (const node of path) {\n      sections.push(`### ${node.level.level}: ${node.level.title}`);\n      sections.push(node.level.summary);\n\n      if (node.content) {\n        // Decompress if needed\n        let content = node.content;\n        if (node.compressed) {\n          const compressed = Buffer.from(content, 'base64');\n          const decompressed = await gunzipAsync(compressed);\n          content = decompressed.toString();\n        }\n        sections.push('');\n        sections.push('**Content:**');\n        sections.push(content);\n      }\n      sections.push('');\n    }\n\n    // Add statistics\n    sections.push('## Retrieval Statistics');\n    sections.push(`- Levels traversed: ${path.length}`);\n    sections.push(\n      `- Search space reduction: ${this.calculateReduction(path)}x`\n    );\n    sections.push(\n      `- Semantic density: ${this.calculateDensity(path).toFixed(2)}`\n    );\n\n    return sections.join('\\n');\n  }\n\n  /**\n   * Calculate search space reduction\n   */\n  private calculateReduction(path: RetrievalNode[]): number {\n    if (path.length < 2) return 1;\n\n    const initial = path[0].level.childCount;\n    const final = path[path.length - 1].level.childCount || 1;\n\n    return Math.round(initial / final);\n  }\n\n  /**\n   * Calculate semantic density along path\n   */\n  private calculateDensity(path: RetrievalNode[]): number {\n    const densities = path.map((n) => n.level.metadata.semanticDensity || 1);\n    return densities.reduce((sum, d) => sum + d, 0) / densities.length;\n  }\n\n  /**\n   * Generate summary for a level\n   */\n  private async generateSummary(\n    traces: Trace[],\n    level: string\n  ): Promise<string> {\n    // Cache key\n    const cacheKey = `${level}:${traces.map((t) => t.id).join(',')}`;\n\n    if (this.summaryCache.has(cacheKey)) {\n      return this.summaryCache.get(cacheKey)!;\n    }\n\n    // Generate summary based on level\n    let summary: string;\n\n    switch (level) {\n      case 'encyclopedia':\n        summary = `Complete knowledge base with ${traces.length} traces covering ${this.getTopics(traces).join(', ')}`;\n        break;\n      case 'chapter':\n        summary = `${traces.length} operations focused on ${this.getDominantOperation(traces)}`;\n        break;\n      case 'section':\n        summary = `${traces.length} traces: ${this.getKeyActivities(traces).join(', ')}`;\n        break;\n      case 'paragraph':\n        summary = traces\n          .slice(0, 3)\n          .map((t) => t.summary)\n          .join('. ');\n        break;\n      default:\n        summary = `${traces.length} items`;\n    }\n\n    this.summaryCache.set(cacheKey, summary);\n    return summary;\n  }\n\n  /**\n   * Extract topics from traces\n   */\n  private getTopics(traces: Trace[]): string[] {\n    const topics = new Set<string>();\n\n    for (const trace of traces) {\n      topics.add(trace.type);\n    }\n\n    return Array.from(topics).slice(0, 5);\n  }\n\n  /**\n   * Get dominant operation type\n   */\n  private getDominantOperation(traces: Trace[]): string {\n    const counts: Record<string, number> = {};\n\n    for (const trace of traces) {\n      counts[trace.type] = (counts[trace.type] || 0) + 1;\n    }\n\n    const sorted = Object.entries(counts).sort((a, b) => b[1] - a[1]);\n    return sorted[0]?.[0] || 'mixed operations';\n  }\n\n  /**\n   * Get key activities\n   */\n  private getKeyActivities(traces: Trace[]): string[] {\n    return traces.slice(0, 3).map((t) => t.type);\n  }\n\n  /**\n   * Generate titles\n   */\n  private generateChapterTitle(traces: Trace[]): string {\n    const start = new Date(traces[0].metadata.startTime);\n    const operation = this.getDominantOperation(traces);\n    return `${operation} (${start.toLocaleDateString()})`;\n  }\n\n  private generateSectionTitle(traces: Trace[]): string {\n    const start = new Date(traces[0].metadata.startTime);\n    return `Section ${start.toLocaleTimeString()}`;\n  }\n\n  private generateParagraphTitle(traces: Trace[]): string {\n    return `${traces.length} traces`;\n  }\n\n  /**\n   * Calculate similarity between traces\n   */\n  private async calculateSimilarity(a: Trace, b: Trace): Promise<number> {\n    // Simple similarity based on type and time\n    const typeSimilarity = a.type === b.type ? 1 : 0;\n    const timeDiff = Math.abs(a.metadata.startTime - b.metadata.startTime);\n    const timeSimilarity = 1 / (1 + timeDiff / (1000 * 60 * 60)); // Hour scale\n\n    return typeSimilarity * 0.5 + timeSimilarity * 0.5;\n  }\n\n  /**\n   * Store node in database\n   */\n  private async storeNode(node: RetrievalNode): Promise<void> {\n    const stmt = this.db.prepare(`\n      INSERT OR REPLACE INTO hierarchy_nodes (\n        id, level, parent_id, title, summary,\n        child_count, token_count, score,\n        time_start, time_end,\n        compression_ratio, semantic_density, access_pattern\n      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)\n    `);\n\n    stmt.run(\n      node.id,\n      node.level.level,\n      node.level.parentId || null,\n      node.level.title,\n      node.level.summary,\n      node.level.childCount,\n      node.level.tokenCount,\n      node.level.score,\n      node.level.timeRange.start,\n      node.level.timeRange.end,\n      node.level.metadata.compressionRatio || 1,\n      node.level.metadata.semanticDensity || 1,\n      node.level.metadata.accessPattern || 'cold'\n    );\n\n    // Store content if present\n    if (node.content) {\n      this.db\n        .prepare(\n          `\n        INSERT OR REPLACE INTO hierarchy_content (\n          node_id, content, compressed, original_size, compressed_size\n        ) VALUES (?, ?, ?, ?, ?)\n      `\n        )\n        .run(\n          node.id,\n          node.content,\n          node.compressed ? 1 : 0,\n          node.compressed ? node.content.length * 2 : node.content.length,\n          node.content.length\n        );\n    }\n\n    // Recursively store children\n    if (node.children) {\n      for (const child of node.children) {\n        await this.storeNode(child);\n      }\n    }\n  }\n\n  /**\n   * Load root encyclopedia node\n   */\n  private async loadRootNode(): Promise<RetrievalNode | null> {\n    const row = this.db\n      .prepare(\n        `\n      SELECT * FROM hierarchy_nodes\n      WHERE level = 'encyclopedia'\n      ORDER BY created_at DESC\n      LIMIT 1\n    `\n      )\n      .get() as any;\n\n    if (!row) return null;\n\n    return this.loadNode(row.id);\n  }\n\n  /**\n   * Load node from database\n   */\n  private async loadNode(nodeId: string): Promise<RetrievalNode | null> {\n    // Check cache\n    if (this.hierarchyCache.has(nodeId)) {\n      return this.hierarchyCache.get(nodeId)!;\n    }\n\n    const nodeRow = this.db\n      .prepare(\n        `\n      SELECT * FROM hierarchy_nodes WHERE id = ?\n    `\n      )\n      .get(nodeId) as any;\n\n    if (!nodeRow) return null;\n\n    // Load content if exists\n    const contentRow = this.db\n      .prepare(\n        `\n      SELECT * FROM hierarchy_content WHERE node_id = ?\n    `\n      )\n      .get(nodeId) as any;\n\n    // Load children\n    const childRows = this.db\n      .prepare(\n        `\n      SELECT id FROM hierarchy_nodes WHERE parent_id = ?\n    `\n      )\n      .all(nodeId) as any[];\n\n    const children: RetrievalNode[] = [];\n    for (const childRow of childRows) {\n      const child = await this.loadNode(childRow.id);\n      if (child) children.push(child);\n    }\n\n    const node: RetrievalNode = {\n      id: nodeRow.id,\n      level: {\n        level: nodeRow.level as any,\n        id: nodeRow.id,\n        parentId: nodeRow.parent_id,\n        title: nodeRow.title,\n        summary: nodeRow.summary,\n        childCount: nodeRow.child_count,\n        tokenCount: nodeRow.token_count,\n        score: nodeRow.score,\n        timeRange: {\n          start: nodeRow.time_start,\n          end: nodeRow.time_end,\n        },\n        metadata: {\n          compressionRatio: nodeRow.compression_ratio,\n          semanticDensity: nodeRow.semantic_density,\n          accessPattern: nodeRow.access_pattern as any,\n          lastAccessed: nodeRow.last_accessed,\n        },\n      },\n      children: children.length > 0 ? children : undefined,\n      content: contentRow?.content,\n      compressed: contentRow?.compressed === 1,\n    };\n\n    // Cache the node\n    this.hierarchyCache.set(nodeId, node);\n\n    return node;\n  }\n\n  /**\n   * Update access pattern for a node\n   */\n  private async updateAccessPattern(nodeId: string): Promise<void> {\n    this.db\n      .prepare(\n        `\n      UPDATE hierarchy_nodes\n      SET last_accessed = ?, access_pattern = 'hot'\n      WHERE id = ?\n    `\n      )\n      .run(Date.now(), nodeId);\n  }\n\n  /**\n   * Generate unique ID\n   */\n  private generateId(prefix: string): string {\n    return `${prefix}_${crypto.randomBytes(8).toString('hex')}`;\n  }\n\n  /**\n   * Get hierarchy statistics\n   */\n  getStatistics(): any {\n    const stats = this.db\n      .prepare(\n        `\n      SELECT \n        level,\n        COUNT(*) as count,\n        AVG(token_count) as avg_tokens,\n        AVG(child_count) as avg_children,\n        AVG(compression_ratio) as avg_compression,\n        AVG(semantic_density) as avg_density\n      FROM hierarchy_nodes\n      GROUP BY level\n    `\n      )\n      .all();\n\n    const totalNodes = this.db\n      .prepare(\n        `\n      SELECT COUNT(*) as count FROM hierarchy_nodes\n    `\n      )\n      .get() as any;\n\n    const totalContent = this.db\n      .prepare(\n        `\n      SELECT \n        SUM(original_size) as original,\n        SUM(compressed_size) as compressed\n      FROM hierarchy_content\n    `\n      )\n      .get() as any;\n\n    return {\n      nodesByLevel: stats,\n      totalNodes: totalNodes.count,\n      totalContent: {\n        original: totalContent?.original || 0,\n        compressed: totalContent?.compressed || 0,\n        ratio: totalContent?.original\n          ? (1 - totalContent.compressed / totalContent.original).toFixed(2)\n          : 0,\n      },\n      cacheSize: this.hierarchyCache.size,\n    };\n  }\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/core/retrieval/retrieval-benchmarks.js

@@ -0,0 +1,517 @@
+import { logger } from "../monitoring/logger.js";
+import { LLMContextRetrieval } from "./llm-context-retrieval.js";
+import { HierarchicalRetrieval } from "./hierarchical-retrieval.js";
+import { GraphRetrieval } from "./graph-retrieval.js";
+class RetrievalBenchmarks {
+  db;
+  flatRetrieval;
+  hierarchicalRetrieval;
+  graphRetrieval;
+  frameManager;
+  constructor(db, frameManager, projectId) {
+    this.db = db;
+    this.frameManager = frameManager;
+    this.flatRetrieval = new LLMContextRetrieval(db, frameManager, projectId);
+    this.hierarchicalRetrieval = new HierarchicalRetrieval(db);
+    this.graphRetrieval = new GraphRetrieval(db);
+    this.initializeSchema();
+  }
+  initializeSchema() {
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS benchmark_results (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        timestamp INTEGER DEFAULT (unixepoch() * 1000),
+        strategy TEXT NOT NULL,
+        query TEXT NOT NULL,
+        difficulty TEXT,
+        category TEXT,
+        precision REAL,
+        recall REAL,
+        f1_score REAL,
+        query_time_ms INTEGER,
+        tokens_used INTEGER,
+        semantic_drift REAL,
+        trace_count INTEGER,
+        retrieved_ids TEXT,
+        expected_ids TEXT
+      )
+    `);
+    this.db.exec(`
+      CREATE INDEX IF NOT EXISTS idx_benchmark_strategy ON benchmark_results(strategy);
+      CREATE INDEX IF NOT EXISTS idx_benchmark_timestamp ON benchmark_results(timestamp);
+      CREATE INDEX IF NOT EXISTS idx_benchmark_difficulty ON benchmark_results(difficulty);
+    `);
+  }
+  /**
+   * Generate benchmark queries based on current data
+   */
+  async generateBenchmarkQueries(traces) {
+    const queries = [];
+    const recentTraces = traces.sort((a, b) => b.metadata.startTime - a.metadata.startTime).slice(0, 10);
+    for (const trace of recentTraces.slice(0, 3)) {
+      queries.push({
+        query: `Show me the ${trace.type} operation from ${new Date(trace.metadata.startTime).toLocaleString()}`,
+        expectedTraceIds: [trace.id],
+        expectedTopics: [trace.type],
+        difficulty: "easy",
+        category: "specific_lookup"
+      });
+    }
+    const topicGroups = this.groupByTopic(traces);
+    for (const [topic, topicTraces] of topicGroups.entries()) {
+      if (topicTraces.length >= 5) {
+        queries.push({
+          query: `What ${topic} operations have been performed recently?`,
+          expectedTraceIds: topicTraces.slice(0, 10).map((t) => t.id),
+          expectedTopics: [topic],
+          difficulty: "medium",
+          category: "topic_search"
+        });
+      }
+    }
+    if (traces.length > 50) {
+      const errorTraces = traces.filter(
+        (t) => t.metadata.errorsEncountered.length > 0
+      );
+      if (errorTraces.length > 0) {
+        queries.push({
+          query: "What errors occurred and how were they resolved?",
+          expectedTraceIds: errorTraces.map((t) => t.id),
+          expectedTopics: ["error", "fix", "debug"],
+          difficulty: "hard",
+          category: "error_analysis"
+        });
+      }
+      const decisionTraces = traces.filter(
+        (t) => t.metadata.decisionsRecorded.length > 0
+      );
+      if (decisionTraces.length > 0) {
+        queries.push({
+          query: "What architectural decisions were made and why?",
+          expectedTraceIds: decisionTraces.map((t) => t.id),
+          expectedTopics: ["decision", "architecture", "design"],
+          difficulty: "hard",
+          category: "decision_tracking"
+        });
+      }
+    }
+    queries.push({
+      query: "something about code",
+      expectedTraceIds: [],
+      expectedTopics: [],
+      difficulty: "hard",
+      category: "vague_query"
+    });
+    queries.push({
+      query: "the thing we did yesterday with the files",
+      expectedTraceIds: [],
+      expectedTopics: [],
+      difficulty: "hard",
+      category: "ambiguous_query"
+    });
+    return queries;
+  }
+  /**
+   * Run benchmarks on all strategies
+   */
+  async runBenchmarks(traces, sampleSize = 10) {
+    logger.info("Starting retrieval benchmarks", {
+      traceCount: traces.length,
+      sampleSize
+    });
+    const queries = await this.generateBenchmarkQueries(traces);
+    const sampledQueries = this.sampleQueries(queries, sampleSize);
+    const results = [];
+    await this.hierarchicalRetrieval.buildHierarchy(traces);
+    const frames = await this.frameManager.getAllFrames();
+    await this.graphRetrieval.buildGraph(traces, frames);
+    for (const query of sampledQueries) {
+      const result = await this.benchmarkFlatRetrieval(query, traces);
+      results.push(result);
+      await this.saveResult(result, traces.length);
+    }
+    for (const query of sampledQueries) {
+      const result = await this.benchmarkHierarchicalRetrieval(query, traces);
+      results.push(result);
+      await this.saveResult(result, traces.length);
+    }
+    for (const query of sampledQueries) {
+      const result = await this.benchmarkGraphRetrieval(query, traces);
+      results.push(result);
+      await this.saveResult(result, traces.length);
+    }
+    const report = this.generateReport(results, traces.length);
+    logger.info("Benchmarks complete", {
+      strategies: 3,
+      queries: sampledQueries.length,
+      avgF1: {
+        flat: report.strategies.flat.avgF1Score,
+        hierarchical: report.strategies.hierarchical.avgF1Score,
+        graph: report.strategies.graph.avgF1Score
+      }
+    });
+    return report;
+  }
+  /**
+   * Benchmark flat embedding retrieval
+   */
+  async benchmarkFlatRetrieval(query, traces) {
+    const startTime = Date.now();
+    try {
+      const result = await this.flatRetrieval.retrieveContext(query.query, {
+        tokenBudget: 4e3
+      });
+      const retrievedIds = result.frames.map((f) => f.id);
+      const queryTime = Date.now() - startTime;
+      return this.evaluateResult(
+        "flat",
+        query,
+        retrievedIds,
+        queryTime,
+        result.tokenUsage.used,
+        "Standard flat embedding retrieval"
+      );
+    } catch (error) {
+      logger.error("Flat retrieval failed", error);
+      return this.createErrorResult("flat", query, error);
+    }
+  }
+  /**
+   * Benchmark hierarchical retrieval
+   */
+  async benchmarkHierarchicalRetrieval(query, traces) {
+    const startTime = Date.now();
+    try {
+      const context = await this.hierarchicalRetrieval.retrieve(
+        query.query,
+        4,
+        4e3
+      );
+      const queryTime = Date.now() - startTime;
+      const retrievedIds = this.extractTraceIds(context);
+      return this.evaluateResult(
+        "hierarchical",
+        query,
+        retrievedIds,
+        queryTime,
+        context.length / 4,
+        // Estimate tokens
+        "Hierarchical retrieval with progressive summarization"
+      );
+    } catch (error) {
+      logger.error("Hierarchical retrieval failed", error);
+      return this.createErrorResult("hierarchical", query, error);
+    }
+  }
+  /**
+   * Benchmark graph retrieval
+   */
+  async benchmarkGraphRetrieval(query, traces) {
+    const startTime = Date.now();
+    try {
+      const paths = await this.graphRetrieval.traverse(query.query, {
+        maxHops: 3,
+        minWeight: 0.3
+      });
+      const queryTime = Date.now() - startTime;
+      const retrievedIds = /* @__PURE__ */ new Set();
+      for (const path of paths) {
+        for (const node of path.nodes) {
+          if (node.metadata.traceIds) {
+            node.metadata.traceIds.forEach((id) => retrievedIds.add(id));
+          }
+        }
+      }
+      return this.evaluateResult(
+        "graph",
+        query,
+        Array.from(retrievedIds),
+        queryTime,
+        paths.length * 100,
+        // Estimate tokens
+        "Graph-based retrieval with explicit relationships"
+      );
+    } catch (error) {
+      logger.error("Graph retrieval failed", error);
+      return this.createErrorResult("graph", query, error);
+    }
+  }
+  /**
+   * Evaluate retrieval results
+   */
+  evaluateResult(strategy, query, retrievedIds, queryTimeMs, tokensUsed, explanation) {
+    const expectedSet = new Set(query.expectedTraceIds);
+    const retrievedSet = new Set(retrievedIds);
+    const truePositives = [...retrievedSet].filter(
+      (id) => expectedSet.has(id)
+    ).length;
+    const falsePositives = retrievedSet.size - truePositives;
+    const falseNegatives = expectedSet.size - truePositives;
+    const precision = retrievedSet.size > 0 ? truePositives / retrievedSet.size : 0;
+    const recall = expectedSet.size > 0 ? truePositives / expectedSet.size : 1;
+    const f1Score = precision + recall > 0 ? 2 * (precision * recall) / (precision + recall) : 0;
+    const semanticDrift = this.calculateSemanticDrift(query, retrievedIds);
+    return {
+      strategy,
+      query,
+      retrievedTraceIds: retrievedIds,
+      precision,
+      recall,
+      f1Score,
+      queryTimeMs,
+      tokensUsed,
+      semanticDrift,
+      explanation
+    };
+  }
+  /**
+   * Calculate semantic drift indicator
+   */
+  calculateSemanticDrift(query, retrievedIds) {
+    if (query.category === "vague_query" && retrievedIds.length > 10) {
+      return 0.8;
+    }
+    if (query.category === "specific_lookup" && retrievedIds.length === 0) {
+      return 0.7;
+    }
+    return 0.1;
+  }
+  /**
+   * Create error result
+   */
+  createErrorResult(strategy, query, error) {
+    return {
+      strategy,
+      query,
+      retrievedTraceIds: [],
+      precision: 0,
+      recall: 0,
+      f1Score: 0,
+      queryTimeMs: 0,
+      tokensUsed: 0,
+      semanticDrift: 1,
+      explanation: `Error: ${error.message}`
+    };
+  }
+  /**
+   * Generate benchmark report
+   */
+  generateReport(results, traceCount) {
+    const byStrategy = this.groupByStrategy(results);
+    const report = {
+      timestamp: Date.now(),
+      traceCount,
+      strategies: {
+        flat: this.calculateStrategyMetrics(byStrategy.flat || []),
+        hierarchical: this.calculateStrategyMetrics(
+          byStrategy.hierarchical || []
+        ),
+        graph: this.calculateStrategyMetrics(byStrategy.graph || [])
+      },
+      warnings: [],
+      recommendations: []
+    };
+    if (report.strategies.flat.semanticCollapse) {
+      report.warnings.push("Flat embedding shows signs of semantic collapse");
+    }
+    if (report.strategies.flat.avgQueryTime > 1e3) {
+      report.warnings.push("Flat retrieval query time exceeds 1 second");
+    }
+    const bestStrategy = this.getBestStrategy(report.strategies);
+    report.recommendations.push(`Best overall strategy: ${bestStrategy}`);
+    if (traceCount > 1e4) {
+      report.recommendations.push("Consider hierarchical retrieval for scale");
+    }
+    if (report.strategies.graph.avgF1Score > report.strategies.flat.avgF1Score * 1.2) {
+      report.recommendations.push(
+        "Graph retrieval significantly outperforms flat - consider switching"
+      );
+    }
+    return report;
+  }
+  /**
+   * Calculate strategy metrics
+   */
+  calculateStrategyMetrics(results) {
+    if (results.length === 0) {
+      return {
+        avgPrecision: 0,
+        avgRecall: 0,
+        avgF1Score: 0,
+        avgQueryTime: 0,
+        avgTokensUsed: 0,
+        semanticCollapse: false,
+        collapseIndicators: []
+      };
+    }
+    const avgPrecision = results.reduce((sum, r) => sum + r.precision, 0) / results.length;
+    const avgRecall = results.reduce((sum, r) => sum + r.recall, 0) / results.length;
+    const avgF1Score = results.reduce((sum, r) => sum + r.f1Score, 0) / results.length;
+    const avgQueryTime = results.reduce((sum, r) => sum + r.queryTimeMs, 0) / results.length;
+    const avgTokensUsed = results.reduce((sum, r) => sum + r.tokensUsed, 0) / results.length;
+    const collapseIndicators = [];
+    const avgDrift = results.reduce((sum, r) => sum + (r.semanticDrift || 0), 0) / results.length;
+    if (avgDrift > 0.5) {
+      collapseIndicators.push("High semantic drift detected");
+    }
+    const uniqueResults = new Set(
+      results.map((r) => r.retrievedTraceIds.sort().join(","))
+    );
+    if (uniqueResults.size < results.length * 0.3) {
+      collapseIndicators.push(
+        "Low result diversity - possible embedding collapse"
+      );
+    }
+    const specificQueries = results.filter(
+      (r) => r.query.difficulty === "easy"
+    );
+    const specificPrecision = specificQueries.reduce((sum, r) => sum + r.precision, 0) / (specificQueries.length || 1);
+    if (specificPrecision < 0.5) {
+      collapseIndicators.push("Poor precision on specific queries");
+    }
+    return {
+      avgPrecision,
+      avgRecall,
+      avgF1Score,
+      avgQueryTime,
+      avgTokensUsed,
+      semanticCollapse: collapseIndicators.length > 0,
+      collapseIndicators
+    };
+  }
+  /**
+   * Determine best strategy
+   */
+  getBestStrategy(strategies) {
+    const scores = {
+      flat: strategies.flat.avgF1Score * (1 - strategies.flat.avgQueryTime / 5e3),
+      hierarchical: strategies.hierarchical.avgF1Score * (1 - strategies.hierarchical.avgQueryTime / 5e3),
+      graph: strategies.graph.avgF1Score * (1 - strategies.graph.avgQueryTime / 5e3)
+    };
+    return Object.entries(scores).sort((a, b) => b[1] - a[1])[0][0];
+  }
+  /**
+   * Group traces by topic
+   */
+  groupByTopic(traces) {
+    const groups = /* @__PURE__ */ new Map();
+    for (const trace of traces) {
+      if (!groups.has(trace.type)) {
+        groups.set(trace.type, []);
+      }
+      groups.get(trace.type).push(trace);
+    }
+    return groups;
+  }
+  /**
+   * Group results by strategy
+   */
+  groupByStrategy(results) {
+    const grouped = {};
+    for (const result of results) {
+      if (!grouped[result.strategy]) {
+        grouped[result.strategy] = [];
+      }
+      grouped[result.strategy].push(result);
+    }
+    return grouped;
+  }
+  /**
+   * Sample queries for benchmarking
+   */
+  sampleQueries(queries, sampleSize) {
+    const byDifficulty = this.groupByDifficulty(queries);
+    const sampled = [];
+    const perDifficulty = Math.ceil(sampleSize / 3);
+    for (const difficulty of ["easy", "medium", "hard"]) {
+      const difficultyQueries = byDifficulty[difficulty] || [];
+      const sample = this.randomSample(difficultyQueries, perDifficulty);
+      sampled.push(...sample);
+    }
+    return sampled.slice(0, sampleSize);
+  }
+  /**
+   * Group queries by difficulty
+   */
+  groupByDifficulty(queries) {
+    const grouped = {};
+    for (const query of queries) {
+      if (!grouped[query.difficulty]) {
+        grouped[query.difficulty] = [];
+      }
+      grouped[query.difficulty].push(query);
+    }
+    return grouped;
+  }
+  /**
+   * Random sample from array
+   */
+  randomSample(array, size) {
+    const shuffled = [...array].sort(() => Math.random() - 0.5);
+    return shuffled.slice(0, size);
+  }
+  /**
+   * Extract trace IDs from context string
+   */
+  extractTraceIds(context) {
+    const matches = context.match(/trace_[a-f0-9]{16}/g) || [];
+    return [...new Set(matches)];
+  }
+  /**
+   * Save benchmark result to database
+   */
+  async saveResult(result, traceCount) {
+    this.db.prepare(
+      `
+      INSERT INTO benchmark_results (
+        strategy, query, difficulty, category,
+        precision, recall, f1_score,
+        query_time_ms, tokens_used, semantic_drift,
+        trace_count, retrieved_ids, expected_ids
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `
+    ).run(
+      result.strategy,
+      result.query.query,
+      result.query.difficulty,
+      result.query.category,
+      result.precision,
+      result.recall,
+      result.f1Score,
+      result.queryTimeMs,
+      result.tokensUsed,
+      result.semanticDrift || 0,
+      traceCount,
+      JSON.stringify(result.retrievedTraceIds),
+      JSON.stringify(result.query.expectedTraceIds)
+    );
+  }
+  /**
+   * Get historical benchmark trends
+   */
+  getHistoricalTrends(days = 7) {
+    const cutoff = Date.now() - days * 24 * 60 * 60 * 1e3;
+    const trends = this.db.prepare(
+      `
+      SELECT 
+        strategy,
+        DATE(timestamp / 1000, 'unixepoch') as date,
+        AVG(precision) as avg_precision,
+        AVG(recall) as avg_recall,
+        AVG(f1_score) as avg_f1,
+        AVG(query_time_ms) as avg_query_time,
+        AVG(semantic_drift) as avg_drift,
+        COUNT(*) as query_count
+      FROM benchmark_results
+      WHERE timestamp > ?
+      GROUP BY strategy, date
+      ORDER BY date, strategy
+    `
+    ).all(cutoff);
+    return trends;
+  }
+}
+export {
+  RetrievalBenchmarks
+};
+//# sourceMappingURL=retrieval-benchmarks.js.map