@stackmemoryai/stackmemory 0.5.58 → 0.5.59

package/dist/src/core/performance/performance-benchmark.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/core/performance/performance-benchmark.ts"],
+  "sourcesContent": ["/**\n * Performance Benchmark Suite\n * Measure improvements from optimization efforts\n */\n\nimport { performance } from 'perf_hooks';\nimport { logger } from '../monitoring/logger.js';\nimport { StreamingJSONLParser } from './streaming-jsonl-parser.js';\nimport { ContextCache } from './context-cache.js';\nimport { LazyContextLoader } from './lazy-context-loader.js';\nimport { readFileSync } from 'fs';\nimport { join } from 'path';\n\nexport interface BenchmarkResult {\n  name: string;\n  duration: number;\n  memoryUsed: number;\n  itemsProcessed: number;\n  throughput: number;\n  improvement?: number;\n}\n\nexport interface BenchmarkSuite {\n  name: string;\n  results: BenchmarkResult[];\n  totalDuration: number;\n  averageImprovement: number;\n}\n\nexport class PerformanceBenchmark {\n  private results: BenchmarkResult[] = [];\n\n  /**\n   * Benchmark JSONL parsing performance\n   */\n  async benchmarkJSONLParsing(\n    filePath: string,\n    iterations = 3\n  ): Promise<BenchmarkResult> {\n    const parser = new StreamingJSONLParser();\n\n    // Baseline: traditional sync parsing\n    const baselineStart = performance.now();\n    const baselineMemStart = process.memoryUsage().heapUsed;\n\n    let baselineCount = 0;\n    for (let i = 0; i < iterations; i++) {\n      const content = readFileSync(filePath, 'utf8');\n      const lines = content.split('\\n').filter((l: any) => l.trim());\n      for (const line of lines) {\n        try {\n          JSON.parse(line);\n          baselineCount++;\n        } catch {}\n      }\n    }\n\n    const baselineDuration = performance.now() - baselineStart;\n    const baselineMemUsed = process.memoryUsage().heapUsed - baselineMemStart;\n\n    // Optimized: streaming parser\n    const optimizedStart = performance.now();\n    const optimizedMemStart = process.memoryUsage().heapUsed;\n\n    let optimizedCount = 0;\n    for (let i = 0; i < iterations; i++) {\n      for await (const batch of parser.parseStream(filePath)) {\n        optimizedCount += batch.length;\n      }\n    }\n\n    const optimizedDuration = performance.now() - optimizedStart;\n    const optimizedMemUsed = process.memoryUsage().heapUsed - optimizedMemStart;\n\n    const improvement =\n      ((baselineDuration - optimizedDuration) / baselineDuration) * 100;\n    const memImprovement =\n      ((baselineMemUsed - optimizedMemUsed) / baselineMemUsed) * 100;\n\n    const result: BenchmarkResult = {\n      name: 'JSONL Parsing',\n      duration: optimizedDuration / iterations,\n      memoryUsed: optimizedMemUsed,\n      itemsProcessed: optimizedCount / iterations,\n      throughput:\n        optimizedCount / iterations / (optimizedDuration / 1000 / iterations),\n      improvement,\n    };\n\n    logger.info('JSONL Parsing Benchmark', {\n      baseline: {\n        duration: baselineDuration / iterations,\n        memory: baselineMemUsed,\n        throughput:\n          baselineCount / iterations / (baselineDuration / 1000 / iterations),\n      },\n      optimized: result,\n      improvements: {\n        speed: `${improvement.toFixed(1)}%`,\n        memory: `${memImprovement.toFixed(1)}%`,\n      },\n    });\n\n    this.results.push(result);\n    return result;\n  }\n\n  /**\n   * Benchmark context caching performance\n   */\n  async benchmarkContextCache(\n    itemCount = 1000,\n    accessPatterns = 10000\n  ): Promise<BenchmarkResult> {\n    const cache = new ContextCache<any>({\n      maxSize: 50 * 1024 * 1024,\n      maxItems: itemCount,\n    });\n\n    // Prepare test data\n    const testData = Array.from({ length: itemCount }, (_, i) => ({\n      key: `item-${i}`,\n      value: {\n        id: i,\n        data: 'x'.repeat(Math.floor(Math.random() * 1000)),\n        timestamp: Date.now(),\n      },\n    }));\n\n    // Populate cache\n    const populateStart = performance.now();\n    for (const item of testData) {\n      cache.set(item.key, item.value);\n    }\n    const populateDuration = performance.now() - populateStart;\n\n    // Benchmark cache access\n    const accessStart = performance.now();\n    let hits = 0;\n    let misses = 0;\n\n    for (let i = 0; i < accessPatterns; i++) {\n      const index = Math.floor(Math.random() * itemCount * 1.2); // Some will miss\n      const key = `item-${index}`;\n      const result = cache.get(key);\n      if (result) hits++;\n      else misses++;\n    }\n\n    const accessDuration = performance.now() - accessStart;\n    const stats = cache.getStats();\n\n    const result: BenchmarkResult = {\n      name: 'Context Cache',\n      duration: accessDuration,\n      memoryUsed: cache.getSize().bytes,\n      itemsProcessed: accessPatterns,\n      throughput: accessPatterns / (accessDuration / 1000),\n      improvement: stats.hitRate * 100,\n    };\n\n    logger.info('Context Cache Benchmark', {\n      populate: {\n        duration: populateDuration,\n        items: itemCount,\n      },\n      access: {\n        duration: accessDuration,\n        patterns: accessPatterns,\n        hitRate: `${(stats.hitRate * 100).toFixed(1)}%`,\n      },\n      performance: {\n        throughput: `${result.throughput.toFixed(0)} ops/sec`,\n        avgAccessTime: `${stats.avgAccessTime.toFixed(2)}ms`,\n      },\n    });\n\n    this.results.push(result);\n    return result;\n  }\n\n  /**\n   * Benchmark lazy loading performance\n   */\n  async benchmarkLazyLoading(\n    db: any,\n    projectId: string,\n    frameCount = 100\n  ): Promise<BenchmarkResult> {\n    const loader = new LazyContextLoader(db, projectId);\n\n    // Check if frames table exists, if not use a mock test\n    let frames: any[] = [];\n    try {\n      frames = db\n        .prepare('SELECT id FROM frames ORDER BY updated_at DESC LIMIT ?')\n        .all(frameCount) as any[];\n    } catch (error: unknown) {\n      // Create mock frame IDs if table doesn't exist\n      logger.warn('Frames table not found, using mock data for benchmark');\n      frames = Array.from({ length: Math.min(frameCount, 10) }, (_, i) => ({\n        id: `frame-${i}`,\n      }));\n    }\n\n    const frameIds = frames.map((f: any) => f.id);\n\n    // Benchmark eager loading (baseline)\n    const eagerStart = performance.now();\n    const eagerMemStart = process.memoryUsage().heapUsed;\n\n    const eagerData = [];\n    for (const id of frameIds) {\n      try {\n        const frame = db.prepare('SELECT * FROM frames WHERE id = ?').get(id);\n        const anchors = db\n          .prepare('SELECT * FROM anchors WHERE frame_id = ?')\n          .all(id);\n        const events = db\n          .prepare('SELECT * FROM events WHERE frame_id = ? LIMIT 10')\n          .all(id);\n        eagerData.push({ frame, anchors, events });\n      } catch {\n        // Use mock data if tables don't exist\n        eagerData.push({\n          frame: { id, type: 'mock', name: `Mock ${id}` },\n          anchors: [],\n          events: [],\n        });\n      }\n    }\n\n    const eagerDuration = performance.now() - eagerStart;\n    const eagerMemUsed = process.memoryUsage().heapUsed - eagerMemStart;\n\n    // Benchmark lazy loading\n    const lazyStart = performance.now();\n    const lazyMemStart = process.memoryUsage().heapUsed;\n\n    // Preload with lazy loading\n    await loader.preloadContext(frameIds, { parallel: true, depth: 2 });\n\n    // Access data lazily\n    let accessedCount = 0;\n    for (const id of frameIds.slice(0, frameCount / 2)) {\n      const frame = await loader.lazyFrame(id).get();\n      if (frame) accessedCount++;\n    }\n\n    const lazyDuration = performance.now() - lazyStart;\n    const lazyMemUsed = process.memoryUsage().heapUsed - lazyMemStart;\n\n    const improvement = ((eagerDuration - lazyDuration) / eagerDuration) * 100;\n    const memImprovement = ((eagerMemUsed - lazyMemUsed) / eagerMemUsed) * 100;\n\n    const result: BenchmarkResult = {\n      name: 'Lazy Loading',\n      duration: lazyDuration,\n      memoryUsed: lazyMemUsed,\n      itemsProcessed: frameCount,\n      throughput: frameCount / (lazyDuration / 1000),\n      improvement,\n    };\n\n    logger.info('Lazy Loading Benchmark', {\n      eager: {\n        duration: eagerDuration,\n        memory: eagerMemUsed,\n      },\n      lazy: {\n        duration: lazyDuration,\n        memory: lazyMemUsed,\n        accessed: accessedCount,\n      },\n      improvements: {\n        speed: `${improvement.toFixed(1)}%`,\n        memory: `${memImprovement.toFixed(1)}%`,\n      },\n    });\n\n    this.results.push(result);\n    return result;\n  }\n\n  /**\n   * Run full benchmark suite\n   */\n  async runFullSuite(\n    projectRoot: string,\n    db: any,\n    projectId: string\n  ): Promise<BenchmarkSuite> {\n    const suiteStart = performance.now();\n\n    logger.info('Starting Performance Benchmark Suite');\n\n    // Run benchmarks\n    const tasksFile = join(projectRoot, '.stackmemory', 'tasks.jsonl');\n\n    const jsonlResult = await this.benchmarkJSONLParsing(tasksFile);\n    const cacheResult = await this.benchmarkContextCache();\n    const lazyResult = await this.benchmarkLazyLoading(db, projectId);\n\n    const totalDuration = performance.now() - suiteStart;\n    const averageImprovement =\n      this.results\n        .filter((r: any) => r.improvement !== undefined)\n        .reduce((sum, r) => sum + (r.improvement || 0), 0) /\n      this.results.filter((r: any) => r.improvement !== undefined).length;\n\n    const suite: BenchmarkSuite = {\n      name: 'Performance Optimization Suite',\n      results: this.results,\n      totalDuration,\n      averageImprovement,\n    };\n\n    // Generate summary report\n    this.generateReport(suite);\n\n    return suite;\n  }\n\n  /**\n   * Generate performance report\n   */\n  private generateReport(suite: BenchmarkSuite): void {\n    console.log('\\n\u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557');\n    console.log('\u2551     Performance Benchmark Results         \u2551');\n    console.log('\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D\\n');\n\n    for (const result of suite.results) {\n      console.log(`\uD83D\uDCCA ${result.name}`);\n      console.log(`   Duration: ${result.duration.toFixed(2)}ms`);\n      console.log(\n        `   Memory: ${(result.memoryUsed / 1024 / 1024).toFixed(2)}MB`\n      );\n      console.log(`   Throughput: ${result.throughput.toFixed(0)} items/sec`);\n      if (result.improvement !== undefined) {\n        const icon = result.improvement > 0 ? '\uD83D\uDE80' : '\u26A0\uFE0F';\n        console.log(\n          `   ${icon} Improvement: ${result.improvement.toFixed(1)}%`\n        );\n      }\n      console.log('');\n    }\n\n    console.log('\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550');\n    console.log(`\u23F1\uFE0F  Total Duration: ${suite.totalDuration.toFixed(2)}ms`);\n    console.log(\n      `\uD83D\uDCC8 Average Improvement: ${suite.averageImprovement.toFixed(1)}%`\n    );\n    console.log('');\n\n    logger.info('Performance Benchmark Complete', {\n      suite: suite.name,\n      duration: suite.totalDuration,\n      avgImprovement: suite.averageImprovement,\n      results: suite.results.map((r: any) => ({\n        name: r.name,\n        improvement: r.improvement,\n        throughput: r.throughput,\n      })),\n    });\n  }\n\n  /**\n   * Get benchmark results\n   */\n  getResults(): BenchmarkResult[] {\n    return this.results;\n  }\n\n  /**\n   * Clear results\n   */\n  clearResults(): void {\n    this.results = [];\n  }\n}\n"],
+  "mappings": "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",
+  "names": ["result"]
+}

