@stackmemoryai/stackmemory 0.5.58 → 0.5.59

package/dist/src/core/performance/optimized-frame-context.js

@@ -0,0 +1,345 @@
+import { fileURLToPath as __fileURLToPath } from 'url';
+import { dirname as __pathDirname } from 'path';
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __pathDirname(__filename);
+import { getQueryCache, createCacheKey } from "../database/query-cache.js";
+import { logger } from "../monitoring/logger.js";
+class OptimizedContextAssembler {
+  db;
+  cache = getQueryCache();
+  preparedStatements = /* @__PURE__ */ new Map();
+  constructor(db) {
+    this.db = db;
+    this.initializePreparedStatements();
+  }
+  /**
+   * Get hot stack context with optimizations
+   */
+  async getHotStackContext(activeStack, options = {}) {
+    const startTime = performance.now();
+    const stats = {
+      cacheHits: 0,
+      dbQueries: 0,
+      totalRows: 0
+    };
+    const {
+      maxEvents = 20,
+      includeClosed = false,
+      enableCaching = true,
+      batchSize = 10
+    } = options;
+    try {
+      const contexts = [];
+      for (let i = 0; i < activeStack.length; i += batchSize) {
+        const batch = activeStack.slice(i, i + batchSize);
+        const batchContexts = await this.processBatch(
+          batch,
+          maxEvents,
+          includeClosed,
+          enableCaching,
+          stats
+        );
+        contexts.push(...batchContexts);
+      }
+      const assemblyTimeMs = performance.now() - startTime;
+      return contexts.map((context) => ({
+        ...context,
+        performance: {
+          assemblyTimeMs: assemblyTimeMs / contexts.length,
+          ...stats
+        }
+      }));
+    } catch (error) {
+      logger.error("Failed to assemble hot stack context", error, {
+        activeStack,
+        options
+      });
+      throw error;
+    }
+  }
+  /**
+   * Get single frame context with full optimization
+   */
+  async getFrameContext(frameId, options = {}) {
+    const startTime = performance.now();
+    const stats = { cacheHits: 0, dbQueries: 0, totalRows: 0 };
+    const { maxEvents = 50, enableCaching = true } = options;
+    const cacheKey = createCacheKey("frame_context", [frameId, maxEvents]);
+    if (enableCaching) {
+      const cached = this.cache.getFrameContext(cacheKey);
+      if (cached) {
+        stats.cacheHits++;
+        return {
+          ...cached,
+          performance: {
+            assemblyTimeMs: performance.now() - startTime,
+            ...stats
+          }
+        };
+      }
+    }
+    try {
+      const context = await this.assembleFrameContext(
+        frameId,
+        maxEvents,
+        stats
+      );
+      if (!context) return null;
+      if (enableCaching) {
+        this.cache.cacheFrameContext(cacheKey, context);
+      }
+      const result = {
+        ...context,
+        performance: {
+          assemblyTimeMs: performance.now() - startTime,
+          ...stats
+        }
+      };
+      return result;
+    } catch (error) {
+      logger.error("Failed to get frame context", error, { frameId });
+      throw error;
+    }
+  }
+  /**
+   * Process a batch of frames efficiently
+   */
+  async processBatch(frameIds, maxEvents, includeClosed, enableCaching, stats) {
+    const contexts = [];
+    const uncachedIds = [];
+    for (const frameId of frameIds) {
+      const cacheKey = createCacheKey("frame_context", [frameId, maxEvents]);
+      if (enableCaching) {
+        const cached = this.cache.getFrameContext(cacheKey);
+        if (cached) {
+          stats.cacheHits++;
+          contexts.push(cached);
+          continue;
+        }
+      }
+      uncachedIds.push(frameId);
+    }
+    if (uncachedIds.length === 0) {
+      return contexts;
+    }
+    const frames = await this.batchGetFrames(uncachedIds, stats);
+    const allEvents = await this.batchGetEvents(uncachedIds, maxEvents, stats);
+    const allAnchors = await this.batchGetAnchors(uncachedIds, stats);
+    const allArtifacts = await this.batchGetArtifacts(uncachedIds, stats);
+    for (const frameId of uncachedIds) {
+      const frame = frames.get(frameId);
+      if (!frame || !includeClosed && frame.state === "closed") {
+        continue;
+      }
+      const context = {
+        frameId,
+        header: {
+          goal: frame.name,
+          constraints: this.extractConstraints(frame.inputs),
+          definitions: frame.inputs.definitions
+        },
+        anchors: allAnchors.get(frameId) || [],
+        recentEvents: allEvents.get(frameId) || [],
+        activeArtifacts: allArtifacts.get(frameId) || []
+      };
+      if (enableCaching) {
+        const cacheKey = createCacheKey("frame_context", [frameId, maxEvents]);
+        this.cache.cacheFrameContext(cacheKey, context);
+      }
+      contexts.push(context);
+    }
+    return contexts;
+  }
+  /**
+   * Batch get frames with single query
+   */
+  async batchGetFrames(frameIds, stats) {
+    if (frameIds.length === 0) return /* @__PURE__ */ new Map();
+    const stmt = this.preparedStatements.get("batch_frames");
+    if (!stmt) throw new Error("Prepared statement not found: batch_frames");
+    const placeholders = frameIds.map(() => "?").join(",");
+    const query = `SELECT * FROM frames WHERE frame_id IN (${placeholders})`;
+    stats.dbQueries++;
+    const rows = this.db.prepare(query).all(...frameIds);
+    stats.totalRows += rows.length;
+    const frameMap = /* @__PURE__ */ new Map();
+    for (const row of rows) {
+      frameMap.set(row.frame_id, {
+        ...row,
+        inputs: JSON.parse(row.inputs || "{}"),
+        outputs: JSON.parse(row.outputs || "{}"),
+        digest_json: JSON.parse(row.digest_json || "{}")
+      });
+    }
+    return frameMap;
+  }
+  /**
+   * Batch get events for multiple frames
+   */
+  async batchGetEvents(frameIds, maxEvents, stats) {
+    if (frameIds.length === 0) return /* @__PURE__ */ new Map();
+    const placeholders = frameIds.map(() => "?").join(",");
+    const query = `
+      SELECT *, ROW_NUMBER() OVER (PARTITION BY frame_id ORDER BY seq DESC) as rn
+      FROM events 
+      WHERE frame_id IN (${placeholders}) 
+      AND rn <= ${maxEvents}
+      ORDER BY frame_id, seq DESC
+    `;
+    stats.dbQueries++;
+    const rows = this.db.prepare(query).all(...frameIds);
+    stats.totalRows += rows.length;
+    const eventMap = /* @__PURE__ */ new Map();
+    for (const row of rows) {
+      if (!eventMap.has(row.frame_id)) {
+        eventMap.set(row.frame_id, []);
+      }
+      eventMap.get(row.frame_id).push({
+        ...row,
+        payload: JSON.parse(row.payload)
+      });
+    }
+    return eventMap;
+  }
+  /**
+   * Batch get anchors for multiple frames
+   */
+  async batchGetAnchors(frameIds, stats) {
+    if (frameIds.length === 0) return /* @__PURE__ */ new Map();
+    const placeholders = frameIds.map(() => "?").join(",");
+    const query = `
+      SELECT * FROM anchors 
+      WHERE frame_id IN (${placeholders}) 
+      ORDER BY frame_id, priority DESC, created_at ASC
+    `;
+    stats.dbQueries++;
+    const rows = this.db.prepare(query).all(...frameIds);
+    stats.totalRows += rows.length;
+    const anchorMap = /* @__PURE__ */ new Map();
+    for (const row of rows) {
+      if (!anchorMap.has(row.frame_id)) {
+        anchorMap.set(row.frame_id, []);
+      }
+      anchorMap.get(row.frame_id).push({
+        ...row,
+        metadata: JSON.parse(row.metadata || "{}")
+      });
+    }
+    return anchorMap;
+  }
+  /**
+   * Batch get active artifacts for multiple frames
+   */
+  async batchGetArtifacts(frameIds, stats) {
+    if (frameIds.length === 0) return /* @__PURE__ */ new Map();
+    const placeholders = frameIds.map(() => "?").join(",");
+    const query = `
+      SELECT frame_id, payload
+      FROM events 
+      WHERE frame_id IN (${placeholders}) 
+      AND event_type = 'artifact'
+      ORDER BY frame_id, ts DESC
+    `;
+    stats.dbQueries++;
+    const rows = this.db.prepare(query).all(...frameIds);
+    stats.totalRows += rows.length;
+    const artifactMap = /* @__PURE__ */ new Map();
+    for (const row of rows) {
+      const payload = JSON.parse(row.payload);
+      if (!artifactMap.has(row.frame_id)) {
+        artifactMap.set(row.frame_id, []);
+      }
+      if (payload.path) {
+        artifactMap.get(row.frame_id).push(payload.path);
+      }
+    }
+    return artifactMap;
+  }
+  /**
+   * Assemble single frame context
+   */
+  async assembleFrameContext(frameId, maxEvents, stats) {
+    const frame = await this.batchGetFrames([frameId], stats).then(
+      (map) => map.get(frameId)
+    );
+    if (!frame) return null;
+    const [events, anchors, artifacts] = await Promise.all([
+      this.batchGetEvents([frameId], maxEvents, stats).then(
+        (map) => map.get(frameId) || []
+      ),
+      this.batchGetAnchors([frameId], stats).then(
+        (map) => map.get(frameId) || []
+      ),
+      this.batchGetArtifacts([frameId], stats).then(
+        (map) => map.get(frameId) || []
+      )
+    ]);
+    return {
+      frameId,
+      header: {
+        goal: frame.name,
+        constraints: this.extractConstraints(frame.inputs),
+        definitions: frame.inputs.definitions
+      },
+      anchors,
+      recentEvents: events,
+      activeArtifacts: artifacts
+    };
+  }
+  /**
+   * Extract constraints from frame inputs
+   */
+  extractConstraints(inputs) {
+    const constraints = [];
+    if (inputs.constraints && Array.isArray(inputs.constraints)) {
+      constraints.push(...inputs.constraints);
+    }
+    if (inputs.requirements && Array.isArray(inputs.requirements)) {
+      constraints.push(...inputs.requirements);
+    }
+    if (inputs.limitations && Array.isArray(inputs.limitations)) {
+      constraints.push(...inputs.limitations);
+    }
+    return constraints;
+  }
+  /**
+   * Initialize prepared statements for common queries
+   */
+  initializePreparedStatements() {
+    try {
+      this.preparedStatements.set(
+        "single_frame",
+        this.db.prepare("SELECT * FROM frames WHERE frame_id = ?")
+      );
+      this.preparedStatements.set(
+        "frame_events",
+        this.db.prepare(
+          "SELECT * FROM events WHERE frame_id = ? ORDER BY seq DESC LIMIT ?"
+        )
+      );
+      this.preparedStatements.set(
+        "frame_anchors",
+        this.db.prepare(
+          "SELECT * FROM anchors WHERE frame_id = ? ORDER BY priority DESC, created_at ASC"
+        )
+      );
+      logger.info(
+        "Prepared statements initialized for optimized context assembly"
+      );
+    } catch (error) {
+      logger.error("Failed to initialize prepared statements", error);
+      throw error;
+    }
+  }
+  /**
+   * Clear cache and reset prepared statements
+   */
+  cleanup() {
+    this.cache.clear();
+    this.preparedStatements.clear();
+  }
+}
+export {
+  OptimizedContextAssembler
+};
+//# sourceMappingURL=optimized-frame-context.js.map

