@stackmemoryai/stackmemory 0.5.59 → 0.5.62

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

@@ -1,521 +0,0 @@
-import { fileURLToPath as __fileURLToPath } from 'url';
-import { dirname as __pathDirname } from 'path';
-const __filename = __fileURLToPath(import.meta.url);
-const __dirname = __pathDirname(__filename);
-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

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

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../src/core/retrieval/retrieval-benchmarks.ts"],
-  "sourcesContent": ["/**\n * Retrieval Quality Benchmarks at Scale\n * Tests different retrieval strategies to monitor for semantic collapse\n *\n * Key metrics:\n * - Precision: How relevant are retrieved results?\n * - Recall: Are we missing important context?\n * - Semantic Drift: Do embeddings collapse over time?\n * - Query Latency: Performance at scale\n */\n\nimport Database from 'better-sqlite3';\nimport { logger } from '../monitoring/logger.js';\nimport { Trace } from '../trace/types.js';\nimport { LLMContextRetrieval } from './llm-context-retrieval.js';\nimport { HierarchicalRetrieval } from './hierarchical-retrieval.js';\nimport { GraphRetrieval } from './graph-retrieval.js';\nimport { FrameManager } from '../context/index.js';\n\nexport interface BenchmarkQuery {\n  query: string;\n  expectedTraceIds: string[];\n  expectedTopics: string[];\n  difficulty: 'easy' | 'medium' | 'hard';\n  category: string;\n}\n\nexport interface BenchmarkResult {\n  strategy: 'flat' | 'hierarchical' | 'graph';\n  query: BenchmarkQuery;\n  retrievedTraceIds: string[];\n  precision: number;\n  recall: number;\n  f1Score: number;\n  queryTimeMs: number;\n  tokensUsed: number;\n  semanticDrift?: number;\n  explanation: string;\n}\n\nexport interface BenchmarkReport {\n  timestamp: number;\n  traceCount: number;\n  strategies: {\n    flat: StrategyMetrics;\n    hierarchical: StrategyMetrics;\n    graph: StrategyMetrics;\n  };\n  warnings: string[];\n  recommendations: string[];\n}\n\nexport interface StrategyMetrics {\n  avgPrecision: number;\n  avgRecall: number;\n  avgF1Score: number;\n  avgQueryTime: number;\n  avgTokensUsed: number;\n  semanticCollapse: boolean;\n  collapseIndicators: string[];\n}\n\n/**\n * Benchmark suite for retrieval quality at scale\n */\nexport class RetrievalBenchmarks {\n  private db: Database.Database;\n  private flatRetrieval: LLMContextRetrieval;\n  private hierarchicalRetrieval: HierarchicalRetrieval;\n  private graphRetrieval: GraphRetrieval;\n  private frameManager: FrameManager;\n\n  constructor(\n    db: Database.Database,\n    frameManager: FrameManager,\n    projectId: string\n  ) {\n    this.db = db;\n    this.frameManager = frameManager;\n\n    // Initialize retrieval strategies\n    this.flatRetrieval = new LLMContextRetrieval(db, frameManager, projectId);\n    this.hierarchicalRetrieval = new HierarchicalRetrieval(db);\n    this.graphRetrieval = new GraphRetrieval(db);\n\n    this.initializeSchema();\n  }\n\n  private initializeSchema(): void {\n    this.db.exec(`\n      CREATE TABLE IF NOT EXISTS benchmark_results (\n        id INTEGER PRIMARY KEY AUTOINCREMENT,\n        timestamp INTEGER DEFAULT (unixepoch() * 1000),\n        strategy TEXT NOT NULL,\n        query TEXT NOT NULL,\n        difficulty TEXT,\n        category TEXT,\n        precision REAL,\n        recall REAL,\n        f1_score REAL,\n        query_time_ms INTEGER,\n        tokens_used INTEGER,\n        semantic_drift REAL,\n        trace_count INTEGER,\n        retrieved_ids TEXT,\n        expected_ids TEXT\n      )\n    `);\n\n    this.db.exec(`\n      CREATE INDEX IF NOT EXISTS idx_benchmark_strategy ON benchmark_results(strategy);\n      CREATE INDEX IF NOT EXISTS idx_benchmark_timestamp ON benchmark_results(timestamp);\n      CREATE INDEX IF NOT EXISTS idx_benchmark_difficulty ON benchmark_results(difficulty);\n    `);\n  }\n\n  /**\n   * Generate benchmark queries based on current data\n   */\n  async generateBenchmarkQueries(traces: Trace[]): Promise<BenchmarkQuery[]> {\n    const queries: BenchmarkQuery[] = [];\n\n    // Easy: Recent specific traces\n    const recentTraces = traces\n      .sort((a, b) => b.metadata.startTime - a.metadata.startTime)\n      .slice(0, 10);\n\n    for (const trace of recentTraces.slice(0, 3)) {\n      queries.push({\n        query: `Show me the ${trace.type} operation from ${new Date(trace.metadata.startTime).toLocaleString()}`,\n        expectedTraceIds: [trace.id],\n        expectedTopics: [trace.type],\n        difficulty: 'easy',\n        category: 'specific_lookup',\n      });\n    }\n\n    // Medium: Topic-based queries\n    const topicGroups = this.groupByTopic(traces);\n\n    for (const [topic, topicTraces] of topicGroups.entries()) {\n      if (topicTraces.length >= 5) {\n        queries.push({\n          query: `What ${topic} operations have been performed recently?`,\n          expectedTraceIds: topicTraces.slice(0, 10).map((t) => t.id),\n          expectedTopics: [topic],\n          difficulty: 'medium',\n          category: 'topic_search',\n        });\n      }\n    }\n\n    // Hard: Cross-topic and temporal queries\n    if (traces.length > 50) {\n      // Find traces with errors\n      const errorTraces = traces.filter(\n        (t) => t.metadata.errorsEncountered.length > 0\n      );\n\n      if (errorTraces.length > 0) {\n        queries.push({\n          query: 'What errors occurred and how were they resolved?',\n          expectedTraceIds: errorTraces.map((t) => t.id),\n          expectedTopics: ['error', 'fix', 'debug'],\n          difficulty: 'hard',\n          category: 'error_analysis',\n        });\n      }\n\n      // Find decision chains\n      const decisionTraces = traces.filter(\n        (t) => t.metadata.decisionsRecorded.length > 0\n      );\n\n      if (decisionTraces.length > 0) {\n        queries.push({\n          query: 'What architectural decisions were made and why?',\n          expectedTraceIds: decisionTraces.map((t) => t.id),\n          expectedTopics: ['decision', 'architecture', 'design'],\n          difficulty: 'hard',\n          category: 'decision_tracking',\n        });\n      }\n    }\n\n    // Adversarial: Test for semantic collapse\n    queries.push({\n      query: 'something about code',\n      expectedTraceIds: [],\n      expectedTopics: [],\n      difficulty: 'hard',\n      category: 'vague_query',\n    });\n\n    queries.push({\n      query: 'the thing we did yesterday with the files',\n      expectedTraceIds: [],\n      expectedTopics: [],\n      difficulty: 'hard',\n      category: 'ambiguous_query',\n    });\n\n    return queries;\n  }\n\n  /**\n   * Run benchmarks on all strategies\n   */\n  async runBenchmarks(\n    traces: Trace[],\n    sampleSize: number = 10\n  ): Promise<BenchmarkReport> {\n    logger.info('Starting retrieval benchmarks', {\n      traceCount: traces.length,\n      sampleSize,\n    });\n\n    const queries = await this.generateBenchmarkQueries(traces);\n    const sampledQueries = this.sampleQueries(queries, sampleSize);\n\n    const results: BenchmarkResult[] = [];\n\n    // Build hierarchical and graph structures\n    await this.hierarchicalRetrieval.buildHierarchy(traces);\n    const frames = await this.frameManager.getAllFrames();\n    await this.graphRetrieval.buildGraph(traces, frames);\n\n    // Test flat retrieval\n    for (const query of sampledQueries) {\n      const result = await this.benchmarkFlatRetrieval(query, traces);\n      results.push(result);\n      await this.saveResult(result, traces.length);\n    }\n\n    // Test hierarchical retrieval\n    for (const query of sampledQueries) {\n      const result = await this.benchmarkHierarchicalRetrieval(query, traces);\n      results.push(result);\n      await this.saveResult(result, traces.length);\n    }\n\n    // Test graph retrieval\n    for (const query of sampledQueries) {\n      const result = await this.benchmarkGraphRetrieval(query, traces);\n      results.push(result);\n      await this.saveResult(result, traces.length);\n    }\n\n    // Generate report\n    const report = this.generateReport(results, traces.length);\n\n    logger.info('Benchmarks complete', {\n      strategies: 3,\n      queries: sampledQueries.length,\n      avgF1: {\n        flat: report.strategies.flat.avgF1Score,\n        hierarchical: report.strategies.hierarchical.avgF1Score,\n        graph: report.strategies.graph.avgF1Score,\n      },\n    });\n\n    return report;\n  }\n\n  /**\n   * Benchmark flat embedding retrieval\n   */\n  private async benchmarkFlatRetrieval(\n    query: BenchmarkQuery,\n    traces: Trace[]\n  ): Promise<BenchmarkResult> {\n    const startTime = Date.now();\n\n    try {\n      const result = await this.flatRetrieval.retrieveContext(query.query, {\n        tokenBudget: 4000,\n      });\n\n      const retrievedIds = result.frames.map((f) => f.id);\n      const queryTime = Date.now() - startTime;\n\n      return this.evaluateResult(\n        'flat',\n        query,\n        retrievedIds,\n        queryTime,\n        result.tokenUsage.used,\n        'Standard flat embedding retrieval'\n      );\n    } catch (error: unknown) {\n      logger.error('Flat retrieval failed', error);\n      return this.createErrorResult('flat', query, error as Error);\n    }\n  }\n\n  /**\n   * Benchmark hierarchical retrieval\n   */\n  private async benchmarkHierarchicalRetrieval(\n    query: BenchmarkQuery,\n    traces: Trace[]\n  ): Promise<BenchmarkResult> {\n    const startTime = Date.now();\n\n    try {\n      const context = await this.hierarchicalRetrieval.retrieve(\n        query.query,\n        4,\n        4000\n      );\n\n      const queryTime = Date.now() - startTime;\n\n      // Extract trace IDs from context (simplified)\n      const retrievedIds = this.extractTraceIds(context);\n\n      return this.evaluateResult(\n        'hierarchical',\n        query,\n        retrievedIds,\n        queryTime,\n        context.length / 4, // Estimate tokens\n        'Hierarchical retrieval with progressive summarization'\n      );\n    } catch (error: unknown) {\n      logger.error('Hierarchical retrieval failed', error);\n      return this.createErrorResult('hierarchical', query, error as Error);\n    }\n  }\n\n  /**\n   * Benchmark graph retrieval\n   */\n  private async benchmarkGraphRetrieval(\n    query: BenchmarkQuery,\n    traces: Trace[]\n  ): Promise<BenchmarkResult> {\n    const startTime = Date.now();\n\n    try {\n      const paths = await this.graphRetrieval.traverse(query.query, {\n        maxHops: 3,\n        minWeight: 0.3,\n      });\n\n      const queryTime = Date.now() - startTime;\n\n      // Extract trace IDs from paths\n      const retrievedIds = new Set<string>();\n      for (const path of paths) {\n        for (const node of path.nodes) {\n          if (node.metadata.traceIds) {\n            node.metadata.traceIds.forEach((id) => retrievedIds.add(id));\n          }\n        }\n      }\n\n      return this.evaluateResult(\n        'graph',\n        query,\n        Array.from(retrievedIds),\n        queryTime,\n        paths.length * 100, // Estimate tokens\n        'Graph-based retrieval with explicit relationships'\n      );\n    } catch (error: unknown) {\n      logger.error('Graph retrieval failed', error);\n      return this.createErrorResult('graph', query, error as Error);\n    }\n  }\n\n  /**\n   * Evaluate retrieval results\n   */\n  private evaluateResult(\n    strategy: 'flat' | 'hierarchical' | 'graph',\n    query: BenchmarkQuery,\n    retrievedIds: string[],\n    queryTimeMs: number,\n    tokensUsed: number,\n    explanation: string\n  ): BenchmarkResult {\n    const expectedSet = new Set(query.expectedTraceIds);\n    const retrievedSet = new Set(retrievedIds);\n\n    // Calculate metrics\n    const truePositives = [...retrievedSet].filter((id) =>\n      expectedSet.has(id)\n    ).length;\n    const falsePositives = retrievedSet.size - truePositives;\n    const falseNegatives = expectedSet.size - truePositives;\n\n    const precision =\n      retrievedSet.size > 0 ? truePositives / retrievedSet.size : 0;\n    const recall = expectedSet.size > 0 ? truePositives / expectedSet.size : 1;\n    const f1Score =\n      precision + recall > 0\n        ? (2 * (precision * recall)) / (precision + recall)\n        : 0;\n\n    // Check for semantic drift (simplified)\n    const semanticDrift = this.calculateSemanticDrift(query, retrievedIds);\n\n    return {\n      strategy,\n      query,\n      retrievedTraceIds: retrievedIds,\n      precision,\n      recall,\n      f1Score,\n      queryTimeMs,\n      tokensUsed,\n      semanticDrift,\n      explanation,\n    };\n  }\n\n  /**\n   * Calculate semantic drift indicator\n   */\n  private calculateSemanticDrift(\n    query: BenchmarkQuery,\n    retrievedIds: string[]\n  ): number {\n    // If vague query returns too many results, indicates collapse\n    if (query.category === 'vague_query' && retrievedIds.length > 10) {\n      return 0.8; // High drift\n    }\n\n    // If specific query returns nothing, indicates problem\n    if (query.category === 'specific_lookup' && retrievedIds.length === 0) {\n      return 0.7;\n    }\n\n    return 0.1; // Normal\n  }\n\n  /**\n   * Create error result\n   */\n  private createErrorResult(\n    strategy: 'flat' | 'hierarchical' | 'graph',\n    query: BenchmarkQuery,\n    error: Error\n  ): BenchmarkResult {\n    return {\n      strategy,\n      query,\n      retrievedTraceIds: [],\n      precision: 0,\n      recall: 0,\n      f1Score: 0,\n      queryTimeMs: 0,\n      tokensUsed: 0,\n      semanticDrift: 1.0,\n      explanation: `Error: ${error.message}`,\n    };\n  }\n\n  /**\n   * Generate benchmark report\n   */\n  private generateReport(\n    results: BenchmarkResult[],\n    traceCount: number\n  ): BenchmarkReport {\n    const byStrategy = this.groupByStrategy(results);\n\n    const report: BenchmarkReport = {\n      timestamp: Date.now(),\n      traceCount,\n      strategies: {\n        flat: this.calculateStrategyMetrics(byStrategy.flat || []),\n        hierarchical: this.calculateStrategyMetrics(\n          byStrategy.hierarchical || []\n        ),\n        graph: this.calculateStrategyMetrics(byStrategy.graph || []),\n      },\n      warnings: [],\n      recommendations: [],\n    };\n\n    // Generate warnings\n    if (report.strategies.flat.semanticCollapse) {\n      report.warnings.push('Flat embedding shows signs of semantic collapse');\n    }\n\n    if (report.strategies.flat.avgQueryTime > 1000) {\n      report.warnings.push('Flat retrieval query time exceeds 1 second');\n    }\n\n    // Generate recommendations\n    const bestStrategy = this.getBestStrategy(report.strategies);\n    report.recommendations.push(`Best overall strategy: ${bestStrategy}`);\n\n    if (traceCount > 10000) {\n      report.recommendations.push('Consider hierarchical retrieval for scale');\n    }\n\n    if (\n      report.strategies.graph.avgF1Score >\n      report.strategies.flat.avgF1Score * 1.2\n    ) {\n      report.recommendations.push(\n        'Graph retrieval significantly outperforms flat - consider switching'\n      );\n    }\n\n    return report;\n  }\n\n  /**\n   * Calculate strategy metrics\n   */\n  private calculateStrategyMetrics(\n    results: BenchmarkResult[]\n  ): StrategyMetrics {\n    if (results.length === 0) {\n      return {\n        avgPrecision: 0,\n        avgRecall: 0,\n        avgF1Score: 0,\n        avgQueryTime: 0,\n        avgTokensUsed: 0,\n        semanticCollapse: false,\n        collapseIndicators: [],\n      };\n    }\n\n    const avgPrecision =\n      results.reduce((sum, r) => sum + r.precision, 0) / results.length;\n    const avgRecall =\n      results.reduce((sum, r) => sum + r.recall, 0) / results.length;\n    const avgF1Score =\n      results.reduce((sum, r) => sum + r.f1Score, 0) / results.length;\n    const avgQueryTime =\n      results.reduce((sum, r) => sum + r.queryTimeMs, 0) / results.length;\n    const avgTokensUsed =\n      results.reduce((sum, r) => sum + r.tokensUsed, 0) / results.length;\n\n    // Check for semantic collapse\n    const collapseIndicators: string[] = [];\n    const avgDrift =\n      results.reduce((sum, r) => sum + (r.semanticDrift || 0), 0) /\n      results.length;\n\n    if (avgDrift > 0.5) {\n      collapseIndicators.push('High semantic drift detected');\n    }\n\n    // Check for uniform results (everything returns same thing)\n    const uniqueResults = new Set(\n      results.map((r) => r.retrievedTraceIds.sort().join(','))\n    );\n    if (uniqueResults.size < results.length * 0.3) {\n      collapseIndicators.push(\n        'Low result diversity - possible embedding collapse'\n      );\n    }\n\n    // Check for poor precision on specific queries\n    const specificQueries = results.filter(\n      (r) => r.query.difficulty === 'easy'\n    );\n    const specificPrecision =\n      specificQueries.reduce((sum, r) => sum + r.precision, 0) /\n      (specificQueries.length || 1);\n    if (specificPrecision < 0.5) {\n      collapseIndicators.push('Poor precision on specific queries');\n    }\n\n    return {\n      avgPrecision,\n      avgRecall,\n      avgF1Score,\n      avgQueryTime,\n      avgTokensUsed,\n      semanticCollapse: collapseIndicators.length > 0,\n      collapseIndicators,\n    };\n  }\n\n  /**\n   * Determine best strategy\n   */\n  private getBestStrategy(strategies: BenchmarkReport['strategies']): string {\n    const scores = {\n      flat:\n        strategies.flat.avgF1Score * (1 - strategies.flat.avgQueryTime / 5000),\n      hierarchical:\n        strategies.hierarchical.avgF1Score *\n        (1 - strategies.hierarchical.avgQueryTime / 5000),\n      graph:\n        strategies.graph.avgF1Score *\n        (1 - strategies.graph.avgQueryTime / 5000),\n    };\n\n    return Object.entries(scores).sort((a, b) => b[1] - a[1])[0][0];\n  }\n\n  /**\n   * Group traces by topic\n   */\n  private groupByTopic(traces: Trace[]): Map<string, Trace[]> {\n    const groups = new Map<string, Trace[]>();\n\n    for (const trace of traces) {\n      if (!groups.has(trace.type)) {\n        groups.set(trace.type, []);\n      }\n      groups.get(trace.type)!.push(trace);\n    }\n\n    return groups;\n  }\n\n  /**\n   * Group results by strategy\n   */\n  private groupByStrategy(\n    results: BenchmarkResult[]\n  ): Record<string, BenchmarkResult[]> {\n    const grouped: Record<string, BenchmarkResult[]> = {};\n\n    for (const result of results) {\n      if (!grouped[result.strategy]) {\n        grouped[result.strategy] = [];\n      }\n      grouped[result.strategy].push(result);\n    }\n\n    return grouped;\n  }\n\n  /**\n   * Sample queries for benchmarking\n   */\n  private sampleQueries(\n    queries: BenchmarkQuery[],\n    sampleSize: number\n  ): BenchmarkQuery[] {\n    // Ensure we get a mix of difficulties\n    const byDifficulty = this.groupByDifficulty(queries);\n    const sampled: BenchmarkQuery[] = [];\n\n    const perDifficulty = Math.ceil(sampleSize / 3);\n\n    for (const difficulty of ['easy', 'medium', 'hard'] as const) {\n      const difficultyQueries = byDifficulty[difficulty] || [];\n      const sample = this.randomSample(difficultyQueries, perDifficulty);\n      sampled.push(...sample);\n    }\n\n    return sampled.slice(0, sampleSize);\n  }\n\n  /**\n   * Group queries by difficulty\n   */\n  private groupByDifficulty(\n    queries: BenchmarkQuery[]\n  ): Record<string, BenchmarkQuery[]> {\n    const grouped: Record<string, BenchmarkQuery[]> = {};\n\n    for (const query of queries) {\n      if (!grouped[query.difficulty]) {\n        grouped[query.difficulty] = [];\n      }\n      grouped[query.difficulty].push(query);\n    }\n\n    return grouped;\n  }\n\n  /**\n   * Random sample from array\n   */\n  private randomSample<T>(array: T[], size: number): T[] {\n    const shuffled = [...array].sort(() => Math.random() - 0.5);\n    return shuffled.slice(0, size);\n  }\n\n  /**\n   * Extract trace IDs from context string\n   */\n  private extractTraceIds(context: string): string[] {\n    // Simple pattern matching for trace IDs\n    const matches = context.match(/trace_[a-f0-9]{16}/g) || [];\n    return [...new Set(matches)];\n  }\n\n  /**\n   * Save benchmark result to database\n   */\n  private async saveResult(\n    result: BenchmarkResult,\n    traceCount: number\n  ): Promise<void> {\n    this.db\n      .prepare(\n        `\n      INSERT INTO benchmark_results (\n        strategy, query, difficulty, category,\n        precision, recall, f1_score,\n        query_time_ms, tokens_used, semantic_drift,\n        trace_count, retrieved_ids, expected_ids\n      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)\n    `\n      )\n      .run(\n        result.strategy,\n        result.query.query,\n        result.query.difficulty,\n        result.query.category,\n        result.precision,\n        result.recall,\n        result.f1Score,\n        result.queryTimeMs,\n        result.tokensUsed,\n        result.semanticDrift || 0,\n        traceCount,\n        JSON.stringify(result.retrievedTraceIds),\n        JSON.stringify(result.query.expectedTraceIds)\n      );\n  }\n\n  /**\n   * Get historical benchmark trends\n   */\n  getHistoricalTrends(days: number = 7): any {\n    const cutoff = Date.now() - days * 24 * 60 * 60 * 1000;\n\n    const trends = this.db\n      .prepare(\n        `\n      SELECT \n        strategy,\n        DATE(timestamp / 1000, 'unixepoch') as date,\n        AVG(precision) as avg_precision,\n        AVG(recall) as avg_recall,\n        AVG(f1_score) as avg_f1,\n        AVG(query_time_ms) as avg_query_time,\n        AVG(semantic_drift) as avg_drift,\n        COUNT(*) as query_count\n      FROM benchmark_results\n      WHERE timestamp > ?\n      GROUP BY strategy, date\n      ORDER BY date, strategy\n    `\n      )\n      .all(cutoff);\n\n    return trends;\n  }\n}\n"],
-  "mappings": "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",
-  "names": []
-}