package/dist/src/core/performance/performance-profiler.js

@@ -0,0 +1,370 @@
+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 { getQueryStatistics } from "../trace/db-trace-wrapper.js";
+function getEnv(key, defaultValue) {
+  const value = process.env[key];
+  if (value === void 0) {
+    if (defaultValue !== void 0) return defaultValue;
+    throw new Error(`Environment variable ${key} is required`);
+  }
+  return value;
+}
+function getOptionalEnv(key) {
+  return process.env[key];
+}
+class PerformanceProfiler {
+  metrics = /* @__PURE__ */ new Map();
+  hotPaths = /* @__PURE__ */ new Map();
+  samples = /* @__PURE__ */ new Map();
+  isEnabled = true;
+  sampleLimit = 1e3;
+  hotPathThreshold = 5;
+  // Operations taking > 5ms are considered hot
+  constructor(options = {}) {
+    this.isEnabled = options.enabled ?? true;
+    this.sampleLimit = options.sampleLimit ?? 1e3;
+    this.hotPathThreshold = options.hotPathThreshold ?? 5;
+  }
+  /**
+   * Start timing an operation
+   */
+  startTiming(operationName) {
+    if (!this.isEnabled) {
+      return () => {
+      };
+    }
+    const startTime = performance.now();
+    return (metadata) => {
+      this.endTiming(operationName, startTime, metadata);
+    };
+  }
+  /**
+   * Time a function execution
+   */
+  async timeFunction(operationName, fn, metadata) {
+    if (!this.isEnabled) {
+      return await fn();
+    }
+    const endTimer = this.startTiming(operationName);
+    try {
+      const result = await fn();
+      endTimer(metadata);
+      return result;
+    } catch (error) {
+      endTimer({ ...metadata, error: true });
+      throw error;
+    }
+  }
+  /**
+   * Record timing manually
+   */
+  recordTiming(operationName, durationMs, metadata) {
+    if (!this.isEnabled) return;
+    this.endTiming(operationName, performance.now() - durationMs, metadata);
+  }
+  /**
+   * Get performance metrics for an operation
+   */
+  getMetrics(operationName) {
+    return this.metrics.get(operationName);
+  }
+  /**
+   * Get all performance metrics
+   */
+  getAllMetrics() {
+    return new Map(this.metrics);
+  }
+  /**
+   * Get hot paths sorted by impact
+   */
+  getHotPaths(limit = 10) {
+    return Array.from(this.hotPaths.values()).sort((a, b) => b.frequency * b.avgDuration - a.frequency * a.avgDuration).slice(0, limit);
+  }
+  /**
+   * Generate comprehensive performance report
+   */
+  generateReport(db) {
+    const hotPaths = this.getHotPaths(20);
+    const recommendations = this.generateRecommendations(hotPaths);
+    const report = {
+      timestamp: Date.now(),
+      hotPaths,
+      databaseMetrics: db ? getQueryStatistics(db) : null,
+      memoryUsage: process.memoryUsage(),
+      cacheMetrics: null,
+      // Will be filled by query cache if available
+      recommendations
+    };
+    logger.info("Performance report generated", {
+      hotPathsCount: hotPaths.length,
+      recommendationsCount: recommendations.length,
+      topHotPath: hotPaths[0]?.path
+    });
+    return report;
+  }
+  /**
+   * Reset all metrics
+   */
+  reset() {
+    this.metrics.clear();
+    this.hotPaths.clear();
+    this.samples.clear();
+    logger.info("Performance metrics reset");
+  }
+  /**
+   * Export metrics to JSON
+   */
+  exportMetrics() {
+    const data = {
+      timestamp: Date.now(),
+      metrics: Object.fromEntries(this.metrics),
+      hotPaths: Object.fromEntries(this.hotPaths),
+      config: {
+        sampleLimit: this.sampleLimit,
+        hotPathThreshold: this.hotPathThreshold,
+        enabled: this.isEnabled
+      }
+    };
+    return JSON.stringify(data, null, 2);
+  }
+  /**
+   * Enable/disable profiling
+   */
+  setEnabled(enabled) {
+    this.isEnabled = enabled;
+    logger.info(`Performance profiling ${enabled ? "enabled" : "disabled"}`);
+  }
+  /**
+   * End timing for an operation
+   */
+  endTiming(operationName, startTime, metadata) {
+    const duration = performance.now() - startTime;
+    const timestamp = Date.now();
+    this.updateMetrics(operationName, duration, timestamp);
+    if (duration > this.hotPathThreshold) {
+      this.trackHotPath(operationName, duration, timestamp, metadata);
+    }
+    this.storeSample(operationName, duration, timestamp, metadata);
+  }
+  /**
+   * Update performance metrics for an operation
+   */
+  updateMetrics(operationName, duration, timestamp) {
+    const existing = this.metrics.get(operationName);
+    if (!existing) {
+      this.metrics.set(operationName, {
+        operationName,
+        callCount: 1,
+        totalTimeMs: duration,
+        avgTimeMs: duration,
+        minTimeMs: duration,
+        maxTimeMs: duration,
+        p95TimeMs: duration,
+        lastExecuted: timestamp
+      });
+    } else {
+      existing.callCount++;
+      existing.totalTimeMs += duration;
+      existing.avgTimeMs = existing.totalTimeMs / existing.callCount;
+      existing.minTimeMs = Math.min(existing.minTimeMs, duration);
+      existing.maxTimeMs = Math.max(existing.maxTimeMs, duration);
+      existing.lastExecuted = timestamp;
+      existing.p95TimeMs = this.calculateP95(operationName);
+    }
+  }
+  /**
+   * Track hot path
+   */
+  trackHotPath(operationName, duration, timestamp, metadata) {
+    const existing = this.hotPaths.get(operationName);
+    if (!existing) {
+      this.hotPaths.set(operationName, {
+        path: operationName,
+        frequency: 1,
+        avgDuration: duration,
+        totalDuration: duration,
+        lastSeen: timestamp,
+        samples: [{ timestamp, duration, metadata }]
+      });
+    } else {
+      existing.frequency++;
+      existing.totalDuration += duration;
+      existing.avgDuration = existing.totalDuration / existing.frequency;
+      existing.lastSeen = timestamp;
+      existing.samples.push({ timestamp, duration, metadata });
+      if (existing.samples.length > 100) {
+        existing.samples = existing.samples.slice(-100);
+      }
+    }
+  }
+  /**
+   * Store performance sample
+   */
+  storeSample(operationName, duration, timestamp, metadata) {
+    if (!this.samples.has(operationName)) {
+      this.samples.set(operationName, []);
+    }
+    const samples = this.samples.get(operationName);
+    samples.push({ timestamp, duration, metadata });
+    if (samples.length > this.sampleLimit) {
+      samples.splice(0, samples.length - this.sampleLimit);
+    }
+  }
+  /**
+   * Calculate 95th percentile from samples
+   */
+  calculateP95(operationName) {
+    const samples = this.samples.get(operationName);
+    if (!samples || samples.length === 0) return 0;
+    const durations = samples.map((s) => s.duration).sort((a, b) => a - b);
+    const index = Math.floor(durations.length * 0.95);
+    return durations[index] || 0;
+  }
+  /**
+   * Generate optimization recommendations
+   */
+  generateRecommendations(hotPaths) {
+    const recommendations = [];
+    for (const hotPath of hotPaths.slice(0, 5)) {
+      const impact = hotPath.frequency * hotPath.avgDuration;
+      if (hotPath.path.includes("getFrameContext") && hotPath.avgDuration > 10) {
+        recommendations.push(
+          `Consider caching frame context for ${hotPath.path} (avg: ${hotPath.avgDuration.toFixed(1)}ms)`
+        );
+      }
+      if (hotPath.path.includes("getFrameEvents") && hotPath.frequency > 100) {
+        recommendations.push(
+          `High frequency event queries detected in ${hotPath.path} (${hotPath.frequency} calls). Consider pagination or caching.`
+        );
+      }
+      if (hotPath.path.includes("bulkInsert") && hotPath.avgDuration > 50) {
+        recommendations.push(
+          `Slow bulk insertion in ${hotPath.path}. Consider increasing batch size or using prepared statements.`
+        );
+      }
+      if (impact > 1e3) {
+        recommendations.push(
+          `High impact operation: ${hotPath.path} (${impact.toFixed(0)}ms total impact). Consider optimization.`
+        );
+      }
+    }
+    const memUsage = process.memoryUsage();
+    if (memUsage.heapUsed / memUsage.heapTotal > 0.8) {
+      recommendations.push(
+        "High memory usage detected. Consider implementing cleanup routines or reducing cache sizes."
+      );
+    }
+    if (recommendations.length === 0) {
+      recommendations.push("No significant performance issues detected.");
+    }
+    return recommendations;
+  }
+}
+let globalProfiler = null;
+function getProfiler() {
+  if (!globalProfiler) {
+    globalProfiler = new PerformanceProfiler({
+      enabled: process.env["NODE_ENV"] !== "production" || process.env["STACKMEMORY_PROFILING"] === "true"
+    });
+  }
+  return globalProfiler;
+}
+async function timeOperation(operationName, fn, metadata) {
+  return getProfiler().timeFunction(operationName, fn, metadata);
+}
+function performanceMonitor(operationName) {
+  return function(target, propertyKey, descriptor) {
+    const originalMethod = descriptor.value;
+    const finalOperationName = operationName || `${target.constructor.name}.${propertyKey}`;
+    descriptor.value = async function(...args) {
+      return getProfiler().timeFunction(
+        finalOperationName,
+        () => originalMethod.apply(this, args)
+      );
+    };
+    return descriptor;
+  };
+}
+class StackMemoryPerformanceMonitor {
+  profiler = getProfiler();
+  /**
+   * Monitor frame operations
+   */
+  monitorFrameOperations(frameManager) {
+    this.wrapMethod(frameManager, "getFrame", "FrameManager.getFrame");
+    this.wrapMethod(
+      frameManager,
+      "getFrameEvents",
+      "FrameManager.getFrameEvents"
+    );
+    this.wrapMethod(
+      frameManager,
+      "getFrameAnchors",
+      "FrameManager.getFrameAnchors"
+    );
+    this.wrapMethod(
+      frameManager,
+      "getHotStackContext",
+      "FrameManager.getHotStackContext"
+    );
+  }
+  /**
+   * Monitor database operations
+   */
+  monitorDatabaseOperations(db) {
+    const originalPrepare = db.prepare;
+    db.prepare = function(sql) {
+      const stmt = originalPrepare.call(this, sql);
+      return wrapStatement(stmt, sql);
+    };
+  }
+  /**
+   * Wrap a method with performance monitoring
+   */
+  wrapMethod(obj, methodName, operationName) {
+    const original = obj[methodName];
+    if (typeof original !== "function") return;
+    obj[methodName] = async function(...args) {
+      return getProfiler().timeFunction(
+        operationName,
+        () => original.apply(this, args)
+      );
+    };
+  }
+}
+function wrapStatement(stmt, sql) {
+  const operationName = `SQL.${sql.trim().split(" ")[0].toUpperCase()}`;
+  const originalRun = stmt.run;
+  const originalGet = stmt.get;
+  const originalAll = stmt.all;
+  stmt.run = function(...args) {
+    return getProfiler().timeFunction(
+      `${operationName}.run`,
+      () => originalRun.apply(this, args)
+    );
+  };
+  stmt.get = function(...args) {
+    return getProfiler().timeFunction(
+      `${operationName}.get`,
+      () => originalGet.apply(this, args)
+    );
+  };
+  stmt.all = function(...args) {
+    return getProfiler().timeFunction(
+      `${operationName}.all`,
+      () => originalAll.apply(this, args)
+    );
+  };
+  return stmt;
+}
+export {
+  PerformanceProfiler,
+  StackMemoryPerformanceMonitor,
+  getProfiler,
+  performanceMonitor,
+  timeOperation
+};
+//# sourceMappingURL=performance-profiler.js.map