package/dist/src/core/performance/optimized-frame-context.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/core/performance/optimized-frame-context.ts"],
+  "sourcesContent": ["/**\n * Optimized Frame Context Assembly\n * High-performance context retrieval with caching and batching\n */\n\nimport Database from 'better-sqlite3';\nimport { getQueryCache, createCacheKey } from '../database/query-cache.js';\nimport { logger } from '../monitoring/logger.js';\nimport {\n  Frame,\n  FrameContext,\n  Anchor,\n  Event,\n} from '../context/index.js';\n\nexport interface ContextAssemblyOptions {\n  maxEvents?: number;\n  includeClosed?: boolean;\n  enableCaching?: boolean;\n  batchSize?: number;\n}\n\nexport interface OptimizedFrameContext extends FrameContext {\n  performance: {\n    assemblyTimeMs: number;\n    cacheHits: number;\n    dbQueries: number;\n    totalRows: number;\n  };\n}\n\n/**\n * Optimized context assembly with caching and batching\n */\nexport class OptimizedContextAssembler {\n  private db: Database.Database;\n  private cache = getQueryCache();\n  private preparedStatements = new Map<string, Database.Statement>();\n\n  constructor(db: Database.Database) {\n    this.db = db;\n    this.initializePreparedStatements();\n  }\n\n  /**\n   * Get hot stack context with optimizations\n   */\n  async getHotStackContext(\n    activeStack: string[],\n    options: ContextAssemblyOptions = {}\n  ): Promise<OptimizedFrameContext[]> {\n    const startTime = performance.now();\n    const stats = {\n      cacheHits: 0,\n      dbQueries: 0,\n      totalRows: 0,\n    };\n\n    const {\n      maxEvents = 20,\n      includeClosed = false,\n      enableCaching = true,\n      batchSize = 10,\n    } = options;\n\n    try {\n      // Batch process frames for better performance\n      const contexts: OptimizedFrameContext[] = [];\n\n      for (let i = 0; i < activeStack.length; i += batchSize) {\n        const batch = activeStack.slice(i, i + batchSize);\n        const batchContexts = await this.processBatch(\n          batch,\n          maxEvents,\n          includeClosed,\n          enableCaching,\n          stats\n        );\n        contexts.push(...batchContexts);\n      }\n\n      const assemblyTimeMs = performance.now() - startTime;\n\n      // Add performance stats to each context\n      return contexts.map((context: any) => ({\n        ...context,\n        performance: {\n          assemblyTimeMs: assemblyTimeMs / contexts.length,\n          ...stats,\n        },\n      }));\n    } catch (error: unknown) {\n      logger.error('Failed to assemble hot stack context', error as Error, {\n        activeStack,\n        options,\n      });\n      throw error;\n    }\n  }\n\n  /**\n   * Get single frame context with full optimization\n   */\n  async getFrameContext(\n    frameId: string,\n    options: ContextAssemblyOptions = {}\n  ): Promise<OptimizedFrameContext | null> {\n    const startTime = performance.now();\n    const stats = { cacheHits: 0, dbQueries: 0, totalRows: 0 };\n\n    const { maxEvents = 50, enableCaching = true } = options;\n\n    // Check cache first\n    const cacheKey = createCacheKey('frame_context', [frameId, maxEvents]);\n    if (enableCaching) {\n      const cached = this.cache.getFrameContext(cacheKey);\n      if (cached) {\n        stats.cacheHits++;\n        return {\n          ...cached,\n          performance: {\n            assemblyTimeMs: performance.now() - startTime,\n            ...stats,\n          },\n        };\n      }\n    }\n\n    try {\n      const context = await this.assembleFrameContext(\n        frameId,\n        maxEvents,\n        stats\n      );\n\n      if (!context) return null;\n\n      // Cache the result\n      if (enableCaching) {\n        this.cache.cacheFrameContext(cacheKey, context);\n      }\n\n      const result: OptimizedFrameContext = {\n        ...context,\n        performance: {\n          assemblyTimeMs: performance.now() - startTime,\n          ...stats,\n        },\n      };\n\n      return result;\n    } catch (error: unknown) {\n      logger.error('Failed to get frame context', error as Error, { frameId });\n      throw error;\n    }\n  }\n\n  /**\n   * Process a batch of frames efficiently\n   */\n  private async processBatch(\n    frameIds: string[],\n    maxEvents: number,\n    includeClosed: boolean,\n    enableCaching: boolean,\n    stats: { cacheHits: number; dbQueries: number; totalRows: number }\n  ): Promise<OptimizedFrameContext[]> {\n    const contexts: OptimizedFrameContext[] = [];\n\n    // Get cached contexts first\n    const uncachedIds = [];\n    for (const frameId of frameIds) {\n      const cacheKey = createCacheKey('frame_context', [frameId, maxEvents]);\n      if (enableCaching) {\n        const cached = this.cache.getFrameContext(cacheKey);\n        if (cached) {\n          stats.cacheHits++;\n          contexts.push(cached);\n          continue;\n        }\n      }\n      uncachedIds.push(frameId);\n    }\n\n    if (uncachedIds.length === 0) {\n      return contexts;\n    }\n\n    // Batch fetch uncached frames\n    const frames = await this.batchGetFrames(uncachedIds, stats);\n    const allEvents = await this.batchGetEvents(uncachedIds, maxEvents, stats);\n    const allAnchors = await this.batchGetAnchors(uncachedIds, stats);\n    const allArtifacts = await this.batchGetArtifacts(uncachedIds, stats);\n\n    // Assemble contexts from batched data\n    for (const frameId of uncachedIds) {\n      const frame = frames.get(frameId);\n      if (!frame || (!includeClosed && frame.state === 'closed')) {\n        continue;\n      }\n\n      const context: FrameContext = {\n        frameId,\n        header: {\n          goal: frame.name,\n          constraints: this.extractConstraints(frame.inputs),\n          definitions: frame.inputs.definitions,\n        },\n        anchors: allAnchors.get(frameId) || [],\n        recentEvents: allEvents.get(frameId) || [],\n        activeArtifacts: allArtifacts.get(frameId) || [],\n      };\n\n      // Cache the context\n      if (enableCaching) {\n        const cacheKey = createCacheKey('frame_context', [frameId, maxEvents]);\n        this.cache.cacheFrameContext(cacheKey, context);\n      }\n\n      contexts.push(context as OptimizedFrameContext);\n    }\n\n    return contexts;\n  }\n\n  /**\n   * Batch get frames with single query\n   */\n  private async batchGetFrames(\n    frameIds: string[],\n    stats: { dbQueries: number; totalRows: number }\n  ): Promise<Map<string, Frame>> {\n    if (frameIds.length === 0) return new Map();\n\n    const stmt = this.preparedStatements.get('batch_frames');\n    if (!stmt) throw new Error('Prepared statement not found: batch_frames');\n\n    const placeholders = frameIds.map(() => '?').join(',');\n    const query = `SELECT * FROM frames WHERE frame_id IN (${placeholders})`;\n\n    stats.dbQueries++;\n    const rows = this.db.prepare(query).all(...frameIds) as any[];\n    stats.totalRows += rows.length;\n\n    const frameMap = new Map<string, Frame>();\n    for (const row of rows) {\n      frameMap.set(row.frame_id, {\n        ...row,\n        inputs: JSON.parse(row.inputs || '{}'),\n        outputs: JSON.parse(row.outputs || '{}'),\n        digest_json: JSON.parse(row.digest_json || '{}'),\n      });\n    }\n\n    return frameMap;\n  }\n\n  /**\n   * Batch get events for multiple frames\n   */\n  private async batchGetEvents(\n    frameIds: string[],\n    maxEvents: number,\n    stats: { dbQueries: number; totalRows: number }\n  ): Promise<Map<string, Event[]>> {\n    if (frameIds.length === 0) return new Map();\n\n    const placeholders = frameIds.map(() => '?').join(',');\n    const query = `\n      SELECT *, ROW_NUMBER() OVER (PARTITION BY frame_id ORDER BY seq DESC) as rn\n      FROM events \n      WHERE frame_id IN (${placeholders}) \n      AND rn <= ${maxEvents}\n      ORDER BY frame_id, seq DESC\n    `;\n\n    stats.dbQueries++;\n    const rows = this.db.prepare(query).all(...frameIds) as any[];\n    stats.totalRows += rows.length;\n\n    const eventMap = new Map<string, Event[]>();\n    for (const row of rows) {\n      if (!eventMap.has(row.frame_id)) {\n        eventMap.set(row.frame_id, []);\n      }\n      eventMap.get(row.frame_id)!.push({\n        ...row,\n        payload: JSON.parse(row.payload),\n      });\n    }\n\n    return eventMap;\n  }\n\n  /**\n   * Batch get anchors for multiple frames\n   */\n  private async batchGetAnchors(\n    frameIds: string[],\n    stats: { dbQueries: number; totalRows: number }\n  ): Promise<Map<string, Anchor[]>> {\n    if (frameIds.length === 0) return new Map();\n\n    const placeholders = frameIds.map(() => '?').join(',');\n    const query = `\n      SELECT * FROM anchors \n      WHERE frame_id IN (${placeholders}) \n      ORDER BY frame_id, priority DESC, created_at ASC\n    `;\n\n    stats.dbQueries++;\n    const rows = this.db.prepare(query).all(...frameIds) as any[];\n    stats.totalRows += rows.length;\n\n    const anchorMap = new Map<string, Anchor[]>();\n    for (const row of rows) {\n      if (!anchorMap.has(row.frame_id)) {\n        anchorMap.set(row.frame_id, []);\n      }\n      anchorMap.get(row.frame_id)!.push({\n        ...row,\n        metadata: JSON.parse(row.metadata || '{}'),\n      });\n    }\n\n    return anchorMap;\n  }\n\n  /**\n   * Batch get active artifacts for multiple frames\n   */\n  private async batchGetArtifacts(\n    frameIds: string[],\n    stats: { dbQueries: number; totalRows: number }\n  ): Promise<Map<string, string[]>> {\n    if (frameIds.length === 0) return new Map();\n\n    const placeholders = frameIds.map(() => '?').join(',');\n    const query = `\n      SELECT frame_id, payload\n      FROM events \n      WHERE frame_id IN (${placeholders}) \n      AND event_type = 'artifact'\n      ORDER BY frame_id, ts DESC\n    `;\n\n    stats.dbQueries++;\n    const rows = this.db.prepare(query).all(...frameIds) as any[];\n    stats.totalRows += rows.length;\n\n    const artifactMap = new Map<string, string[]>();\n    for (const row of rows) {\n      const payload = JSON.parse(row.payload);\n      if (!artifactMap.has(row.frame_id)) {\n        artifactMap.set(row.frame_id, []);\n      }\n      if (payload.path) {\n        artifactMap.get(row.frame_id)!.push(payload.path);\n      }\n    }\n\n    return artifactMap;\n  }\n\n  /**\n   * Assemble single frame context\n   */\n  private async assembleFrameContext(\n    frameId: string,\n    maxEvents: number,\n    stats: { dbQueries: number; totalRows: number }\n  ): Promise<FrameContext | null> {\n    // Single frame operations - these could be further optimized with prepared statements\n    const frame = await this.batchGetFrames([frameId], stats).then((map) =>\n      map.get(frameId)\n    );\n    if (!frame) return null;\n\n    const [events, anchors, artifacts] = await Promise.all([\n      this.batchGetEvents([frameId], maxEvents, stats).then(\n        (map) => map.get(frameId) || []\n      ),\n      this.batchGetAnchors([frameId], stats).then(\n        (map) => map.get(frameId) || []\n      ),\n      this.batchGetArtifacts([frameId], stats).then(\n        (map) => map.get(frameId) || []\n      ),\n    ]);\n\n    return {\n      frameId,\n      header: {\n        goal: frame.name,\n        constraints: this.extractConstraints(frame.inputs),\n        definitions: frame.inputs.definitions,\n      },\n      anchors,\n      recentEvents: events,\n      activeArtifacts: artifacts,\n    };\n  }\n\n  /**\n   * Extract constraints from frame inputs\n   */\n  private extractConstraints(inputs: Record<string, any>): string[] {\n    const constraints: string[] = [];\n\n    if (inputs.constraints && Array.isArray(inputs.constraints)) {\n      constraints.push(...inputs.constraints);\n    }\n\n    if (inputs.requirements && Array.isArray(inputs.requirements)) {\n      constraints.push(...inputs.requirements);\n    }\n\n    if (inputs.limitations && Array.isArray(inputs.limitations)) {\n      constraints.push(...inputs.limitations);\n    }\n\n    return constraints;\n  }\n\n  /**\n   * Initialize prepared statements for common queries\n   */\n  private initializePreparedStatements(): void {\n    try {\n      // Single frame query\n      this.preparedStatements.set(\n        'single_frame',\n        this.db.prepare('SELECT * FROM frames WHERE frame_id = ?')\n      );\n\n      // Frame events with limit\n      this.preparedStatements.set(\n        'frame_events',\n        this.db.prepare(\n          'SELECT * FROM events WHERE frame_id = ? ORDER BY seq DESC LIMIT ?'\n        )\n      );\n\n      // Frame anchors\n      this.preparedStatements.set(\n        'frame_anchors',\n        this.db.prepare(\n          'SELECT * FROM anchors WHERE frame_id = ? ORDER BY priority DESC, created_at ASC'\n        )\n      );\n\n      logger.info(\n        'Prepared statements initialized for optimized context assembly'\n      );\n    } catch (error: unknown) {\n      logger.error('Failed to initialize prepared statements', error as Error);\n      throw error;\n    }\n  }\n\n  /**\n   * Clear cache and reset prepared statements\n   */\n  cleanup(): void {\n    this.cache.clear();\n    // Modern better-sqlite3 automatically handles cleanup\n    this.preparedStatements.clear();\n  }\n}\n"],
+  "mappings": "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",
+  "names": []
+}

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

