openclaw-multi-auto 1.5.2 → 1.5.5

package/extensions/page-action-cache/src/cache-invalidator.ts

@@ -1,271 +0,0 @@
-/**
- * Cache Invalidator
- * 缓存失效检测器 - 检测页面变化并失效缓存
- */
-
-import type {
-  PageViewport,
-  PageChangeDetection,
-  PageActionCacheEntry,
-  DOMHashFeatures,
-} from "./types.js";
-
-// ============================================================================
-// Cache Invalidator 类
-// ============================================================================
-
-/**
- * 缓存失效检测器
- */
-export class CacheInvalidator {
-  /**
-   * 检测页面是否发生变化
-   */
-  async detectPageChange(
-    html: string,
-    _url: string,
-    _viewport: PageViewport,
-    cachedEntry?: PageActionCacheEntry
-  ): Promise<PageChangeDetection> {
-    // 计算当前 DOM hash
-    const currentHash = this.calculateDOMHash(html);
-
-    if (!cachedEntry || !cachedEntry.pageChangeDetection) {
-      return {
-        hasChanged: true,
-        changeType: "none",
-        confidence: 0,
-        domHash: currentHash,
-        lastCheckedAt: Date.now(),
-      };
-    }
-
-    const cachedHash = cachedEntry.pageChangeDetection.domHash;
-
-    // 比较 hash
-    if (currentHash === cachedHash) {
-      return {
-        hasChanged: false,
-        changeType: "none",
-        confidence: 100,
-        domHash: currentHash,
-        lastCheckedAt: Date.now(),
-      };
-    }
-
-    // 检测变化类型
-    const structureChanged = this.detectStructureChange(html);
-    const contentChanged = this.detectContentChange(html, cachedEntry);
-
-    if (structureChanged || contentChanged) {
-      return {
-        hasChanged: true,
-        changeType: structureChanged ? "structure" : "content",
-        confidence: Math.max(
-          structureChanged ? 80 : 0,
-          contentChanged ? 80 : 0
-        ),
-        domHash: currentHash,
-        lastCheckedAt: Date.now(),
-        details: structureChanged
-          ? "Form/Button count changed"
-          : "Content hash changed",
-      };
-    }
-
-    // hash 不同但结构未变，可能是动态内容
-    return {
-      hasChanged: true,
-      changeType: "content",
-      confidence: 50, // 低置信度，可能是动态内容
-      domHash: currentHash,
-      lastCheckedAt: Date.now(),
-      details: "Hash changed but structure is similar",
-    };
-  }
-
-  /**
-   * 计算 DOM hash
-   */
-  calculateDOMHash(html: string): string {
-    const features = this.extractDOMFeatures(html);
-    return this.combineFeaturesHash(features);
-  }
-
-  /**
-   * 提取 DOM 特征
-   */
-  private extractDOMFeatures(html: string): DOMHashFeatures {
-    return {
-      formCount: this.countElements(html, "form"),
-      buttonCount: this.countElements(html, "button"),
-      linkCount: this.countElements(html, "a"),
-      scriptCount: this.countElements(html, "script"),
-      headingCount:
-        this.countElements(html, "h1") +
-        this.countElements(html, "h2") +
-        this.countElements(html, "h3"),
-    };
-  }
-
-  /**
-   * 计算元素数量
-   */
-  private countElements(html: string, tagName: string): number {
-    const regex = new RegExp(`<${tagName}\\b`, "gi");
-    return (html.match(regex) || []).length;
-  }
-
-  /**
-   * 组合特征为 hash
-   */
-  private combineFeaturesHash(features: DOMHashFeatures): string {
-    const values = [
-      features.formCount,
-      features.buttonCount,
-      features.linkCount,
-      features.scriptCount,
-      features.headingCount,
-    ];
-
-    // 简单 hash 算法
-    let hash = 0;
-    for (const value of values) {
-      hash = ((hash << 5) - hash + value) | 0;
-    }
-    return hash.toString(16);
-  }
-
-  /**
-   * 检测结构变化
-   */
-  private detectStructureChange(html: string): boolean {
-    // 检查表单和按钮数量是否发生显著变化
-    const features = this.extractDOMFeatures(html);
-
-    // 如果表单数量变化，认为是结构变化
-    // 这里简化处理，实际应该与缓存条目比较
-    const hasForm = features.formCount > 0;
-
-    return !hasForm;
-  }
-
-  /**
-   * 检测内容变化
-   */
-  private detectContentChange(
-    html: string,
-    cachedEntry: PageActionCacheEntry
-  ): boolean {
-    // 简化处理：检查 HTML 长度变化
-    const lengthChanged = Math.abs(html.length - (cachedEntry.actions.length * 100)) > 500;
-
-    return lengthChanged;
-  }
-
-  /**
-   * 判断是否应该失效缓存
-   */
-  shouldInvalidate(
-    entry: PageActionCacheEntry,
-    changeResult: PageChangeDetection,
-    threshold: number = 80
-  ): boolean {
-    // 根据页面类型和置信度决定是否失效
-    const pageType = entry.pageType || "mixed";
-
-    if (pageType === "static") {
-      // 静态页面：高置信度时失效
-      return changeResult.hasChanged && changeResult.confidence >= threshold;
-    } else if (pageType === "dynamic") {
-      // 动态页面：只在结构变化时失效
-      return (
-        changeResult.hasChanged && changeResult.changeType === "structure"
-      );
-    } else {
-      // 混合页面：中等置信度时失效
-      return (
-        changeResult.hasChanged && changeResult.confidence >= threshold - 10
-      );
-    }
-  }
-
-  /**
-   * 创建渐进式失效器
-   */
-  createProgressiveInvalidator(): ProgressiveInvalidator {
-    return new ProgressiveInvalidator();
-  }
-}
-
-// ============================================================================
-// Progressive Invalidator 类
-// ============================================================================
-
-/**
- * 渐进式失效：保留多版本
- */
-export class ProgressiveInvalidator {
-  private versions: Map<string, string[]> = new Map();
-
-  /**
-   * 添加版本
-   */
-  addVersion(entry: PageActionCacheEntry, versionId: string): void {
-    const key = entry.key;
-
-    if (!this.versions.has(key)) {
-      this.versions.set(key, []);
-    }
-
-    const versions = this.versions.get(key)!;
-    versions.push(versionId);
-
-    // 只保留最近的 N 个版本（默认 3 个）
-    if (versions.length > 3) {
-      versions.shift();
-    }
-  }
-
-  /**
-   * 获取版本列表
-   */
-  getVersions(key: string): string[] {
-    return this.versions.get(key) || [];
-  }
-
-  /**
-   * 生成版本标识
-   */
-  generateVersion(entry: PageActionCacheEntry): string {
-    const time = new Date(entry.createdAt).toISOString().slice(0, 10); // YYYY-MM-DD
-    const pageType = entry.pageType || "unknown";
-
-    return `${pageType}-${entry.scenario}-${time}`;
-  }
-
-  /**
-   * 清理旧版本
-   */
-  cleanupOldVersions(key: string, maxVersions: number = 3): void {
-    const versions = this.getVersions(key);
-
-    if (versions.length > maxVersions) {
-      const toKeep = versions.slice(-maxVersions);
-      this.versions.set(key, toKeep);
-    }
-  }
-}
-
-// ============================================================================
-// 单例
-// ============================================================================
-
-let cacheInvalidatorInstance: CacheInvalidator | null = null;
-
-export function getCacheInvalidator(): CacheInvalidator {
-  if (!cacheInvalidatorInstance) {
-    cacheInvalidatorInstance = new CacheInvalidator();
-  }
-  return cacheInvalidatorInstance;
-}

package/extensions/page-action-cache/src/cache-store.ts

@@ -1,457 +0,0 @@
-/**
- * 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;
-}