package/dist/src/core/performance/performance-profiler.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/core/performance/performance-profiler.ts"],
+  "sourcesContent": ["/**\n * Performance Profiler\n * Identifies and optimizes hot paths in StackMemory operations\n */\n\nimport { logger } from '../monitoring/logger.js';\nimport { getQueryStatistics } from '../trace/db-trace-wrapper.js';\nimport Database from 'better-sqlite3';\n// Type-safe environment variable access\nfunction getEnv(key: string, defaultValue?: string): string {\n  const value = process.env[key];\n  if (value === undefined) {\n    if (defaultValue !== undefined) return defaultValue;\n    throw new Error(`Environment variable ${key} is required`);\n  }\n  return value;\n}\n\nfunction getOptionalEnv(key: string): string | undefined {\n  return process.env[key];\n}\n\nexport interface PerformanceMetrics {\n  operationName: string;\n  callCount: number;\n  totalTimeMs: number;\n  avgTimeMs: number;\n  minTimeMs: number;\n  maxTimeMs: number;\n  p95TimeMs: number;\n  lastExecuted: number;\n}\n\nexport interface HotPath {\n  path: string;\n  frequency: number;\n  avgDuration: number;\n  totalDuration: number;\n  lastSeen: number;\n  samples: PerformanceSample[];\n}\n\nexport interface PerformanceSample {\n  timestamp: number;\n  duration: number;\n  metadata?: Record<string, any>;\n}\n\nexport interface SystemPerformanceReport {\n  timestamp: number;\n  hotPaths: HotPath[];\n  databaseMetrics: any;\n  memoryUsage: {\n    heapUsed: number;\n    heapTotal: number;\n    external: number;\n  };\n  cacheMetrics: any;\n  recommendations: string[];\n}\n\n/**\n * Performance profiler with hot path detection\n */\nexport class PerformanceProfiler {\n  private metrics = new Map<string, PerformanceMetrics>();\n  private hotPaths = new Map<string, HotPath>();\n  private samples = new Map<string, PerformanceSample[]>();\n  private isEnabled = true;\n  private sampleLimit = 1000;\n  private hotPathThreshold = 5; // Operations taking > 5ms are considered hot\n\n  constructor(\n    options: {\n      enabled?: boolean;\n      sampleLimit?: number;\n      hotPathThreshold?: number;\n    } = {}\n  ) {\n    this.isEnabled = options.enabled ?? true;\n    this.sampleLimit = options.sampleLimit ?? 1000;\n    this.hotPathThreshold = options.hotPathThreshold ?? 5;\n  }\n\n  /**\n   * Start timing an operation\n   */\n  startTiming(operationName: string): (metadata?: Record<string, any>) => void {\n    if (!this.isEnabled) {\n      return () => {}; // No-op\n    }\n\n    const startTime = performance.now();\n\n    return (metadata?: Record<string, any>) => {\n      this.endTiming(operationName, startTime, metadata);\n    };\n  }\n\n  /**\n   * Time a function execution\n   */\n  async timeFunction<T>(\n    operationName: string,\n    fn: () => T | Promise<T>,\n    metadata?: Record<string, any>\n  ): Promise<T> {\n    if (!this.isEnabled) {\n      return await fn();\n    }\n\n    const endTimer = this.startTiming(operationName);\n    try {\n      const result = await fn();\n      endTimer(metadata);\n      return result;\n    } catch (error: unknown) {\n      endTimer({ ...metadata, error: true });\n      throw error;\n    }\n  }\n\n  /**\n   * Record timing manually\n   */\n  recordTiming(\n    operationName: string,\n    durationMs: number,\n    metadata?: Record<string, any>\n  ): void {\n    if (!this.isEnabled) return;\n\n    this.endTiming(operationName, performance.now() - durationMs, metadata);\n  }\n\n  /**\n   * Get performance metrics for an operation\n   */\n  getMetrics(operationName: string): PerformanceMetrics | undefined {\n    return this.metrics.get(operationName);\n  }\n\n  /**\n   * Get all performance metrics\n   */\n  getAllMetrics(): Map<string, PerformanceMetrics> {\n    return new Map(this.metrics);\n  }\n\n  /**\n   * Get hot paths sorted by impact\n   */\n  getHotPaths(limit = 10): HotPath[] {\n    return Array.from(this.hotPaths.values())\n      .sort((a, b) => b.frequency * b.avgDuration - a.frequency * a.avgDuration)\n      .slice(0, limit);\n  }\n\n  /**\n   * Generate comprehensive performance report\n   */\n  generateReport(db?: Database.Database): SystemPerformanceReport {\n    const hotPaths = this.getHotPaths(20);\n    const recommendations = this.generateRecommendations(hotPaths);\n\n    const report: SystemPerformanceReport = {\n      timestamp: Date.now(),\n      hotPaths,\n      databaseMetrics: db ? getQueryStatistics(db) : null,\n      memoryUsage: process.memoryUsage(),\n      cacheMetrics: null, // Will be filled by query cache if available\n      recommendations,\n    };\n\n    logger.info('Performance report generated', {\n      hotPathsCount: hotPaths.length,\n      recommendationsCount: recommendations.length,\n      topHotPath: hotPaths[0]?.path,\n    });\n\n    return report;\n  }\n\n  /**\n   * Reset all metrics\n   */\n  reset(): void {\n    this.metrics.clear();\n    this.hotPaths.clear();\n    this.samples.clear();\n    logger.info('Performance metrics reset');\n  }\n\n  /**\n   * Export metrics to JSON\n   */\n  exportMetrics(): string {\n    const data = {\n      timestamp: Date.now(),\n      metrics: Object.fromEntries(this.metrics),\n      hotPaths: Object.fromEntries(this.hotPaths),\n      config: {\n        sampleLimit: this.sampleLimit,\n        hotPathThreshold: this.hotPathThreshold,\n        enabled: this.isEnabled,\n      },\n    };\n\n    return JSON.stringify(data, null, 2);\n  }\n\n  /**\n   * Enable/disable profiling\n   */\n  setEnabled(enabled: boolean): void {\n    this.isEnabled = enabled;\n    logger.info(`Performance profiling ${enabled ? 'enabled' : 'disabled'}`);\n  }\n\n  /**\n   * End timing for an operation\n   */\n  private endTiming(\n    operationName: string,\n    startTime: number,\n    metadata?: Record<string, any>\n  ): void {\n    const duration = performance.now() - startTime;\n    const timestamp = Date.now();\n\n    // Update metrics\n    this.updateMetrics(operationName, duration, timestamp);\n\n    // Track hot paths\n    if (duration > this.hotPathThreshold) {\n      this.trackHotPath(operationName, duration, timestamp, metadata);\n    }\n\n    // Store sample\n    this.storeSample(operationName, duration, timestamp, metadata);\n  }\n\n  /**\n   * Update performance metrics for an operation\n   */\n  private updateMetrics(\n    operationName: string,\n    duration: number,\n    timestamp: number\n  ): void {\n    const existing = this.metrics.get(operationName);\n\n    if (!existing) {\n      this.metrics.set(operationName, {\n        operationName,\n        callCount: 1,\n        totalTimeMs: duration,\n        avgTimeMs: duration,\n        minTimeMs: duration,\n        maxTimeMs: duration,\n        p95TimeMs: duration,\n        lastExecuted: timestamp,\n      });\n    } else {\n      existing.callCount++;\n      existing.totalTimeMs += duration;\n      existing.avgTimeMs = existing.totalTimeMs / existing.callCount;\n      existing.minTimeMs = Math.min(existing.minTimeMs, duration);\n      existing.maxTimeMs = Math.max(existing.maxTimeMs, duration);\n      existing.lastExecuted = timestamp;\n\n      // Update p95 from samples\n      existing.p95TimeMs = this.calculateP95(operationName);\n    }\n  }\n\n  /**\n   * Track hot path\n   */\n  private trackHotPath(\n    operationName: string,\n    duration: number,\n    timestamp: number,\n    metadata?: Record<string, any>\n  ): void {\n    const existing = this.hotPaths.get(operationName);\n\n    if (!existing) {\n      this.hotPaths.set(operationName, {\n        path: operationName,\n        frequency: 1,\n        avgDuration: duration,\n        totalDuration: duration,\n        lastSeen: timestamp,\n        samples: [{ timestamp, duration, metadata }],\n      });\n    } else {\n      existing.frequency++;\n      existing.totalDuration += duration;\n      existing.avgDuration = existing.totalDuration / existing.frequency;\n      existing.lastSeen = timestamp;\n\n      // Keep limited samples\n      existing.samples.push({ timestamp, duration, metadata });\n      if (existing.samples.length > 100) {\n        existing.samples = existing.samples.slice(-100);\n      }\n    }\n  }\n\n  /**\n   * Store performance sample\n   */\n  private storeSample(\n    operationName: string,\n    duration: number,\n    timestamp: number,\n    metadata?: Record<string, any>\n  ): void {\n    if (!this.samples.has(operationName)) {\n      this.samples.set(operationName, []);\n    }\n\n    const samples = this.samples.get(operationName)!;\n    samples.push({ timestamp, duration, metadata });\n\n    // Limit samples to prevent memory growth\n    if (samples.length > this.sampleLimit) {\n      samples.splice(0, samples.length - this.sampleLimit);\n    }\n  }\n\n  /**\n   * Calculate 95th percentile from samples\n   */\n  private calculateP95(operationName: string): number {\n    const samples = this.samples.get(operationName);\n    if (!samples || samples.length === 0) return 0;\n\n    const durations = samples.map((s: any) => s.duration).sort((a, b) => a - b);\n    const index = Math.floor(durations.length * 0.95);\n    return durations[index] || 0;\n  }\n\n  /**\n   * Generate optimization recommendations\n   */\n  private generateRecommendations(hotPaths: HotPath[]): string[] {\n    const recommendations: string[] = [];\n\n    for (const hotPath of hotPaths.slice(0, 5)) {\n      const impact = hotPath.frequency * hotPath.avgDuration;\n\n      if (\n        hotPath.path.includes('getFrameContext') &&\n        hotPath.avgDuration > 10\n      ) {\n        recommendations.push(\n          `Consider caching frame context for ${hotPath.path} (avg: ${hotPath.avgDuration.toFixed(1)}ms)`\n        );\n      }\n\n      if (hotPath.path.includes('getFrameEvents') && hotPath.frequency > 100) {\n        recommendations.push(\n          `High frequency event queries detected in ${hotPath.path} (${hotPath.frequency} calls). Consider pagination or caching.`\n        );\n      }\n\n      if (hotPath.path.includes('bulkInsert') && hotPath.avgDuration > 50) {\n        recommendations.push(\n          `Slow bulk insertion in ${hotPath.path}. Consider increasing batch size or using prepared statements.`\n        );\n      }\n\n      if (impact > 1000) {\n        recommendations.push(\n          `High impact operation: ${hotPath.path} (${impact.toFixed(0)}ms total impact). Consider optimization.`\n        );\n      }\n    }\n\n    // Memory recommendations\n    const memUsage = process.memoryUsage();\n    if (memUsage.heapUsed / memUsage.heapTotal > 0.8) {\n      recommendations.push(\n        'High memory usage detected. Consider implementing cleanup routines or reducing cache sizes.'\n      );\n    }\n\n    if (recommendations.length === 0) {\n      recommendations.push('No significant performance issues detected.');\n    }\n\n    return recommendations;\n  }\n}\n\n// Global profiler instance\nlet globalProfiler: PerformanceProfiler | null = null;\n\n/**\n * Get or create global profiler\n */\nexport function getProfiler(): PerformanceProfiler {\n  if (!globalProfiler) {\n    globalProfiler = new PerformanceProfiler({\n      enabled:\n        process.env['NODE_ENV'] !== 'production' ||\n        process.env['STACKMEMORY_PROFILING'] === 'true',\n    });\n  }\n  return globalProfiler;\n}\n\n/**\n * Convenience function to time operations\n */\nexport async function timeOperation<T>(\n  operationName: string,\n  fn: () => T | Promise<T>,\n  metadata?: Record<string, any>\n): Promise<T> {\n  return getProfiler().timeFunction(operationName, fn, metadata);\n}\n\n/**\n * Create a performance monitoring decorator\n */\nexport function performanceMonitor(operationName?: string) {\n  return function (\n    target: any,\n    propertyKey: string,\n    descriptor: PropertyDescriptor\n  ) {\n    const originalMethod = descriptor.value;\n    const finalOperationName =\n      operationName || `${target.constructor.name}.${propertyKey}`;\n\n    descriptor.value = async function (...args: any[]) {\n      return getProfiler().timeFunction(finalOperationName, () =>\n        originalMethod.apply(this, args)\n      );\n    };\n\n    return descriptor;\n  };\n}\n\n/**\n * Monitor specific StackMemory operations\n */\nexport class StackMemoryPerformanceMonitor {\n  private profiler = getProfiler();\n\n  /**\n   * Monitor frame operations\n   */\n  monitorFrameOperations(frameManager: any): void {\n    this.wrapMethod(frameManager, 'getFrame', 'FrameManager.getFrame');\n    this.wrapMethod(\n      frameManager,\n      'getFrameEvents',\n      'FrameManager.getFrameEvents'\n    );\n    this.wrapMethod(\n      frameManager,\n      'getFrameAnchors',\n      'FrameManager.getFrameAnchors'\n    );\n    this.wrapMethod(\n      frameManager,\n      'getHotStackContext',\n      'FrameManager.getHotStackContext'\n    );\n  }\n\n  /**\n   * Monitor database operations\n   */\n  monitorDatabaseOperations(db: Database.Database): void {\n    const originalPrepare = db.prepare;\n    db.prepare = function <T = any>(sql: string): Database.Statement<T[], T> {\n      const stmt = originalPrepare.call(this, sql);\n      return wrapStatement(stmt, sql);\n    };\n  }\n\n  /**\n   * Wrap a method with performance monitoring\n   */\n  private wrapMethod(\n    obj: any,\n    methodName: string,\n    operationName: string\n  ): void {\n    const original = obj[methodName];\n    if (typeof original !== 'function') return;\n\n    obj[methodName] = async function (...args: any[]) {\n      return getProfiler().timeFunction(operationName, () =>\n        original.apply(this, args)\n      );\n    };\n  }\n}\n\n/**\n * Wrap a database statement with performance monitoring\n */\nfunction wrapStatement(\n  stmt: Database.Statement,\n  sql: string\n): Database.Statement {\n  const operationName = `SQL.${sql.trim().split(' ')[0].toUpperCase()}`;\n\n  const originalRun = stmt.run;\n  const originalGet = stmt.get;\n  const originalAll = stmt.all;\n\n  stmt.run = function (this: Database.Statement, ...args: any[]) {\n    return getProfiler().timeFunction(`${operationName}.run`, () =>\n      originalRun.apply(this, args)\n    );\n  } as any;\n\n  stmt.get = function (this: Database.Statement, ...args: any[]) {\n    return getProfiler().timeFunction(`${operationName}.get`, () =>\n      originalGet.apply(this, args)\n    );\n  } as any;\n\n  stmt.all = function (this: Database.Statement, ...args: any[]) {\n    return getProfiler().timeFunction(`${operationName}.all`, () =>\n      originalAll.apply(this, args)\n    );\n  } as any;\n\n  return stmt;\n}\n"],
+  "mappings": ";;;;AAKA,SAAS,cAAc;AACvB,SAAS,0BAA0B;AAGnC,SAAS,OAAO,KAAa,cAA+B;AAC1D,QAAM,QAAQ,QAAQ,IAAI,GAAG;AAC7B,MAAI,UAAU,QAAW;AACvB,QAAI,iBAAiB,OAAW,QAAO;AACvC,UAAM,IAAI,MAAM,wBAAwB,GAAG,cAAc;AAAA,EAC3D;AACA,SAAO;AACT;AAEA,SAAS,eAAe,KAAiC;AACvD,SAAO,QAAQ,IAAI,GAAG;AACxB;AA4CO,MAAM,oBAAoB;AAAA,EACvB,UAAU,oBAAI,IAAgC;AAAA,EAC9C,WAAW,oBAAI,IAAqB;AAAA,EACpC,UAAU,oBAAI,IAAiC;AAAA,EAC/C,YAAY;AAAA,EACZ,cAAc;AAAA,EACd,mBAAmB;AAAA;AAAA,EAE3B,YACE,UAII,CAAC,GACL;AACA,SAAK,YAAY,QAAQ,WAAW;AACpC,SAAK,cAAc,QAAQ,eAAe;AAC1C,SAAK,mBAAmB,QAAQ,oBAAoB;AAAA,EACtD;AAAA;AAAA;AAAA;AAAA,EAKA,YAAY,eAAiE;AAC3E,QAAI,CAAC,KAAK,WAAW;AACnB,aAAO,MAAM;AAAA,MAAC;AAAA,IAChB;AAEA,UAAM,YAAY,YAAY,IAAI;AAElC,WAAO,CAAC,aAAmC;AACzC,WAAK,UAAU,eAAe,WAAW,QAAQ;AAAA,IACnD;AAAA,EACF;AAAA;AAAA;AAAA;AAAA,EAKA,MAAM,aACJ,eACA,IACA,UACY;AACZ,QAAI,CAAC,KAAK,WAAW;AACnB,aAAO,MAAM,GAAG;AAAA,IAClB;AAEA,UAAM,WAAW,KAAK,YAAY,aAAa;AAC/C,QAAI;AACF,YAAM,SAAS,MAAM,GAAG;AACxB,eAAS,QAAQ;AACjB,aAAO;AAAA,IACT,SAAS,OAAgB;AACvB,eAAS,EAAE,GAAG,UAAU,OAAO,KAAK,CAAC;AACrC,YAAM;AAAA,IACR;AAAA,EACF;AAAA;AAAA;AAAA;AAAA,EAKA,aACE,eACA,YACA,UACM;AACN,QAAI,CAAC,KAAK,UAAW;AAErB,SAAK,UAAU,eAAe,YAAY,IAAI,IAAI,YAAY,QAAQ;AAAA,EACxE;AAAA;AAAA;AAAA;AAAA,EAKA,WAAW,eAAuD;AAChE,WAAO,KAAK,QAAQ,IAAI,aAAa;AAAA,EACvC;AAAA;AAAA;AAAA;AAAA,EAKA,gBAAiD;AAC/C,WAAO,IAAI,IAAI,KAAK,OAAO;AAAA,EAC7B;AAAA;AAAA;AAAA;AAAA,EAKA,YAAY,QAAQ,IAAe;AACjC,WAAO,MAAM,KAAK,KAAK,SAAS,OAAO,CAAC,EACrC,KAAK,CAAC,GAAG,MAAM,EAAE,YAAY,EAAE,cAAc,EAAE,YAAY,EAAE,WAAW,EACxE,MAAM,GAAG,KAAK;AAAA,EACnB;AAAA;AAAA;AAAA;AAAA,EAKA,eAAe,IAAiD;AAC9D,UAAM,WAAW,KAAK,YAAY,EAAE;AACpC,UAAM,kBAAkB,KAAK,wBAAwB,QAAQ;AAE7D,UAAM,SAAkC;AAAA,MACtC,WAAW,KAAK,IAAI;AAAA,MACpB;AAAA,MACA,iBAAiB,KAAK,mBAAmB,EAAE,IAAI;AAAA,MAC/C,aAAa,QAAQ,YAAY;AAAA,MACjC,cAAc;AAAA;AAAA,MACd;AAAA,IACF;AAEA,WAAO,KAAK,gCAAgC;AAAA,MAC1C,eAAe,SAAS;AAAA,MACxB,sBAAsB,gBAAgB;AAAA,MACtC,YAAY,SAAS,CAAC,GAAG;AAAA,IAC3B,CAAC;AAED,WAAO;AAAA,EACT;AAAA;AAAA;AAAA;AAAA,EAKA,QAAc;AACZ,SAAK,QAAQ,MAAM;AACnB,SAAK,SAAS,MAAM;AACpB,SAAK,QAAQ,MAAM;AACnB,WAAO,KAAK,2BAA2B;AAAA,EACzC;AAAA;AAAA;AAAA;AAAA,EAKA,gBAAwB;AACtB,UAAM,OAAO;AAAA,MACX,WAAW,KAAK,IAAI;AAAA,MACpB,SAAS,OAAO,YAAY,KAAK,OAAO;AAAA,MACxC,UAAU,OAAO,YAAY,KAAK,QAAQ;AAAA,MAC1C,QAAQ;AAAA,QACN,aAAa,KAAK;AAAA,QAClB,kBAAkB,KAAK;AAAA,QACvB,SAAS,KAAK;AAAA,MAChB;AAAA,IACF;AAEA,WAAO,KAAK,UAAU,MAAM,MAAM,CAAC;AAAA,EACrC;AAAA;AAAA;AAAA;AAAA,EAKA,WAAW,SAAwB;AACjC,SAAK,YAAY;AACjB,WAAO,KAAK,yBAAyB,UAAU,YAAY,UAAU,EAAE;AAAA,EACzE;AAAA;AAAA;AAAA;AAAA,EAKQ,UACN,eACA,WACA,UACM;AACN,UAAM,WAAW,YAAY,IAAI,IAAI;AACrC,UAAM,YAAY,KAAK,IAAI;AAG3B,SAAK,cAAc,eAAe,UAAU,SAAS;AAGrD,QAAI,WAAW,KAAK,kBAAkB;AACpC,WAAK,aAAa,eAAe,UAAU,WAAW,QAAQ;AAAA,IAChE;AAGA,SAAK,YAAY,eAAe,UAAU,WAAW,QAAQ;AAAA,EAC/D;AAAA;AAAA;AAAA;AAAA,EAKQ,cACN,eACA,UACA,WACM;AACN,UAAM,WAAW,KAAK,QAAQ,IAAI,aAAa;AAE/C,QAAI,CAAC,UAAU;AACb,WAAK,QAAQ,IAAI,eAAe;AAAA,QAC9B;AAAA,QACA,WAAW;AAAA,QACX,aAAa;AAAA,QACb,WAAW;AAAA,QACX,WAAW;AAAA,QACX,WAAW;AAAA,QACX,WAAW;AAAA,QACX,cAAc;AAAA,MAChB,CAAC;AAAA,IACH,OAAO;AACL,eAAS;AACT,eAAS,eAAe;AACxB,eAAS,YAAY,SAAS,cAAc,SAAS;AACrD,eAAS,YAAY,KAAK,IAAI,SAAS,WAAW,QAAQ;AAC1D,eAAS,YAAY,KAAK,IAAI,SAAS,WAAW,QAAQ;AAC1D,eAAS,eAAe;AAGxB,eAAS,YAAY,KAAK,aAAa,aAAa;AAAA,IACtD;AAAA,EACF;AAAA;AAAA;AAAA;AAAA,EAKQ,aACN,eACA,UACA,WACA,UACM;AACN,UAAM,WAAW,KAAK,SAAS,IAAI,aAAa;AAEhD,QAAI,CAAC,UAAU;AACb,WAAK,SAAS,IAAI,eAAe;AAAA,QAC/B,MAAM;AAAA,QACN,WAAW;AAAA,QACX,aAAa;AAAA,QACb,eAAe;AAAA,QACf,UAAU;AAAA,QACV,SAAS,CAAC,EAAE,WAAW,UAAU,SAAS,CAAC;AAAA,MAC7C,CAAC;AAAA,IACH,OAAO;AACL,eAAS;AACT,eAAS,iBAAiB;AAC1B,eAAS,cAAc,SAAS,gBAAgB,SAAS;AACzD,eAAS,WAAW;AAGpB,eAAS,QAAQ,KAAK,EAAE,WAAW,UAAU,SAAS,CAAC;AACvD,UAAI,SAAS,QAAQ,SAAS,KAAK;AACjC,iBAAS,UAAU,SAAS,QAAQ,MAAM,IAAI;AAAA,MAChD;AAAA,IACF;AAAA,EACF;AAAA;AAAA;AAAA;AAAA,EAKQ,YACN,eACA,UACA,WACA,UACM;AACN,QAAI,CAAC,KAAK,QAAQ,IAAI,aAAa,GAAG;AACpC,WAAK,QAAQ,IAAI,eAAe,CAAC,CAAC;AAAA,IACpC;AAEA,UAAM,UAAU,KAAK,QAAQ,IAAI,aAAa;AAC9C,YAAQ,KAAK,EAAE,WAAW,UAAU,SAAS,CAAC;AAG9C,QAAI,QAAQ,SAAS,KAAK,aAAa;AACrC,cAAQ,OAAO,GAAG,QAAQ,SAAS,KAAK,WAAW;AAAA,IACrD;AAAA,EACF;AAAA;AAAA;AAAA;AAAA,EAKQ,aAAa,eAA+B;AAClD,UAAM,UAAU,KAAK,QAAQ,IAAI,aAAa;AAC9C,QAAI,CAAC,WAAW,QAAQ,WAAW,EAAG,QAAO;AAE7C,UAAM,YAAY,QAAQ,IAAI,CAAC,MAAW,EAAE,QAAQ,EAAE,KAAK,CAAC,GAAG,MAAM,IAAI,CAAC;AAC1E,UAAM,QAAQ,KAAK,MAAM,UAAU,SAAS,IAAI;AAChD,WAAO,UAAU,KAAK,KAAK;AAAA,EAC7B;AAAA;AAAA;AAAA;AAAA,EAKQ,wBAAwB,UAA+B;AAC7D,UAAM,kBAA4B,CAAC;AAEnC,eAAW,WAAW,SAAS,MAAM,GAAG,CAAC,GAAG;AAC1C,YAAM,SAAS,QAAQ,YAAY,QAAQ;AAE3C,UACE,QAAQ,KAAK,SAAS,iBAAiB,KACvC,QAAQ,cAAc,IACtB;AACA,wBAAgB;AAAA,UACd,sCAAsC,QAAQ,IAAI,UAAU,QAAQ,YAAY,QAAQ,CAAC,CAAC;AAAA,QAC5F;AAAA,MACF;AAEA,UAAI,QAAQ,KAAK,SAAS,gBAAgB,KAAK,QAAQ,YAAY,KAAK;AACtE,wBAAgB;AAAA,UACd,4CAA4C,QAAQ,IAAI,KAAK,QAAQ,SAAS;AAAA,QAChF;AAAA,MACF;AAEA,UAAI,QAAQ,KAAK,SAAS,YAAY,KAAK,QAAQ,cAAc,IAAI;AACnE,wBAAgB;AAAA,UACd,0BAA0B,QAAQ,IAAI;AAAA,QACxC;AAAA,MACF;AAEA,UAAI,SAAS,KAAM;AACjB,wBAAgB;AAAA,UACd,0BAA0B,QAAQ,IAAI,KAAK,OAAO,QAAQ,CAAC,CAAC;AAAA,QAC9D;AAAA,MACF;AAAA,IACF;AAGA,UAAM,WAAW,QAAQ,YAAY;AACrC,QAAI,SAAS,WAAW,SAAS,YAAY,KAAK;AAChD,sBAAgB;AAAA,QACd;AAAA,MACF;AAAA,IACF;AAEA,QAAI,gBAAgB,WAAW,GAAG;AAChC,sBAAgB,KAAK,6CAA6C;AAAA,IACpE;AAEA,WAAO;AAAA,EACT;AACF;AAGA,IAAI,iBAA6C;AAK1C,SAAS,cAAmC;AACjD,MAAI,CAAC,gBAAgB;AACnB,qBAAiB,IAAI,oBAAoB;AAAA,MACvC,SACE,QAAQ,IAAI,UAAU,MAAM,gBAC5B,QAAQ,IAAI,uBAAuB,MAAM;AAAA,IAC7C,CAAC;AAAA,EACH;AACA,SAAO;AACT;AAKA,eAAsB,cACpB,eACA,IACA,UACY;AACZ,SAAO,YAAY,EAAE,aAAa,eAAe,IAAI,QAAQ;AAC/D;AAKO,SAAS,mBAAmB,eAAwB;AACzD,SAAO,SACL,QACA,aACA,YACA;AACA,UAAM,iBAAiB,WAAW;AAClC,UAAM,qBACJ,iBAAiB,GAAG,OAAO,YAAY,IAAI,IAAI,WAAW;AAE5D,eAAW,QAAQ,kBAAmB,MAAa;AACjD,aAAO,YAAY,EAAE;AAAA,QAAa;AAAA,QAAoB,MACpD,eAAe,MAAM,MAAM,IAAI;AAAA,MACjC;AAAA,IACF;AAEA,WAAO;AAAA,EACT;AACF;AAKO,MAAM,8BAA8B;AAAA,EACjC,WAAW,YAAY;AAAA;AAAA;AAAA;AAAA,EAK/B,uBAAuB,cAAyB;AAC9C,SAAK,WAAW,cAAc,YAAY,uBAAuB;AACjE,SAAK;AAAA,MACH;AAAA,MACA;AAAA,MACA;AAAA,IACF;AACA,SAAK;AAAA,MACH;AAAA,MACA;AAAA,MACA;AAAA,IACF;AACA,SAAK;AAAA,MACH;AAAA,MACA;AAAA,MACA;AAAA,IACF;AAAA,EACF;AAAA;AAAA;AAAA;AAAA,EAKA,0BAA0B,IAA6B;AACrD,UAAM,kBAAkB,GAAG;AAC3B,OAAG,UAAU,SAAmB,KAAyC;AACvE,YAAM,OAAO,gBAAgB,KAAK,MAAM,GAAG;AAC3C,aAAO,cAAc,MAAM,GAAG;AAAA,IAChC;AAAA,EACF;AAAA;AAAA;AAAA;AAAA,EAKQ,WACN,KACA,YACA,eACM;AACN,UAAM,WAAW,IAAI,UAAU;AAC/B,QAAI,OAAO,aAAa,WAAY;AAEpC,QAAI,UAAU,IAAI,kBAAmB,MAAa;AAChD,aAAO,YAAY,EAAE;AAAA,QAAa;AAAA,QAAe,MAC/C,SAAS,MAAM,MAAM,IAAI;AAAA,MAC3B;AAAA,IACF;AAAA,EACF;AACF;AAKA,SAAS,cACP,MACA,KACoB;AACpB,QAAM,gBAAgB,OAAO,IAAI,KAAK,EAAE,MAAM,GAAG,EAAE,CAAC,EAAE,YAAY,CAAC;AAEnE,QAAM,cAAc,KAAK;AACzB,QAAM,cAAc,KAAK;AACzB,QAAM,cAAc,KAAK;AAEzB,OAAK,MAAM,YAAuC,MAAa;AAC7D,WAAO,YAAY,EAAE;AAAA,MAAa,GAAG,aAAa;AAAA,MAAQ,MACxD,YAAY,MAAM,MAAM,IAAI;AAAA,IAC9B;AAAA,EACF;AAEA,OAAK,MAAM,YAAuC,MAAa;AAC7D,WAAO,YAAY,EAAE;AAAA,MAAa,GAAG,aAAa;AAAA,MAAQ,MACxD,YAAY,MAAM,MAAM,IAAI;AAAA,IAC9B;AAAA,EACF;AAEA,OAAK,MAAM,YAAuC,MAAa;AAC7D,WAAO,YAAY,EAAE;AAAA,MAAa,GAAG,aAAa;AAAA,MAAQ,MACxD,YAAY,MAAM,MAAM,IAAI;AAAA,IAC9B;AAAA,EACF;AAEA,SAAO;AACT;",
+  "names": []
+}

