misoai-web 1.5.8 → 1.6.0

package/dist/lib/puppeteer-agent-launcher.js

@@ -1856,9 +1856,15 @@ var PageTaskExecutor = class {
   }
   async waitFor(assertion, opt) {
     const description = `waitFor: ${assertion}`;
-    const taskExecutor = new import_misoai_core.Executor(taskTitleStr("WaitFor", description), {
-      onTaskStart: this.onTaskStartCallback
-    });
+    const useMemory = true;
+    let taskExecutor;
+    if (useMemory) {
+      taskExecutor = this.getPersistentExecutor();
+    } else {
+      taskExecutor = new import_misoai_core.Executor(taskTitleStr("WaitFor", description), {
+        onTaskStart: this.onTaskStartCallback
+      });
+    }
     const { timeoutMs, checkIntervalMs } = opt;
     (0, import_utils6.assert)(assertion, "No assertion for waitFor");
     (0, import_utils6.assert)(timeoutMs, "No timeoutMs for waitFor");
@@ -1913,6 +1919,20 @@ var PageTaskExecutor = class {
       `waitFor timeout: ${errorThought}`
     );
   }
+  /**
+   * Hafızaya yeni bir öğe ekler
+   */
+  addToMemory(memoryItem) {
+    if (!this.persistentExecutor || this.persistentExecutor.status === "error") {
+      const previousMemory = this.workflowMemory.getWorkflowMemory(this.sessionContext.workflowId);
+      this.persistentExecutor = new import_misoai_core.Executor("Persistent Task Executor", {
+        onTaskStart: this.onTaskStartCallback,
+        initialMemory: previousMemory
+      });
+    }
+    this.persistentExecutor.memoryStore?.add(memoryItem);
+    this.persistentExecutor.memoryAnalytics?.recordMemoryOperation("add", memoryItem);
+  }
 };
 
 // src/common/plan-builder.ts
@@ -2007,7 +2027,7 @@ var import_js_yaml3 = __toESM(require("js-yaml"));
 var import_semver = __toESM(require("semver"));
 
 // package.json
-var version = "1.5.7";
+var version = "1.6.0";
 
 // src/common/task-cache.ts
 var debug3 = (0, import_logger3.getDebug)("cache");
@@ -2218,7 +2238,10 @@ var PageAgent = class {
     }
     this.taskExecutor = new PageTaskExecutor(this.page, this.insight, {
       taskCache: this.taskCache,
-      onTaskStart: this.callbackOnTaskStartTip.bind(this)
+      onTaskStart: this.callbackOnTaskStartTip.bind(this),
+      memoryConfig: opts?.memoryConfig,
+      sessionId: opts?.sessionId,
+      workflowId: opts?.workflowId
     });
     this.dump = this.resetDump();
     this.reportFileName = reportFileName(
@@ -2669,6 +2692,7 @@ ${reasonMsg}`);
   }
   async aiCaptcha(options) {
     const { deepThink = false, autoDetectComplexity = true } = options || {};
+    const memoryContext = this.getMemoryAsContext();
     let shouldUseDeepThink = deepThink;
     if (autoDetectComplexity && !deepThink) {
       const context = await this.getUIContext();
@@ -2749,6 +2773,26 @@ Return only "complex" or "simple" based on your analysis.
       }
     }
     await new Promise((resolve2) => setTimeout(resolve2, 3e3));
+    const captchaMemoryItem = {
+      id: `captcha_${Date.now()}`,
+      timestamp: Date.now(),
+      taskType: "Action",
+      summary: `Solved ${captchaResult.captchaType} CAPTCHA: ${captchaResult.thought}`,
+      context: {
+        url: await this.page.url?.() || "",
+        captchaType: captchaResult.captchaType,
+        actions: captchaResult.actions,
+        deepThink: actualDeepThink
+      },
+      metadata: {
+        executionTime: Date.now() - Date.now(),
+        // Will be updated
+        success: true,
+        confidence: 0.9
+      },
+      tags: ["captcha", "action", captchaResult.captchaType]
+    };
+    this.taskExecutor.addToMemory(captchaMemoryItem);
     const metadata = {
       status: "finished",
       usage,
@@ -2765,10 +2809,15 @@ Return only "complex" or "simple" based on your analysis.
   }
   async aiWaitFor(assertion, opt) {
     const startTime = Date.now();
-    const { executor } = await this.taskExecutor.waitFor(assertion, {
+    const memoryContext = this.getMemoryAsContext();
+    const assertionWithContext = memoryContext ? `${assertion}
+
+Previous workflow steps:
+${memoryContext}` : assertion;
+    const { executor } = await this.taskExecutor.waitFor(assertionWithContext, {
       timeoutMs: opt?.timeoutMs || 15 * 1e3,
       checkIntervalMs: opt?.checkIntervalMs || 3 * 1e3,
-      assertion
+      assertion: assertionWithContext
     });
     const metadata = {
       status: executor.isInErrorState() ? "failed" : "finished",
@@ -2924,6 +2973,109 @@ ${errors}`);
   clearMemory() {
     this.taskExecutor.clearMemory();
   }