@@ -0,0 +1,277 @@
+import { fileURLToPath as __fileURLToPath } from 'url';
+import { dirname as __pathDirname } from 'path';
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __pathDirname(__filename);
+import { performance } from "perf_hooks";
+import { logger } from "../monitoring/logger.js";
+import { StreamingJSONLParser } from "./streaming-jsonl-parser.js";
+import { ContextCache } from "./context-cache.js";
+import { LazyContextLoader } from "./lazy-context-loader.js";
+import { readFileSync } from "fs";
+import { join } from "path";
+class PerformanceBenchmark {
+  results = [];
+  /**
+   * Benchmark JSONL parsing performance
+   */
+  async benchmarkJSONLParsing(filePath, iterations = 3) {
+    const parser = new StreamingJSONLParser();
+    const baselineStart = performance.now();
+    const baselineMemStart = process.memoryUsage().heapUsed;
+    let baselineCount = 0;
+    for (let i = 0; i < iterations; i++) {
+      const content = readFileSync(filePath, "utf8");
+      const lines = content.split("\n").filter((l) => l.trim());
+      for (const line of lines) {
+        try {
+          JSON.parse(line);
+          baselineCount++;
+        } catch {
+        }
+      }
+    }
+    const baselineDuration = performance.now() - baselineStart;
+    const baselineMemUsed = process.memoryUsage().heapUsed - baselineMemStart;
+    const optimizedStart = performance.now();
+    const optimizedMemStart = process.memoryUsage().heapUsed;
+    let optimizedCount = 0;
+    for (let i = 0; i < iterations; i++) {
+      for await (const batch of parser.parseStream(filePath)) {
+        optimizedCount += batch.length;
+      }
+    }
+    const optimizedDuration = performance.now() - optimizedStart;
+    const optimizedMemUsed = process.memoryUsage().heapUsed - optimizedMemStart;
+    const improvement = (baselineDuration - optimizedDuration) / baselineDuration * 100;
+    const memImprovement = (baselineMemUsed - optimizedMemUsed) / baselineMemUsed * 100;
+    const result = {
+      name: "JSONL Parsing",
+      duration: optimizedDuration / iterations,
+      memoryUsed: optimizedMemUsed,
+      itemsProcessed: optimizedCount / iterations,
+      throughput: optimizedCount / iterations / (optimizedDuration / 1e3 / iterations),
+      improvement
+    };
+    logger.info("JSONL Parsing Benchmark", {
+      baseline: {
+        duration: baselineDuration / iterations,
+        memory: baselineMemUsed,
+        throughput: baselineCount / iterations / (baselineDuration / 1e3 / iterations)
+      },
+      optimized: result,
+      improvements: {
+        speed: `${improvement.toFixed(1)}%`,
+        memory: `${memImprovement.toFixed(1)}%`
+      }
+    });
+    this.results.push(result);
+    return result;
+  }
+  /**
+   * Benchmark context caching performance
+   */
+  async benchmarkContextCache(itemCount = 1e3, accessPatterns = 1e4) {
+    const cache = new ContextCache({
+      maxSize: 50 * 1024 * 1024,
+      maxItems: itemCount
+    });
+    const testData = Array.from({ length: itemCount }, (_, i) => ({
+      key: `item-${i}`,
+      value: {
+        id: i,
+        data: "x".repeat(Math.floor(Math.random() * 1e3)),
+        timestamp: Date.now()
+      }
+    }));
+    const populateStart = performance.now();
+    for (const item of testData) {
+      cache.set(item.key, item.value);
+    }
+    const populateDuration = performance.now() - populateStart;
+    const accessStart = performance.now();
+    let hits = 0;
+    let misses = 0;
+    for (let i = 0; i < accessPatterns; i++) {
+      const index = Math.floor(Math.random() * itemCount * 1.2);
+      const key = `item-${index}`;
+      const result2 = cache.get(key);
+      if (result2) hits++;
+      else misses++;
+    }
+    const accessDuration = performance.now() - accessStart;
+    const stats = cache.getStats();
+    const result = {
+      name: "Context Cache",
+      duration: accessDuration,
+      memoryUsed: cache.getSize().bytes,
+      itemsProcessed: accessPatterns,
+      throughput: accessPatterns / (accessDuration / 1e3),
+      improvement: stats.hitRate * 100
+    };
+    logger.info("Context Cache Benchmark", {
+      populate: {
+        duration: populateDuration,
+        items: itemCount
+      },
+      access: {
+        duration: accessDuration,
+        patterns: accessPatterns,
+        hitRate: `${(stats.hitRate * 100).toFixed(1)}%`
+      },
+      performance: {
+        throughput: `${result.throughput.toFixed(0)} ops/sec`,
+        avgAccessTime: `${stats.avgAccessTime.toFixed(2)}ms`
+      }
+    });
+    this.results.push(result);
+    return result;
+  }
+  /**
+   * Benchmark lazy loading performance
+   */
+  async benchmarkLazyLoading(db, projectId, frameCount = 100) {
+    const loader = new LazyContextLoader(db, projectId);
+    let frames = [];
+    try {
+      frames = db.prepare("SELECT id FROM frames ORDER BY updated_at DESC LIMIT ?").all(frameCount);
+    } catch (error) {
+      logger.warn("Frames table not found, using mock data for benchmark");
+      frames = Array.from({ length: Math.min(frameCount, 10) }, (_, i) => ({
+        id: `frame-${i}`
+      }));
+    }
+    const frameIds = frames.map((f) => f.id);
+    const eagerStart = performance.now();
+    const eagerMemStart = process.memoryUsage().heapUsed;
+    const eagerData = [];
+    for (const id of frameIds) {
+      try {
+        const frame = db.prepare("SELECT * FROM frames WHERE id = ?").get(id);
+        const anchors = db.prepare("SELECT * FROM anchors WHERE frame_id = ?").all(id);
+        const events = db.prepare("SELECT * FROM events WHERE frame_id = ? LIMIT 10").all(id);
+        eagerData.push({ frame, anchors, events });
+      } catch {
+        eagerData.push({
+          frame: { id, type: "mock", name: `Mock ${id}` },
+          anchors: [],
+          events: []
+        });
+      }
+    }
+    const eagerDuration = performance.now() - eagerStart;
+    const eagerMemUsed = process.memoryUsage().heapUsed - eagerMemStart;
+    const lazyStart = performance.now();
+    const lazyMemStart = process.memoryUsage().heapUsed;
+    await loader.preloadContext(frameIds, { parallel: true, depth: 2 });
+    let accessedCount = 0;
+    for (const id of frameIds.slice(0, frameCount / 2)) {
+      const frame = await loader.lazyFrame(id).get();
+      if (frame) accessedCount++;
+    }
+    const lazyDuration = performance.now() - lazyStart;
+    const lazyMemUsed = process.memoryUsage().heapUsed - lazyMemStart;
+    const improvement = (eagerDuration - lazyDuration) / eagerDuration * 100;
+    const memImprovement = (eagerMemUsed - lazyMemUsed) / eagerMemUsed * 100;
+    const result = {
+      name: "Lazy Loading",
+      duration: lazyDuration,
+      memoryUsed: lazyMemUsed,
+      itemsProcessed: frameCount,
+      throughput: frameCount / (lazyDuration / 1e3),
+      improvement
+    };
+    logger.info("Lazy Loading Benchmark", {
+      eager: {
+        duration: eagerDuration,
+        memory: eagerMemUsed
+      },
+      lazy: {
+        duration: lazyDuration,
+        memory: lazyMemUsed,
+        accessed: accessedCount
+      },
+      improvements: {
+        speed: `${improvement.toFixed(1)}%`,
+        memory: `${memImprovement.toFixed(1)}%`
+      }
+    });
+    this.results.push(result);
+    return result;
+  }
+  /**
+   * Run full benchmark suite
+   */
+  async runFullSuite(projectRoot, db, projectId) {
+    const suiteStart = performance.now();
+    logger.info("Starting Performance Benchmark Suite");
+    const tasksFile = join(projectRoot, ".stackmemory", "tasks.jsonl");
+    const jsonlResult = await this.benchmarkJSONLParsing(tasksFile);
+    const cacheResult = await this.benchmarkContextCache();
+    const lazyResult = await this.benchmarkLazyLoading(db, projectId);
+    const totalDuration = performance.now() - suiteStart;
+    const averageImprovement = this.results.filter((r) => r.improvement !== void 0).reduce((sum, r) => sum + (r.improvement || 0), 0) / this.results.filter((r) => r.improvement !== void 0).length;
+    const suite = {
+      name: "Performance Optimization Suite",
+      results: this.results,
+      totalDuration,
+      averageImprovement
+    };
+    this.generateReport(suite);
+    return suite;
+  }
+  /**
+   * Generate performance report
+   */
+  generateReport(suite) {
+    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");
+    console.log("\u2551     Performance Benchmark Results         \u2551");
+    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");
+    for (const result of suite.results) {
+      console.log(`\u{1F4CA} ${result.name}`);
+      console.log(`   Duration: ${result.duration.toFixed(2)}ms`);
+      console.log(
+        `   Memory: ${(result.memoryUsed / 1024 / 1024).toFixed(2)}MB`
+      );
+      console.log(`   Throughput: ${result.throughput.toFixed(0)} items/sec`);
+      if (result.improvement !== void 0) {
+        const icon = result.improvement > 0 ? "\u{1F680}" : "\u26A0\uFE0F";
+        console.log(
+          `   ${icon} Improvement: ${result.improvement.toFixed(1)}%`
+        );
+      }
+      console.log("");
+    }
+    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");
+    console.log(`\u23F1\uFE0F  Total Duration: ${suite.totalDuration.toFixed(2)}ms`);
+    console.log(
+      `\u{1F4C8} Average Improvement: ${suite.averageImprovement.toFixed(1)}%`
+    );
+    console.log("");
+    logger.info("Performance Benchmark Complete", {
+      suite: suite.name,
+      duration: suite.totalDuration,
+      avgImprovement: suite.averageImprovement,
+      results: suite.results.map((r) => ({
+        name: r.name,
+        improvement: r.improvement,
+        throughput: r.throughput
+      }))
+    });
+  }
+  /**
+   * Get benchmark results
+   */
+  getResults() {
+    return this.results;
+  }
+  /**
+   * Clear results
+   */
+  clearResults() {
+    this.results = [];
+  }
+}
+export {
+  PerformanceBenchmark
+};
+//# sourceMappingURL=performance-benchmark.js.map