package/dist/src/core/performance/streaming-jsonl-parser.js

@@ -0,0 +1,195 @@
+import { fileURLToPath as __fileURLToPath } from 'url';
+import { dirname as __pathDirname } from 'path';
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __pathDirname(__filename);
+import { createReadStream } from "fs";
+import { createInterface } from "readline";
+import { Transform, pipeline } from "stream";
+import { promisify } from "util";
+import { logger } from "../monitoring/logger.js";
+const pipelineAsync = promisify(pipeline);
+class StreamingJSONLParser {
+  DEFAULT_BATCH_SIZE = 100;
+  DEFAULT_MAX_LINE_LENGTH = 1024 * 1024;
+  // 1MB per line
+  /**
+   * Stream-parse a JSONL file with batching and backpressure handling
+   */
+  async *parseStream(filePath, options = {}) {
+    const {
+      batchSize = this.DEFAULT_BATCH_SIZE,
+      maxLineLength = this.DEFAULT_MAX_LINE_LENGTH,
+      filter,
+      transform,
+      onProgress
+    } = options;
+    const stream = createReadStream(filePath, {
+      encoding: "utf8",
+      highWaterMark: 64 * 1024
+      // 64KB chunks
+    });
+    const rl = createInterface({
+      input: stream,
+      crlfDelay: Infinity,
+      historySize: 0
+      // Disable history for memory efficiency
+    });
+    let batch = [];
+    let lineCount = 0;
+    let processedCount = 0;
+    let errorCount = 0;
+    try {
+      for await (const line of rl) {
+        lineCount++;
+        if (line.length > maxLineLength) {
+          logger.warn("Skipping oversized line", {
+            lineNumber: lineCount,
+            length: line.length,
+            maxLength: maxLineLength
+          });
+          errorCount++;
+          continue;
+        }
+        if (!line.trim()) continue;
+        try {
+          let obj = JSON.parse(line);
+          if (filter && !filter(obj)) continue;
+          if (transform) obj = transform(obj);
+          batch.push(obj);
+          processedCount++;
+          if (batch.length >= batchSize) {
+            yield batch;
+            batch = [];
+            onProgress?.(processedCount);
+          }
+        } catch (parseError) {
+          errorCount++;
+          logger.debug("Failed to parse JSONL line", {
+            lineNumber: lineCount,
+            error: parseError,
+            preview: line.substring(0, 100)
+          });
+        }
+      }
+      if (batch.length > 0) {
+        yield batch;
+        onProgress?.(processedCount);
+      }
+    } finally {
+      rl.close();
+      stream.destroy();
+      logger.debug("JSONL parsing complete", {
+        filePath,
+        totalLines: lineCount,
+        processed: processedCount,
+        errors: errorCount
+      });
+    }
+  }
+  /**
+   * Parse entire file into memory (use for smaller files)
+   */
+  async parseAll(filePath, options = {}) {
+    const results = [];
+    for await (const batch of this.parseStream(filePath, {
+      ...options,
+      batchSize: Number.MAX_SAFE_INTEGER
+    })) {
+      results.push(...batch);
+    }
+    return results;
+  }
+  /**
+   * Process JSONL file with a custom processor function
+   */
+  async process(filePath, processor, options = {}) {
+    const results = [];
+    for await (const batch of this.parseStream(filePath, options)) {
+      const result = await processor(batch);
+      results.push(result);
+    }
+    return results;
+  }
+  /**
+   * Create a transform stream for JSONL parsing
+   */
+  createTransformStream(options = {}) {
+    const {
+      filter,
+      transform,
+      maxLineLength = this.DEFAULT_MAX_LINE_LENGTH
+    } = options;
+    let buffer = "";
+    let lineCount = 0;
+    return new Transform({
+      objectMode: true,
+      transform(chunk, encoding, callback) {
+        buffer += chunk.toString();
+        const lines = buffer.split("\n");
+        buffer = lines.pop() || "";
+        for (const line of lines) {
+          lineCount++;
+          if (!line.trim()) continue;
+          if (line.length > maxLineLength) {
+            logger.warn("Skipping oversized line in transform", { lineCount });
+            continue;
+          }
+          try {
+            let obj = JSON.parse(line);
+            if (filter && !filter(obj)) continue;
+            if (transform) obj = transform(obj);
+            this.push(obj);
+          } catch (error) {
+            logger.debug("Transform parse error", { lineCount, error });
+          }
+        }
+        callback();
+      },
+      flush(callback) {
+        if (buffer.trim()) {
+          try {
+            let obj = JSON.parse(buffer);
+            if (!filter || filter(obj)) {
+              if (transform) obj = transform(obj);
+              this.push(obj);
+            }
+          } catch (error) {
+            logger.debug("Flush parse error", { error });
+          }
+        }
+        callback();
+      }
+    });
+  }
+  /**
+   * Count lines in JSONL file without parsing
+   */
+  async countLines(filePath) {
+    const stream = createReadStream(filePath, { encoding: "utf8" });
+    const rl = createInterface({ input: stream, historySize: 0 });
+    let count = 0;
+    for await (const _ of rl) {
+      count++;
+    }
+    return count;
+  }
+  /**
+   * Sample random lines from JSONL file
+   */
+  async *sampleLines(filePath, sampleRate, options = {}) {
+    if (sampleRate <= 0 || sampleRate > 1) {
+      throw new Error("Sample rate must be between 0 and 1");
+    }
+    for await (const batch of this.parseStream(filePath, options)) {
+      for (const item of batch) {
+        if (Math.random() < sampleRate) {
+          yield item;
+        }
+      }
+    }
+  }
+}
+export {
+  StreamingJSONLParser
+};
+//# sourceMappingURL=streaming-jsonl-parser.js.map