@stackmemoryai/stackmemory 0.3.3 → 0.3.6

package/dist/core/storage/chromadb-simple.js

@@ -0,0 +1,160 @@
+import { ChromaClient } from "chromadb";
+import { v4 as uuidv4 } from "uuid";
+class ChromaDBAdapter {
+  client;
+  collection = null;
+  config;
+  fallbackStorage = /* @__PURE__ */ new Map();
+  constructor(config) {
+    this.config = config;
+    try {
+      if (config.apiUrl && config.apiUrl.includes("trychroma.com")) {
+        this.client = new ChromaClient({
+          ssl: true,
+          host: "api.trychroma.com",
+          port: 443,
+          headers: {
+            "X-Chroma-Token": config.apiKey
+          }
+        });
+      } else {
+        this.client = new ChromaClient();
+      }
+    } catch (error) {
+      console.log("Using in-memory ChromaDB client");
+      this.client = new ChromaClient();
+    }
+  }
+  async initialize() {
+    try {
+      const collectionName = this.config.collectionName || "stackmemory_context";
+      this.collection = await this.client.getOrCreateCollection({
+        name: collectionName,
+        metadata: {
+          description: "StackMemory Claude context",
+          version: "2.0.0"
+        }
+      });
+      console.log(`[${(/* @__PURE__ */ new Date()).toISOString()}] INFO: ChromaDB collection '${collectionName}' initialized`);
+    } catch (error) {
+      console.log(`ChromaDB service not available, using JSON fallback storage`);
+      this.collection = null;
+    }
+  }
+  async store(context) {
+    const id = context.id || `ctx_${uuidv4()}`;
+    const metadata = {
+      timestamp: context.timestamp || (/* @__PURE__ */ new Date()).toISOString(),
+      type: context.type || "context",
+      user_id: context.user_id || this.config.userId || "default",
+      project: context.project || "stackmemory"
+    };
+    if (context.session_id) metadata.session_id = context.session_id;
+    if (context.metadata) {
+      Object.entries(context.metadata).forEach(([key, value]) => {
+        if (value !== void 0 && value !== null) {
+          metadata[key] = value;
+        }
+      });
+    }
+    if (!this.collection) {
+      await this.initialize();
+    }
+    try {
+      if (this.collection) {
+        await this.collection.upsert({
+          ids: [id],
+          documents: [context.content || JSON.stringify(context)],
+          metadatas: [metadata]
+        });
+      } else {
+        await this.storeToJsonFallback(id, context, metadata);
+      }
+      return {
+        success: true,
+        id,
+        stored_at: (/* @__PURE__ */ new Date()).toISOString()
+      };
+    } catch (error) {
+      console.error("Failed to store context:", error.message);
+      try {
+        await this.storeToJsonFallback(id, context, metadata);
+        return { success: true, id, stored_at: (/* @__PURE__ */ new Date()).toISOString() };
+      } catch (fallbackError) {
+        return { success: false, error: fallbackError.message };
+      }
+    }
+  }
+  async storeToJsonFallback(id, context, metadata) {
+    const fs = await import("fs");
+    const path = await import("path");
+    const os = await import("os");
+    const storageDir = path.join(os.homedir(), ".stackmemory", "context-storage");
+    const storageFile = path.join(storageDir, "contexts.jsonl");
+    if (!fs.existsSync(storageDir)) {
+      fs.mkdirSync(storageDir, { recursive: true });
+    }
+    const entry = {
+      id,
+      content: context.content || JSON.stringify(context),
+      metadata,
+      stored_at: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    fs.appendFileSync(storageFile, JSON.stringify(entry) + "\n");
+  }
+  async search(params) {
+    if (!this.collection) {
+      await this.initialize();
+    }
+    try {
+      const query = params.query || "";
+      const limit = params.limit || 10;
+      const where = {};
+      if (params.filter) {
+        Object.entries(params.filter).forEach(([key, value]) => {
+          if (value !== void 0 && value !== null) {
+            where[key] = value;
+          }
+        });
+      }
+      const results = await this.collection.query({
+        queryTexts: [query],
+        nResults: limit,
+        where: Object.keys(where).length > 0 ? where : void 0
+      });
+      const contexts = [];
+      if (results.documents && results.documents[0]) {
+        for (let i = 0; i < results.documents[0].length; i++) {
+          contexts.push({
+            id: results.ids[0][i],
+            content: results.documents[0][i],
+            metadata: results.metadatas?.[0]?.[i] || {},
+            distance: results.distances?.[0]?.[i] || 0
+          });
+        }
+      }
+      return contexts;
+    } catch (error) {
+      console.error("Failed to search contexts:", error.message);
+      return [];
+    }
+  }
+  async deleteCollection() {
+    if (this.collection) {
+      await this.client.deleteCollection({
+        name: this.config.collectionName || "stackmemory_context"
+      });
+      console.log("Collection deleted");
+    }
+  }
+  async listCollections() {
+    const collections = await this.client.listCollections();
+    return collections;
+  }
+}
+var chromadb_simple_default = ChromaDBAdapter;
+export {
+  ChromaDBAdapter,
+  chromadb_simple_default as default
+};
+//# sourceMappingURL=chromadb-simple.js.map

package/dist/core/storage/chromadb-simple.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/core/storage/chromadb-simple.ts"],
+  "sourcesContent": ["/**\n * Simplified ChromaDB adapter for Claude hooks\n */\n\nimport { ChromaClient } from 'chromadb';\nimport { v4 as uuidv4 } from 'uuid';\n\nexport class ChromaDBAdapter {\n  private client: ChromaClient;\n  private collection: any = null;\n  private config: any;\n  private fallbackStorage: Map<string, any> = new Map();\n  \n  constructor(config: any) {\n    this.config = config;\n    \n    try {\n      // Try to initialize ChromaDB client\n      if (config.apiUrl && config.apiUrl.includes('trychroma.com')) {\n        // Cloud configuration\n        this.client = new ChromaClient({\n          ssl: true,\n          host: 'api.trychroma.com',\n          port: 443,\n          headers: {\n            'X-Chroma-Token': config.apiKey\n          }\n        });\n      } else {\n        // In-memory/local configuration (no external service needed)\n        this.client = new ChromaClient();\n      }\n    } catch (error) {\n      // Fallback to in-memory client\n      console.log('Using in-memory ChromaDB client');\n      this.client = new ChromaClient();\n    }\n  }\n\n  async initialize(): Promise<void> {\n    try {\n      // Use a single collection for all context\n      const collectionName = this.config.collectionName || 'stackmemory_context';\n      \n      // Get or create collection\n      this.collection = await this.client.getOrCreateCollection({\n        name: collectionName,\n        metadata: {\n          description: 'StackMemory Claude context',\n          version: '2.0.0'\n        }\n      });\n      \n      console.log(`[${new Date().toISOString()}] INFO: ChromaDB collection '${collectionName}' initialized`);\n    } catch (error: any) {\n      console.log(`ChromaDB service not available, using JSON fallback storage`);\n      this.collection = null; // Use fallback\n    }\n  }\n\n  async store(context: any): Promise<any> {\n    const id = context.id || `ctx_${uuidv4()}`;\n    \n    // Prepare metadata - only include non-undefined values\n    const metadata: any = {\n      timestamp: context.timestamp || new Date().toISOString(),\n      type: context.type || 'context',\n      user_id: context.user_id || this.config.userId || 'default',\n      project: context.project || 'stackmemory'\n    };\n\n    // Add optional metadata if defined\n    if (context.session_id) metadata.session_id = context.session_id;\n    if (context.metadata) {\n      Object.entries(context.metadata).forEach(([key, value]) => {\n        if (value !== undefined && value !== null) {\n          metadata[key] = value;\n        }\n      });\n    }\n\n    if (!this.collection) {\n      await this.initialize();\n    }\n\n    try {\n      if (this.collection) {\n        // Store in ChromaDB if available\n        await this.collection.upsert({\n          ids: [id],\n          documents: [context.content || JSON.stringify(context)],\n          metadatas: [metadata]\n        });\n      } else {\n        // Fallback to JSON file storage\n        await this.storeToJsonFallback(id, context, metadata);\n      }\n\n      return { \n        success: true, \n        id,\n        stored_at: new Date().toISOString()\n      };\n    } catch (error: any) {\n      console.error('Failed to store context:', error.message);\n      // Try fallback storage\n      try {\n        await this.storeToJsonFallback(id, context, metadata);\n        return { success: true, id, stored_at: new Date().toISOString() };\n      } catch (fallbackError: any) {\n        return { success: false, error: fallbackError.message };\n      }\n    }\n  }\n\n  private async storeToJsonFallback(id: string, context: any, metadata: any): Promise<void> {\n    const fs = await import('fs');\n    const path = await import('path');\n    const os = await import('os');\n    \n    const storageDir = path.join(os.homedir(), '.stackmemory', 'context-storage');\n    const storageFile = path.join(storageDir, 'contexts.jsonl');\n\n    // Ensure directory exists\n    if (!fs.existsSync(storageDir)) {\n      fs.mkdirSync(storageDir, { recursive: true });\n    }\n\n    const entry = {\n      id,\n      content: context.content || JSON.stringify(context),\n      metadata,\n      stored_at: new Date().toISOString()\n    };\n\n    // Append to JSONL file\n    fs.appendFileSync(storageFile, JSON.stringify(entry) + '\\n');\n  }\n\n  async search(params: any): Promise<any[]> {\n    if (!this.collection) {\n      await this.initialize();\n    }\n\n    try {\n      const query = params.query || '';\n      const limit = params.limit || 10;\n      \n      // Build where clause\n      const where: any = {};\n      if (params.filter) {\n        Object.entries(params.filter).forEach(([key, value]) => {\n          if (value !== undefined && value !== null) {\n            where[key] = value;\n          }\n        });\n      }\n\n      // Query collection\n      const results = await this.collection.query({\n        queryTexts: [query],\n        nResults: limit,\n        where: Object.keys(where).length > 0 ? where : undefined\n      });\n\n      // Format results\n      const contexts: any[] = [];\n      if (results.documents && results.documents[0]) {\n        for (let i = 0; i < results.documents[0].length; i++) {\n          contexts.push({\n            id: results.ids[0][i],\n            content: results.documents[0][i],\n            metadata: results.metadatas?.[0]?.[i] || {},\n            distance: results.distances?.[0]?.[i] || 0\n          });\n        }\n      }\n\n      return contexts;\n    } catch (error: any) {\n      console.error('Failed to search contexts:', error.message);\n      return [];\n    }\n  }\n\n  async deleteCollection(): Promise<void> {\n    if (this.collection) {\n      await this.client.deleteCollection({\n        name: this.config.collectionName || 'stackmemory_context'\n      });\n      console.log('Collection deleted');\n    }\n  }\n\n  async listCollections(): Promise<any[]> {\n    const collections = await this.client.listCollections();\n    return collections;\n  }\n}\n\nexport default ChromaDBAdapter;"],
+  "mappings": "AAIA,SAAS,oBAAoB;AAC7B,SAAS,MAAM,cAAc;AAEtB,MAAM,gBAAgB;AAAA,EACnB;AAAA,EACA,aAAkB;AAAA,EAClB;AAAA,EACA,kBAAoC,oBAAI,IAAI;AAAA,EAEpD,YAAY,QAAa;AACvB,SAAK,SAAS;AAEd,QAAI;AAEF,UAAI,OAAO,UAAU,OAAO,OAAO,SAAS,eAAe,GAAG;AAE5D,aAAK,SAAS,IAAI,aAAa;AAAA,UAC7B,KAAK;AAAA,UACL,MAAM;AAAA,UACN,MAAM;AAAA,UACN,SAAS;AAAA,YACP,kBAAkB,OAAO;AAAA,UAC3B;AAAA,QACF,CAAC;AAAA,MACH,OAAO;AAEL,aAAK,SAAS,IAAI,aAAa;AAAA,MACjC;AAAA,IACF,SAAS,OAAO;AAEd,cAAQ,IAAI,iCAAiC;AAC7C,WAAK,SAAS,IAAI,aAAa;AAAA,IACjC;AAAA,EACF;AAAA,EAEA,MAAM,aAA4B;AAChC,QAAI;AAEF,YAAM,iBAAiB,KAAK,OAAO,kBAAkB;AAGrD,WAAK,aAAa,MAAM,KAAK,OAAO,sBAAsB;AAAA,QACxD,MAAM;AAAA,QACN,UAAU;AAAA,UACR,aAAa;AAAA,UACb,SAAS;AAAA,QACX;AAAA,MACF,CAAC;AAED,cAAQ,IAAI,KAAI,oBAAI,KAAK,GAAE,YAAY,CAAC,gCAAgC,cAAc,eAAe;AAAA,IACvG,SAAS,OAAY;AACnB,cAAQ,IAAI,6DAA6D;AACzE,WAAK,aAAa;AAAA,IACpB;AAAA,EACF;AAAA,EAEA,MAAM,MAAM,SAA4B;AACtC,UAAM,KAAK,QAAQ,MAAM,OAAO,OAAO,CAAC;AAGxC,UAAM,WAAgB;AAAA,MACpB,WAAW,QAAQ,cAAa,oBAAI,KAAK,GAAE,YAAY;AAAA,MACvD,MAAM,QAAQ,QAAQ;AAAA,MACtB,SAAS,QAAQ,WAAW,KAAK,OAAO,UAAU;AAAA,MAClD,SAAS,QAAQ,WAAW;AAAA,IAC9B;AAGA,QAAI,QAAQ,WAAY,UAAS,aAAa,QAAQ;AACtD,QAAI,QAAQ,UAAU;AACpB,aAAO,QAAQ,QAAQ,QAAQ,EAAE,QAAQ,CAAC,CAAC,KAAK,KAAK,MAAM;AACzD,YAAI,UAAU,UAAa,UAAU,MAAM;AACzC,mBAAS,GAAG,IAAI;AAAA,QAClB;AAAA,MACF,CAAC;AAAA,IACH;AAEA,QAAI,CAAC,KAAK,YAAY;AACpB,YAAM,KAAK,WAAW;AAAA,IACxB;AAEA,QAAI;AACF,UAAI,KAAK,YAAY;AAEnB,cAAM,KAAK,WAAW,OAAO;AAAA,UAC3B,KAAK,CAAC,EAAE;AAAA,UACR,WAAW,CAAC,QAAQ,WAAW,KAAK,UAAU,OAAO,CAAC;AAAA,UACtD,WAAW,CAAC,QAAQ;AAAA,QACtB,CAAC;AAAA,MACH,OAAO;AAEL,cAAM,KAAK,oBAAoB,IAAI,SAAS,QAAQ;AAAA,MACtD;AAEA,aAAO;AAAA,QACL,SAAS;AAAA,QACT;AAAA,QACA,YAAW,oBAAI,KAAK,GAAE,YAAY;AAAA,MACpC;AAAA,IACF,SAAS,OAAY;AACnB,cAAQ,MAAM,4BAA4B,MAAM,OAAO;AAEvD,UAAI;AACF,cAAM,KAAK,oBAAoB,IAAI,SAAS,QAAQ;AACpD,eAAO,EAAE,SAAS,MAAM,IAAI,YAAW,oBAAI,KAAK,GAAE,YAAY,EAAE;AAAA,MAClE,SAAS,eAAoB;AAC3B,eAAO,EAAE,SAAS,OAAO,OAAO,cAAc,QAAQ;AAAA,MACxD;AAAA,IACF;AAAA,EACF;AAAA,EAEA,MAAc,oBAAoB,IAAY,SAAc,UAA8B;AACxF,UAAM,KAAK,MAAM,OAAO,IAAI;AAC5B,UAAM,OAAO,MAAM,OAAO,MAAM;AAChC,UAAM,KAAK,MAAM,OAAO,IAAI;AAE5B,UAAM,aAAa,KAAK,KAAK,GAAG,QAAQ,GAAG,gBAAgB,iBAAiB;AAC5E,UAAM,cAAc,KAAK,KAAK,YAAY,gBAAgB;AAG1D,QAAI,CAAC,GAAG,WAAW,UAAU,GAAG;AAC9B,SAAG,UAAU,YAAY,EAAE,WAAW,KAAK,CAAC;AAAA,IAC9C;AAEA,UAAM,QAAQ;AAAA,MACZ;AAAA,MACA,SAAS,QAAQ,WAAW,KAAK,UAAU,OAAO;AAAA,MAClD;AAAA,MACA,YAAW,oBAAI,KAAK,GAAE,YAAY;AAAA,IACpC;AAGA,OAAG,eAAe,aAAa,KAAK,UAAU,KAAK,IAAI,IAAI;AAAA,EAC7D;AAAA,EAEA,MAAM,OAAO,QAA6B;AACxC,QAAI,CAAC,KAAK,YAAY;AACpB,YAAM,KAAK,WAAW;AAAA,IACxB;AAEA,QAAI;AACF,YAAM,QAAQ,OAAO,SAAS;AAC9B,YAAM,QAAQ,OAAO,SAAS;AAG9B,YAAM,QAAa,CAAC;AACpB,UAAI,OAAO,QAAQ;AACjB,eAAO,QAAQ,OAAO,MAAM,EAAE,QAAQ,CAAC,CAAC,KAAK,KAAK,MAAM;AACtD,cAAI,UAAU,UAAa,UAAU,MAAM;AACzC,kBAAM,GAAG,IAAI;AAAA,UACf;AAAA,QACF,CAAC;AAAA,MACH;AAGA,YAAM,UAAU,MAAM,KAAK,WAAW,MAAM;AAAA,QAC1C,YAAY,CAAC,KAAK;AAAA,QAClB,UAAU;AAAA,QACV,OAAO,OAAO,KAAK,KAAK,EAAE,SAAS,IAAI,QAAQ;AAAA,MACjD,CAAC;AAGD,YAAM,WAAkB,CAAC;AACzB,UAAI,QAAQ,aAAa,QAAQ,UAAU,CAAC,GAAG;AAC7C,iBAAS,IAAI,GAAG,IAAI,QAAQ,UAAU,CAAC,EAAE,QAAQ,KAAK;AACpD,mBAAS,KAAK;AAAA,YACZ,IAAI,QAAQ,IAAI,CAAC,EAAE,CAAC;AAAA,YACpB,SAAS,QAAQ,UAAU,CAAC,EAAE,CAAC;AAAA,YAC/B,UAAU,QAAQ,YAAY,CAAC,IAAI,CAAC,KAAK,CAAC;AAAA,YAC1C,UAAU,QAAQ,YAAY,CAAC,IAAI,CAAC,KAAK;AAAA,UAC3C,CAAC;AAAA,QACH;AAAA,MACF;AAEA,aAAO;AAAA,IACT,SAAS,OAAY;AACnB,cAAQ,MAAM,8BAA8B,MAAM,OAAO;AACzD,aAAO,CAAC;AAAA,IACV;AAAA,EACF;AAAA,EAEA,MAAM,mBAAkC;AACtC,QAAI,KAAK,YAAY;AACnB,YAAM,KAAK,OAAO,iBAAiB;AAAA,QACjC,MAAM,KAAK,OAAO,kBAAkB;AAAA,MACtC,CAAC;AACD,cAAQ,IAAI,oBAAoB;AAAA,IAClC;AAAA,EACF;AAAA,EAEA,MAAM,kBAAkC;AACtC,UAAM,cAAc,MAAM,KAAK,OAAO,gBAAgB;AACtD,WAAO;AAAA,EACT;AACF;AAEA,IAAO,0BAAQ;",
+  "names": []
+}

