jiren 1.1.1 → 1.2.0

package/components/cache.ts

@@ -0,0 +1,181 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { gzipSync, gunzipSync } from "zlib";
+import { createHash } from "crypto";
+import { join } from "path";
+import type { JirenResponse } from "./types";
+
+interface CacheEntry {
+  response: JirenResponse;
+  timestamp: number;
+  ttl: number;
+}
+
+export class ResponseCache {
+  private cacheDir: string;
+  private maxSize: number;
+
+  constructor(maxSize = 100, cacheDir = ".cache/jiren") {
+    this.maxSize = maxSize;
+    this.cacheDir = cacheDir;
+
+    // Create cache directory if it doesn't exist
+    if (!existsSync(this.cacheDir)) {
+      mkdirSync(this.cacheDir, { recursive: true });
+    }
+  }
+
+  /**
+   * Generate cache key from URL and options
+   */
+  private generateKey(url: string, path?: string, options?: any): string {
+    const fullUrl = path ? `${url}${path}` : url;
+    const method = options?.method || "GET";
+    const headers = JSON.stringify(options?.headers || {});
+    const key = `${method}:${fullUrl}:${headers}`;
+
+    // Hash the key to create a valid filename
+    return createHash("md5").update(key).digest("hex");
+  }
+
+  /**
+   * Get cache file path (compressed .gz file)
+   */
+  private getCacheFilePath(key: string): string {
+    return join(this.cacheDir, `${key}.json.gz`);
+  }
+
+  /**
+   * Get cached response if valid
+   */
+  get(url: string, path?: string, options?: any): JirenResponse | null {
+    const key = this.generateKey(url, path, options);
+    const filePath = this.getCacheFilePath(key);
+
+    if (!existsSync(filePath)) return null;
+
+    try {
+      // Read compressed file
+      const compressed = readFileSync(filePath);
+
+      // Decompress
+      const decompressed = gunzipSync(compressed);
+      const data = decompressed.toString("utf-8");
+      const entry: CacheEntry = JSON.parse(data);
+
+      // Check if expired
+      const now = Date.now();
+      if (now - entry.timestamp > entry.ttl) {
+        // Delete expired cache file
+        try {
+          require("fs").unlinkSync(filePath);
+        } catch {}
+        return null;
+      }
+
+      return entry.response;
+    } catch (error) {
+      // Invalid cache file, delete it
+      try {
+        require("fs").unlinkSync(filePath);
+      } catch {}
+      return null;
+    }
+  }
+
+  /**
+   * Store response in cache as compressed JSON file
+   */
+  set(
+    url: string,
+    response: JirenResponse,
+    ttl: number,
+    path?: string,
+    options?: any
+  ): void {
+    const key = this.generateKey(url, path, options);
+    const filePath = this.getCacheFilePath(key);
+
+    const entry: CacheEntry = {
+      response,
+      timestamp: Date.now(),
+      ttl,
+    };
+
+    try {
+      // Convert to JSON
+      const json = JSON.stringify(entry);
+
+      // Compress with gzip
+      const compressed = gzipSync(json);
+
+      // Write compressed file
+      writeFileSync(filePath, compressed);
+    } catch (error) {
+      // Silently fail if can't write cache
+      console.warn("Failed to write cache:", error);
+    }
+  }
+
+  /**
+   * Clear cache for a specific URL or all
+   */
+  clear(url?: string): void {
+    if (url) {
+      // Clear all cache files for this URL
+      // This is approximate since we hash the keys
+      // For now, just clear all to be safe
+      this.clearAll();
+    } else {
+      this.clearAll();
+    }
+  }
+
+  /**
+   * Clear all cache files
+   */
+  private clearAll(): void {
+    try {
+      const fs = require("fs");
+      const files = fs.readdirSync(this.cacheDir);
+      for (const file of files) {
+        if (file.endsWith(".json.gz")) {
+          fs.unlinkSync(join(this.cacheDir, file));
+        }
+      }
+    } catch (error) {
+      // Silently fail
+    }
+  }
+
+  /**
+   * Get cache statistics
+   */
+  stats() {
+    try {
+      const fs = require("fs");
+      const files = fs.readdirSync(this.cacheDir);
+      const cacheFiles = files.filter((f: string) => f.endsWith(".json.gz"));
+
+      // Calculate total size
+      let totalSize = 0;
+      for (const file of cacheFiles) {
+        const stats = fs.statSync(join(this.cacheDir, file));
+        totalSize += stats.size;
+      }
+
+      return {
+        size: cacheFiles.length,
+        maxSize: this.maxSize,
+        cacheDir: this.cacheDir,
+        totalSizeKB: (totalSize / 1024).toFixed(2),
+      };
+    } catch {
+      return {
+        size: 0,
+        maxSize: this.maxSize,
+        cacheDir: this.cacheDir,
+        totalSizeKB: "0",
+      };
+    }
+  }
+}