page-action-cache 1.0.1

package/src/cache-store.ts

@@ -0,0 +1,457 @@
+/**
+ * Page Action Cache Store
+ * 管理页面操作缓存的存储
+ */
+
+import fs from "node:fs";
+import path from "node:path";
+import { createHash } from "node:crypto";
+import type {
+  PageActionCacheEntry,
+  PageActionCacheStore,
+  PageViewport,
+  CacheStats,
+  ScenarioMatch,
+} from "./types.js";
+
+// ============================================================================
+// 配置
+// ============================================================================
+
+const CACHE_DIR = path.join(
+  process.env.HOME || process.env.USERPROFILE || ".",
+  ".openclaw",
+  "cache",
+  "page-actions"
+);
+
+const CACHE_FILE = path.join(CACHE_DIR, "cache.json");
+const CACHE_VERSION = 1;
+
+const DEFAULT_TTL = {
+  L3: 7 * 24 * 60 * 60 * 1000, // 7 天
+  L2: 3 * 24 * 60 * 60 * 1000, // 3 天
+  L1: 30 * 60 * 1000, // 30 分钟
+};
+
+// ============================================================================
+// CacheStore 类
+// ============================================================================
+
+/**
+ * 缓存存储管理器
+ */
+export class CacheStore {
+  private store: PageActionCacheStore;
+
+  constructor() {
+    this.store = this.load();
+  }
+
+  // -------------------------------------------------------------------------
+  // 初始化和加载
+  // -------------------------------------------------------------------------
+
+  private load(): PageActionCacheStore {
+    try {
+      if (fs.existsSync(CACHE_FILE)) {
+        const data = fs.readFileSync(CACHE_FILE, "utf-8");
+        const loaded = JSON.parse(data) as PageActionCacheStore;
+
+        // 版本检查
+        if (loaded.version !== CACHE_VERSION) {
+          console.warn(
+            `[CacheStore] Cache version mismatch (expected ${CACHE_VERSION}, got ${loaded.version}), clearing cache`
+          );
+          return this.createEmptyStore();
+        }
+
+        return loaded;
+      }
+    } catch (error) {
+      console.error(`[CacheStore] Failed to load cache:`, error);
+    }
+
+    return this.createEmptyStore();
+  }
+
+  private createEmptyStore(): PageActionCacheStore {
+    return {
+      version: CACHE_VERSION,
+      entries: {},
+      scenarios: new Map<string, ScenarioMatch>(),
+      stats: {
+        totalEntries: 0,
+        totalHits: 0,
+        totalMisses: 0,
+        hitRate: 0,
+        l3Hits: 0,
+        l2Hits: 0,
+        l1Hits: 0,
+        scenarioMatches: 0,
+        llmClassifications: 0,
+        learnedAssociations: 0,
+        savedTokens: 0,
+        savedTime: 0,
+        avgExecutionTime: 0,
+        userConfirmations: 0,
+        userForcedRefreshes: 0,
+        cacheErrors: 0,
+      },
+    };
+  }
+
+  private ensureCacheDir(): void {
+    if (!fs.existsSync(CACHE_DIR)) {
+      fs.mkdirSync(CACHE_DIR, { recursive: true });
+    }
+  }
+
+  // -------------------------------------------------------------------------
+  // 保存
+  // -------------------------------------------------------------------------
+
+  private save(): void {
+    try {
+      this.ensureCacheDir();
+
+      // 序列化（处理 Map）
+      const serialized = {
+        ...this.store,
+        scenarios: Array.from(this.store.scenarios.entries()),
+      };
+
+      fs.writeFileSync(CACHE_FILE, JSON.stringify(serialized, null, 2));
+    } catch (error) {
+      console.error(`[CacheStore] Failed to save cache:`, error);
+    }
+  }
+
+  private scheduleSave(): void {
+    // 防抖保存（100ms）
+    if (this._saveTimeout) {
+      clearTimeout(this._saveTimeout);
+    }
+    this._saveTimeout = setTimeout(() => this.save(), 100);
+  }
+
+  private _saveTimeout: NodeJS.Timeout | null = null;
+
+  // -------------------------------------------------------------------------
+  // 缓存键生成
+  // -------------------------------------------------------------------------
+
+  private generateKey(url: string, viewport: PageViewport): string {
+    const normalizedUrl = this.normalizeUrl(url);
+    const viewportStr = `${viewport.width}x${viewport.height}`;
+    const hash = createHash("md5")
+      .update(`${normalizedUrl}:${viewportStr}`)
+      .digest("hex");
+    return hash || `fallback-${Date.now()}`; // 确保 hash 不为空
+  }
+
+  private normalizeUrl(url: string): string {
+    try {
+      const parsed = new URL(url);
+      // 移除查询参数和哈希（可根据配置调整）
+      parsed.search = "";
+      parsed.hash = "";
+      return parsed.toString();
+    } catch {
+      return url;
+    }
+  }
+
+  // -------------------------------------------------------------------------
+  // 基本操作
+  // -------------------------------------------------------------------------
+
+  /**
+   * 设置缓存条目
+   */
+  set(
+    url: string,
+    viewport: PageViewport,
+    actions: any[],
+    metadata: {
+      scenario: string;
+      cacheLevel: "L3" | "L2" | "L1";
+      variables?: Record<string, string>;
+      description?: string;
+      pageType?: "static" | "dynamic" | "mixed";
+    }
+  ): string {
+    const key = this.generateKey(url, viewport);
+    const now = Date.now();
+    const ttl = DEFAULT_TTL[metadata.cacheLevel];
+
+    const entry: PageActionCacheEntry = {
+      key,
+      url: this.normalizeUrl(url),
+      viewport,
+      cacheLevel: metadata.cacheLevel,
+      scenario: metadata.scenario,
+      description: metadata.description || `Cached ${metadata.scenario} actions`,
+      variables: metadata.variables,
+      actions,
+      createdAt: now,
+      lastAccessTime: now,
+      accessCount: 0,
+      expiresAt: now + ttl,
+      pageChangeDetection: {
+        hasChanged: false,
+        changeType: "none",
+        confidence: 100,
+        domHash: "",
+        lastCheckedAt: now,
+      },
+      source: "llm",
+      version: 1,
+      successCount: 0,
+      failCount: 0,
+      avgExecutionTime: 0,
+      pageType: metadata.pageType || "mixed",
+    };
+
+    this.store.entries[key] = entry;
+    this.store.stats.totalEntries++;
+
+    this.scheduleSave();
+    return key;
+  }
+
+  /**
+   * 获取缓存条目
+   */
+  get(url: string, viewport: PageViewport): PageActionCacheEntry | null {
+    const key = this.generateKey(url, viewport);
+    const entry = this.store.entries[key];
+
+    if (!entry) {
+      this.store.stats.totalMisses++;
+      this.updateHitRate();
+      return null;
+    }
+
+    // 检查过期
+    if (Date.now() > entry.expiresAt) {
+      delete this.store.entries[key];
+      this.store.stats.totalEntries--;
+      this.store.stats.totalMisses++;
+      this.updateHitRate();
+      this.scheduleSave();
+      return null;
+    }
+
+    // 更新访问统计
+    entry.lastAccessTime = Date.now();
+    entry.accessCount++;
+
+    // 更新层级统计
+    this.store.stats.totalHits++;
+    switch (entry.cacheLevel) {
+      case "L3":
+        this.store.stats.l3Hits++;
+        break;
+      case "L2":
+        this.store.stats.l2Hits++;
+        break;
+      case "L1":
+        this.store.stats.l1Hits++;
+        break;
+    }
+
+    this.updateHitRate();
+    this.scheduleSave();
+
+    return entry;
+  }
+
+  /**
+   * 删除缓存条目
+   */
+  delete(url: string, viewport: PageViewport): boolean {
+    const key = this.generateKey(url, viewport);
+    const existed = !!this.store.entries[key];
+
+    if (existed) {
+      delete this.store.entries[key];
+      this.store.stats.totalEntries--;
+      this.scheduleSave();
+    }
+
+    return existed;
+  }
+
+  /**
+   * 按模式删除缓存条目
+   */
+  deleteByPattern(urlPattern: string): number {
+    let deleted = 0;
+
+    for (const [key, entry] of Object.entries(this.store.entries)) {
+      if (entry.url.includes(urlPattern)) {
+        delete this.store.entries[key];
+        this.store.stats.totalEntries--;
+        deleted++;
+      }
+    }
+
+    if (deleted > 0) {
+      this.scheduleSave();
+    }
+
+    return deleted;
+  }
+
+  /**
+   * 清空所有缓存
+   */
+  clear(): void {
+    this.store.entries = {};
+    this.store.scenarios.clear();
+    this.store.stats = this.createEmptyStore().stats;
+    this.scheduleSave();
+  }
+
+  // -------------------------------------------------------------------------
+  // 统计更新
+  // -------------------------------------------------------------------------
+
+  private updateHitRate(): void {
+    const total = this.store.stats.totalHits + this.store.stats.totalMisses;
+    this.store.stats.hitRate =
+      total > 0 ? (this.store.stats.totalHits / total) * 100 : 0;
+  }
+
+  /**
+   * 更新执行统计
+   */
+  updateExecutionStats(
+    key: string,
+    results: Array<{ success: boolean; duration: number }>
+  ): void {
+    const entry = this.store.entries[key];
+    if (!entry) return;
+
+    const successCount = results.filter((r) => r.success).length;
+    const failCount = results.length - successCount;
+    const avgDuration =
+      results.reduce((sum, r) => sum + r.duration, 0) / results.length;
+
+    // 更新统计（加权平均）
+    const oldCount = entry.successCount + entry.failCount;
+    const newCount = oldCount + results.length;
+
+    entry.successCount += successCount;
+    entry.failCount += failCount;
+    entry.avgExecutionTime =
+      (entry.avgExecutionTime * oldCount + avgDuration * results.length) /
+      newCount;
+
+    // 估算节省的 token 和时间
+    this.store.stats.savedTokens += 5000; // 估算值
+    this.store.stats.savedTime += 2000; // 估算值（毫秒）
+
+    this.scheduleSave();
+  }
+
+  // -------------------------------------------------------------------------
+  // 场景匹配管理
+  // -------------------------------------------------------------------------
+
+  /**
+   * 保存场景匹配
+   */
+  saveScenarioMatch(match: ScenarioMatch): void {
+    this.store.scenarios.set(match.scenario, match);
+    this.store.stats.scenarioMatches++;
+    this.scheduleSave();
+  }
+
+  /**
+   * 获取场景匹配
+   */
+  getScenarioMatch(scenario: string): ScenarioMatch | undefined {
+    return this.store.scenarios.get(scenario);
+  }
+
+  // -------------------------------------------------------------------------
+  // 查询方法
+  // -------------------------------------------------------------------------
+
+  /**
+   * 获取统计信息
+   */
+  getStats(): CacheStats {
+    return { ...this.store.stats };
+  }
+
+  /**
+   * 列出所有缓存条目
+   */
+  listEntries(): PageActionCacheEntry[] {
+    return Object.values(this.store.entries).sort(
+      (a, b) => b.lastAccessTime - a.lastAccessTime
+    );
+  }
+
+  /**
+   * 获取热门场景
+   */
+  getTopScenarios(limit: number = 5): string {
+    const scenarioCounts = new Map<string, number>();
+
+    for (const entry of Object.values(this.store.entries)) {
+      const count = scenarioCounts.get(entry.scenario) || 0;
+      scenarioCounts.set(entry.scenario, count + entry.accessCount);
+    }
+
+    const sorted = Array.from(scenarioCounts.entries())
+      .sort((a, b) => b[1] - a[1])
+      .slice(0, limit);
+
+    return sorted
+      .map(([scenario, count]) => `- ${scenario}: ${count} 次`)
+      .join("\n");
+  }
+
+  // -------------------------------------------------------------------------
+  // 清理
+  // -------------------------------------------------------------------------
+
+  /**
+   * 清理过期缓存
+   */
+  cleanupExpired(): number {
+    const now = Date.now();
+    let cleaned = 0;
+
+    for (const [key, entry] of Object.entries(this.store.entries)) {
+      if (now > entry.expiresAt) {
+        delete this.store.entries[key];
+        this.store.stats.totalEntries--;
+        cleaned++;
+      }
+    }
+
+    if (cleaned > 0) {
+      this.scheduleSave();
+    }
+
+    return cleaned;
+  }
+}
+
+// ============================================================================
+// 单例
+// ============================================================================
+
+let cacheStoreInstance: CacheStore | null = null;
+
+export function getCacheStore(): CacheStore {
+  if (!cacheStoreInstance) {
+    cacheStoreInstance = new CacheStore();
+  }
+  return cacheStoreInstance;
+}