package/dist/core/storage/infinite-storage.js

@@ -0,0 +1,443 @@
+import { S3Client, PutObjectCommand, GetObjectCommand } from "@aws-sdk/client-s3";
+import { createClient as createRedisClient } from "redis";
+import { Pool } from "pg";
+import { Logger } from "../monitoring/logger.js";
+import { compress, decompress } from "../utils/compression.js";
+class InfiniteStorageSystem {
+  redisClient;
+  timeseriesPool;
+  s3Client;
+  logger;
+  config;
+  latencies = [];
+  migrationWorker = null;
+  constructor(config) {
+    this.config = config;
+    this.logger = new Logger("InfiniteStorage");
+    if (!config.tiers || config.tiers.length === 0) {
+      this.config.tiers = [
+        { name: "hot", ageThresholdHours: 1, storageClass: "MEMORY", accessLatencyMs: 5 },
+        { name: "warm", ageThresholdHours: 168, storageClass: "TIMESERIES", accessLatencyMs: 50 },
+        { name: "cold", ageThresholdHours: 720, storageClass: "S3_STANDARD", accessLatencyMs: 100 },
+        { name: "archive", ageThresholdHours: Infinity, storageClass: "S3_GLACIER", accessLatencyMs: 36e5 }
+      ];
+    }
+  }
+  async initialize() {
+    try {
+      if (this.config.redis?.url) {
+        this.redisClient = createRedisClient({
+          url: this.config.redis.url
+        });
+        await this.redisClient.connect();
+        await this.redisClient.configSet("maxmemory-policy", "allkeys-lru");
+        if (this.config.redis.maxMemoryMB) {
+          await this.redisClient.configSet("maxmemory", `${this.config.redis.maxMemoryMB}mb`);
+        }
+        this.logger.info("Redis client initialized for hot tier");
+      }
+      if (this.config.timeseries?.connectionString) {
+        this.timeseriesPool = new Pool({
+          connectionString: this.config.timeseries.connectionString,
+          max: 10,
+          idleTimeoutMillis: 3e4
+        });
+        await this.createTimeSeriesTables();
+        this.logger.info("TimeSeries DB initialized for warm tier");
+      }
+      if (this.config.s3?.bucket) {
+        this.s3Client = new S3Client({
+          region: this.config.s3.region || "us-east-1",
+          credentials: this.config.s3.accessKeyId ? {
+            accessKeyId: this.config.s3.accessKeyId,
+            secretAccessKey: this.config.s3.secretAccessKey
+          } : void 0
+        });
+        this.logger.info("S3 client initialized for cold/archive tiers");
+      }
+      this.startMigrationWorker();
+      this.logger.info("Infinite Storage System initialized");
+    } catch (error) {
+      this.logger.error("Failed to initialize storage system", error);
+      throw error;
+    }
+  }
+  /**
+   * Create TimeSeries tables for warm tier storage
+   */
+  async createTimeSeriesTables() {
+    const client = await this.timeseriesPool.connect();
+    try {
+      await client.query(`
+        CREATE TABLE IF NOT EXISTS frame_timeseries (
+          time TIMESTAMPTZ NOT NULL,
+          frame_id TEXT NOT NULL,
+          user_id TEXT NOT NULL,
+          project_name TEXT,
+          type TEXT,
+          data JSONB,
+          compressed_data BYTEA,
+          storage_tier TEXT DEFAULT 'warm',
+          access_count INTEGER DEFAULT 0,
+          last_accessed TIMESTAMPTZ DEFAULT NOW(),
+          PRIMARY KEY (time, frame_id)
+        )
+      `);
+      await client.query(`
+        SELECT create_hypertable('frame_timeseries', 'time', 
+          chunk_time_interval => INTERVAL '1 day',
+          if_not_exists => TRUE)
+      `).catch(() => {
+        this.logger.info("Using standard PostgreSQL partitioning");
+      });
+      await client.query(`
+        CREATE INDEX IF NOT EXISTS idx_frame_user ON frame_timeseries (user_id, time DESC);
+        CREATE INDEX IF NOT EXISTS idx_frame_project ON frame_timeseries (project_name, time DESC);
+        CREATE INDEX IF NOT EXISTS idx_frame_tier ON frame_timeseries (storage_tier);
+      `);
+      await client.query(`
+        SELECT add_compression_policy('frame_timeseries', INTERVAL '7 days', if_not_exists => TRUE)
+      `).catch(() => {
+        this.logger.info("Compression policy not available");
+      });
+    } finally {
+      client.release();
+    }
+  }
+  /**
+   * Store a frame with automatic tier selection
+   */
+  async storeFrame(frame, userId) {
+    const startTime = Date.now();
+    try {
+      const frameData = JSON.stringify(frame);
+      const compressedData = await compress(frameData);
+      const frameKey = `frame:${userId}:${frame.frameId}`;
+      if (this.redisClient) {
+        await this.redisClient.setEx(
+          frameKey,
+          this.config.redis.ttlSeconds || 3600,
+          compressedData
+        );
+        await this.redisClient.hSet(`meta:${frameKey}`, {
+          userId,
+          projectName: frame.projectName || "default",
+          type: frame.type,
+          timestamp: frame.timestamp,
+          tier: "hot"
+        });
+      }
+      if (this.timeseriesPool) {
+        const client = await this.timeseriesPool.connect();
+        try {
+          await client.query(`
+            INSERT INTO frame_timeseries (time, frame_id, user_id, project_name, type, data, compressed_data, storage_tier)
+            VALUES ($1, $2, $3, $4, $5, $6, $7, $8)
+            ON CONFLICT (time, frame_id) DO UPDATE
+            SET data = EXCLUDED.data,
+                compressed_data = EXCLUDED.compressed_data,
+                last_accessed = NOW(),
+                access_count = frame_timeseries.access_count + 1
+          `, [
+            new Date(frame.timestamp),
+            frame.frameId,
+            userId,
+            frame.projectName || "default",
+            frame.type,
+            frame,
+            compressedData,
+            "warm"
+          ]);
+        } finally {
+          client.release();
+        }
+      }
+      const latency = Date.now() - startTime;
+      this.trackLatency(latency);
+      this.logger.debug(`Stored frame ${frame.frameId} in ${latency}ms`);
+    } catch (error) {
+      this.logger.error(`Failed to store frame ${frame.frameId}`, error);
+      throw error;
+    }
+  }
+  /**
+   * Retrieve a frame with intelligent caching
+   */
+  async retrieveFrame(frameId, userId) {
+    const startTime = Date.now();
+    const frameKey = `frame:${userId}:${frameId}`;
+    try {
+      if (this.redisClient) {
+        const cached = await this.redisClient.get(frameKey);
+        if (cached) {
+          const decompressed = await decompress(cached);
+          const frame = JSON.parse(decompressed);
+          await this.redisClient.expire(frameKey, this.config.redis.ttlSeconds || 3600);
+          const latency = Date.now() - startTime;
+          this.trackLatency(latency);
+          this.logger.debug(`Retrieved frame ${frameId} from hot tier in ${latency}ms`);
+          return frame;
+        }
+      }
+      if (this.timeseriesPool) {
+        const client = await this.timeseriesPool.connect();
+        try {
+          const result = await client.query(`
+            SELECT data, compressed_data, storage_tier 
+            FROM frame_timeseries 
+            WHERE frame_id = $1 AND user_id = $2
+            ORDER BY time DESC
+            LIMIT 1
+          `, [frameId, userId]);
+          if (result.rows.length > 0) {
+            const row = result.rows[0];
+            let frame;
+            if (row.compressed_data) {
+              const decompressed = await decompress(row.compressed_data);
+              frame = JSON.parse(decompressed);
+            } else {
+              frame = row.data;
+            }
+            await client.query(`
+              UPDATE frame_timeseries 
+              SET last_accessed = NOW(), access_count = access_count + 1
+              WHERE frame_id = $1 AND user_id = $2
+            `, [frameId, userId]);
+            if (this.redisClient) {
+              await this.promoteToHotTier(frame, userId);
+            }
+            const latency = Date.now() - startTime;
+            this.trackLatency(latency);
+            this.logger.debug(`Retrieved frame ${frameId} from warm tier in ${latency}ms`);
+            return frame;
+          }
+        } finally {
+          client.release();
+        }
+      }
+      if (this.s3Client && this.config.s3.bucket) {
+        const key = `frames/${userId}/${frameId}.json.gz`;
+        try {
+          const command = new GetObjectCommand({
+            Bucket: this.config.s3.bucket,
+            Key: key
+          });
+          const response = await this.s3Client.send(command);
+          const compressedData = await response.Body.transformToByteArray();
+          const decompressed = await decompress(Buffer.from(compressedData));
+          const frame = JSON.parse(decompressed);
+          await this.promoteFrame(frame, userId);
+          const latency = Date.now() - startTime;
+          this.trackLatency(latency);
+          this.logger.debug(`Retrieved frame ${frameId} from cold tier in ${latency}ms`);
+          return frame;
+        } catch (error) {
+          if (error.Code !== "NoSuchKey") {
+            throw error;
+          }
+        }
+      }
+      this.logger.debug(`Frame ${frameId} not found in any tier`);
+      return null;
+    } catch (error) {
+      this.logger.error(`Failed to retrieve frame ${frameId}`, error);
+      throw error;
+    }
+  }
+  /**
+   * Promote frame to hot tier for fast access
+   */
+  async promoteToHotTier(frame, userId) {
+    if (!this.redisClient) return;
+    try {
+      const frameKey = `frame:${userId}:${frame.frameId}`;
+      const frameData = JSON.stringify(frame);
+      const compressedData = await compress(frameData);
+      await this.redisClient.setEx(
+        frameKey,
+        this.config.redis.ttlSeconds || 3600,
+        compressedData
+      );
+      this.logger.debug(`Promoted frame ${frame.frameId} to hot tier`);
+    } catch (error) {
+      this.logger.error(`Failed to promote frame ${frame.frameId}`, error);
+    }
+  }
+  /**
+   * Promote frame through storage tiers
+   */
+  async promoteFrame(frame, userId) {
+    if (this.timeseriesPool) {
+      const client = await this.timeseriesPool.connect();
+      try {
+        const compressedData = await compress(JSON.stringify(frame));
+        await client.query(`
+          INSERT INTO frame_timeseries (time, frame_id, user_id, data, compressed_data, storage_tier)
+          VALUES ($1, $2, $3, $4, $5, $6)
+          ON CONFLICT (time, frame_id) DO UPDATE
+          SET storage_tier = 'warm',
+              last_accessed = NOW(),
+              access_count = frame_timeseries.access_count + 1
+        `, [
+          new Date(frame.timestamp),
+          frame.frameId,
+          userId,
+          frame,
+          compressedData,
+          "warm"
+        ]);
+      } finally {
+        client.release();
+      }
+    }
+    await this.promoteToHotTier(frame, userId);
+  }
+  /**
+   * Start background worker for tier migration
+   */
+  startMigrationWorker() {
+    this.migrationWorker = setInterval(async () => {
+      await this.migrateAgedData();
+    }, 60 * 60 * 1e3);
+    this.logger.info("Migration worker started");
+  }
+  /**
+   * Migrate aged data to appropriate storage tiers
+   */
+  async migrateAgedData() {
+    this.logger.info("Starting tier migration...");
+    if (!this.timeseriesPool) return;
+    const client = await this.timeseriesPool.connect();
+    try {
+      const coldEligible = await client.query(`
+        SELECT frame_id, user_id, data, compressed_data
+        FROM frame_timeseries
+        WHERE storage_tier = 'warm'
+          AND time < NOW() - INTERVAL '7 days'
+          AND last_accessed < NOW() - INTERVAL '7 days'
+        LIMIT 1000
+      `);
+      for (const row of coldEligible.rows) {
+        await this.migrateToS3(row, "STANDARD");
+        await client.query(`
+          UPDATE frame_timeseries
+          SET storage_tier = 'cold'
+          WHERE frame_id = $1 AND user_id = $2
+        `, [row.frame_id, row.user_id]);
+      }
+      const archiveEligible = await client.query(`
+        SELECT frame_id, user_id, data, compressed_data
+        FROM frame_timeseries
+        WHERE storage_tier = 'cold'
+          AND time < NOW() - INTERVAL '30 days'
+          AND last_accessed < NOW() - INTERVAL '30 days'
+        LIMIT 1000
+      `);
+      for (const row of archiveEligible.rows) {
+        await this.migrateToS3(row, "GLACIER");
+        await client.query(`
+          UPDATE frame_timeseries
+          SET storage_tier = 'archive'
+          WHERE frame_id = $1 AND user_id = $2
+        `, [row.frame_id, row.user_id]);
+      }
+      this.logger.info(`Migration completed: ${coldEligible.rows.length} to cold, ${archiveEligible.rows.length} to archive`);
+    } finally {
+      client.release();
+    }
+  }
+  /**
+   * Migrate data to S3 storage
+   */
+  async migrateToS3(row, storageClass) {
+    if (!this.s3Client || !this.config.s3.bucket) return;
+    try {
+      const key = `frames/${row.user_id}/${row.frame_id}.json.gz`;
+      const data = row.compressed_data || await compress(JSON.stringify(row.data));
+      const command = new PutObjectCommand({
+        Bucket: this.config.s3.bucket,
+        Key: key,
+        Body: data,
+        StorageClass: storageClass,
+        Metadata: {
+          userId: row.user_id,
+          frameId: row.frame_id,
+          migratedAt: (/* @__PURE__ */ new Date()).toISOString()
+        }
+      });
+      await this.s3Client.send(command);
+      this.logger.debug(`Migrated frame ${row.frame_id} to S3 ${storageClass}`);
+    } catch (error) {
+      this.logger.error(`Failed to migrate frame ${row.frame_id} to S3`, error);
+      throw error;
+    }
+  }
+  /**
+   * Track latency for performance monitoring
+   */
+  trackLatency(latencyMs) {
+    this.latencies.push(latencyMs);
+    if (this.latencies.length > 1e3) {
+      this.latencies.shift();
+    }
+  }
+  /**
+   * Get storage metrics
+   */
+  async getMetrics() {
+    const metrics = {
+      totalObjects: 0,
+      tierDistribution: {},
+      storageBytes: 0,
+      avgLatencyMs: 0,
+      p50LatencyMs: 0,
+      p99LatencyMs: 0
+    };
+    if (this.latencies.length > 0) {
+      const sorted = [...this.latencies].sort((a, b) => a - b);
+      metrics.avgLatencyMs = sorted.reduce((a, b) => a + b, 0) / sorted.length;
+      metrics.p50LatencyMs = sorted[Math.floor(sorted.length * 0.5)];
+      metrics.p99LatencyMs = sorted[Math.floor(sorted.length * 0.99)];
+    }
+    if (this.timeseriesPool) {
+      const client = await this.timeseriesPool.connect();
+      try {
+        const result = await client.query(`
+          SELECT 
+            storage_tier,
+            COUNT(*) as count,
+            SUM(pg_column_size(compressed_data)) as bytes
+          FROM frame_timeseries
+          GROUP BY storage_tier
+        `);
+        for (const row of result.rows) {
+          metrics.tierDistribution[row.storage_tier] = parseInt(row.count);
+          metrics.storageBytes += parseInt(row.bytes || 0);
+          metrics.totalObjects += parseInt(row.count);
+        }
+      } finally {
+        client.release();
+      }
+    }
+    return metrics;
+  }
+  /**
+   * Cleanup and shutdown
+   */
+  async shutdown() {
+    if (this.migrationWorker) {
+      clearInterval(this.migrationWorker);
+    }
+    if (this.redisClient) {
+      await this.redisClient.quit();
+    }
+    if (this.timeseriesPool) {
+      await this.timeseriesPool.end();
+    }
+    this.logger.info("Infinite Storage System shut down");
+  }
+}
+export {
+  InfiniteStorageSystem
+};
+//# sourceMappingURL=infinite-storage.js.map