+  /**
+   * Test sonunda kullanım için detaylı hafıza raporu döndürür (JSON formatında)
+   */
+  getMemoryReport() {
+    const memory = this.getMemory();
+    const stats = this.getMemoryStats();
+    return {
+      summary: {
+        totalItems: memory.length,
+        totalTasks: stats.analytics.totalTasks,
+        memoryHits: stats.analytics.memoryHits,
+        memoryMisses: stats.analytics.memoryMisses,
+        memoryEffectiveness: Math.round(stats.analytics.memoryEffectiveness * 100),
+        averageMemorySize: Math.round(stats.analytics.averageMemorySize * 100) / 100
+      },
+      config: stats.config,
+      items: memory.map((item) => ({
+        id: item.id,
+        timestamp: item.timestamp,
+        taskType: item.taskType,
+        summary: item.summary,
+        context: item.context,
+        metadata: item.metadata,
+        tags: item.tags,
+        relativeTime: this.formatRelativeTime(item.timestamp)
+      })),
+      analytics: {
+        taskTypeDistribution: this.getTaskTypeDistribution(memory),
+        successRate: this.calculateSuccessRate(memory),
+        averageExecutionTime: this.calculateAverageExecutionTime(memory),
+        dataExtractionCount: this.countDataExtractions(memory),
+        workflowSteps: this.extractWorkflowSteps(memory)
+      }
+    };
+  }
+  /**
+   * Test sonunda kullanım için basit hafıza özeti döndürür (JSON formatında)
+   */
+  getMemorySummary() {
+    const memory = this.getMemory();
+    const stats = this.getMemoryStats();
+    return {
+      totalItems: memory.length,
+      memoryEffectiveness: `${Math.round(stats.analytics.memoryEffectiveness * 100)}%`,
+      taskTypes: this.getTaskTypeDistribution(memory),
+      recentSteps: memory.slice(-5).map((item) => ({
+        step: item.summary,
+        type: item.taskType,
+        success: item.metadata?.success || false,
+        time: this.formatRelativeTime(item.timestamp)
+      })),
+      dataExtracted: this.getExtractedDataSummary(memory)
+    };
+  }
+  formatRelativeTime(timestamp) {
+    const now = Date.now();
+    const diff = now - timestamp;
+    const seconds = Math.floor(diff / 1e3);
+    const minutes = Math.floor(seconds / 60);
+    const hours = Math.floor(minutes / 60);
+    if (hours > 0)
+      return `${hours}h ${minutes % 60}m ago`;
+    if (minutes > 0)
+      return `${minutes}m ${seconds % 60}s ago`;
+    return `${seconds}s ago`;
+  }
+  getTaskTypeDistribution(memory) {
+    const distribution = {};
+    memory.forEach((item) => {
+      distribution[item.taskType] = (distribution[item.taskType] || 0) + 1;
+    });
+    return distribution;
+  }
+  calculateSuccessRate(memory) {
+    if (memory.length === 0)
+      return 0;
+    const successCount = memory.filter((item) => item.metadata?.success !== false).length;
+    return Math.round(successCount / memory.length * 100);
+  }
+  calculateAverageExecutionTime(memory) {
+    const executionTimes = memory.map((item) => item.metadata?.executionTime).filter((time) => typeof time === "number");
+    if (executionTimes.length === 0)
+      return 0;
+    const average = executionTimes.reduce((sum, time) => sum + time, 0) / executionTimes.length;
+    return Math.round(average);
+  }
+  countDataExtractions(memory) {
+    return memory.filter(
+      (item) => item.context?.dataExtracted || item.taskType === "Insight" && item.summary.includes("Extracted")
+    ).length;
+  }
+  extractWorkflowSteps(memory) {
+    return memory.map((item) => item.summary);
+  }
+  getExtractedDataSummary(memory) {
+    const extractedData = {};
+    memory.forEach((item, index) => {
+      if (item.context?.dataExtracted) {
+        extractedData[`step_${index + 1}`] = item.context.dataExtracted;
+      }
+    });
+    return extractedData;
+  }
 };
 
 // src/puppeteer/index.ts