@projectservan8n/cnapse 0.8.2 → 0.10.0

package/dist/chunk-WSBJFRQH.js

@@ -0,0 +1,366 @@
+import {
+  chat
+} from "./chunk-GP73OJCZ.js";
+import {
+  pressKey,
+  typeText
+} from "./chunk-TFHK5CYF.js";
+import {
+  describeScreen
+} from "./chunk-OIVTPXE4.js";
+
+// src/agents/learner.ts
+import { EventEmitter } from "events";
+import { homedir } from "os";
+import { join } from "path";
+import { readFile, writeFile, mkdir } from "fs/promises";
+import { existsSync } from "fs";
+var MEMORY_FILE = join(homedir(), ".cnapse", "agent-memory.json");
+var MAX_MEMORY_SIZE = 500;
+var AgentLearner = class extends EventEmitter {
+  memory;
+  loaded = false;
+  constructor() {
+    super();
+    this.memory = this.createEmptyMemory();
+  }
+  createEmptyMemory() {
+    return {
+      version: 1,
+      learned: [],
+      stats: {
+        totalAttempts: 0,
+        totalSuccesses: 0,
+        totalLearned: 0,
+        sourceCounts: {}
+      }
+    };
+  }
+  /**
+   * Load memory from disk
+   */
+  async load() {
+    if (this.loaded) return;
+    try {
+      const dir = join(homedir(), ".cnapse");
+      if (!existsSync(dir)) {
+        await mkdir(dir, { recursive: true });
+      }
+      if (existsSync(MEMORY_FILE)) {
+        const data = await readFile(MEMORY_FILE, "utf-8");
+        this.memory = JSON.parse(data);
+      }
+      this.loaded = true;
+      this.emit("loaded", this.memory.learned.length);
+    } catch (error) {
+      console.error("Failed to load agent memory:", error);
+      this.memory = this.createEmptyMemory();
+      this.loaded = true;
+    }
+  }
+  /**
+   * Save memory to disk
+   */
+  async save() {
+    try {
+      const dir = join(homedir(), ".cnapse");
+      if (!existsSync(dir)) {
+        await mkdir(dir, { recursive: true });
+      }
+      if (this.memory.learned.length > MAX_MEMORY_SIZE) {
+        this.memory.learned.sort((a, b) => {
+          const aScore = a.successCount - a.failCount;
+          const bScore = b.successCount - b.failCount;
+          return bScore - aScore;
+        });
+        this.memory.learned = this.memory.learned.slice(0, MAX_MEMORY_SIZE);
+      }
+      await writeFile(MEMORY_FILE, JSON.stringify(this.memory, null, 2));
+      this.emit("saved", this.memory.learned.length);
+    } catch (error) {
+      console.error("Failed to save agent memory:", error);
+    }
+  }
+  /**
+   * Check if we've solved something similar before
+   */
+  async recall(goal, currentScreen) {
+    await this.load();
+    const goalLower = goal.toLowerCase();
+    const screenLower = currentScreen.toLowerCase();
+    const candidates = this.memory.learned.filter((m) => {
+      const goalSimilarity = this.calculateSimilarity(goalLower, m.goal.toLowerCase());
+      const screenSimilarity = this.calculateSimilarity(screenLower, m.situation.toLowerCase());
+      return goalSimilarity > 0.5 && screenSimilarity > 0.3;
+    });
+    if (candidates.length === 0) return null;
+    candidates.sort((a, b) => {
+      const aScore = a.successCount - a.failCount + a.successCount * 0.1;
+      const bScore = b.successCount - b.failCount + b.successCount * 0.1;
+      return bScore - aScore;
+    });
+    const best = candidates[0];
+    if (best.successCount > best.failCount) {
+      this.emit("recalled", best);
+      return best;
+    }
+    return null;
+  }
+  /**
+   * Simple word-based similarity (Jaccard-like)
+   */
+  calculateSimilarity(a, b) {
+    const wordsA = new Set(a.split(/\s+/).filter((w) => w.length > 2));
+    const wordsB = new Set(b.split(/\s+/).filter((w) => w.length > 2));
+    if (wordsA.size === 0 || wordsB.size === 0) return 0;
+    let intersection = 0;
+    for (const word of wordsA) {
+      if (wordsB.has(word)) intersection++;
+    }
+    const union = wordsA.size + wordsB.size - intersection;
+    return intersection / union;
+  }
+  /**
+   * Learn from a successful action
+   */
+  async learn(situation, goal, actionType, actionValue, source) {
+    await this.load();
+    const id = `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const existing = this.memory.learned.find(
+      (m) => m.goal.toLowerCase() === goal.toLowerCase() && m.actionType === actionType && m.actionValue === actionValue
+    );
+    if (existing) {
+      existing.successCount++;
+      existing.lastUsed = now;
+      this.emit("reinforced", existing);
+    } else {
+      const learned = {
+        id,
+        situation: situation.slice(0, 500),
+        // Truncate long descriptions
+        goal,
+        solution: `${actionType}: ${actionValue}`,
+        actionType,
+        actionValue,
+        source,
+        successCount: 1,
+        failCount: 0,
+        lastUsed: now,
+        created: now
+      };
+      this.memory.learned.push(learned);
+      this.memory.stats.totalLearned++;
+      this.memory.stats.sourceCounts[source] = (this.memory.stats.sourceCounts[source] || 0) + 1;
+      this.emit("learned", learned);
+    }
+    await this.save();
+  }
+  /**
+   * Record a failed attempt
+   */
+  async recordFailure(goal, actionType, actionValue) {
+    await this.load();
+    const existing = this.memory.learned.find(
+      (m) => m.goal.toLowerCase() === goal.toLowerCase() && m.actionType === actionType && m.actionValue === actionValue
+    );
+    if (existing) {
+      existing.failCount++;
+      await this.save();
+    }
+  }
+  /**
+   * Get help from multiple AI sources when stuck
+   */
+  async getHelp(goal, currentScreen, triedActions) {
+    this.emit("seeking_help", { goal, triedActions: triedActions.length });
+    const query = this.buildHelpQuery(goal, currentScreen, triedActions);
+    const suggestions = [];
+    const sources = await Promise.allSettled([
+      this.askOwnAI(query),
+      this.askPerplexity(goal, currentScreen),
+      this.askWebSearch(goal)
+    ]);
+    for (const result of sources) {
+      if (result.status === "fulfilled" && result.value) {
+        suggestions.push(result.value);
+      }
+    }
+    suggestions.sort((a, b) => b.confidence - a.confidence);
+    this.emit("got_help", suggestions.length);
+    return suggestions;
+  }
+  buildHelpQuery(goal, screen, tried) {
+    return `I'm trying to: ${goal}
+
+Current screen shows: ${screen.slice(0, 500)}
+
+Actions I've already tried:
+${tried.length > 0 ? tried.slice(-5).join("\n") : "None yet"}
+
+What's the SINGLE next action I should take?
+Be very specific - tell me exactly what to click, what to type, or what key to press.
+
+Respond in this format:
+ACTION: <click|type|press|navigate|scroll|wait>
+VALUE: <what to click on / text to type / key to press / URL to navigate to>
+REASONING: <brief explanation>`;
+  }
+  /**
+   * Ask our configured AI provider for help
+   */
+  async askOwnAI(query) {
+    try {
+      const response = await chat([{ role: "user", content: query }]);
+      return this.parseSuggestion(response.content, "own_ai", 0.8);
+    } catch (error) {
+      return null;
+    }
+  }
+  /**
+   * Ask Perplexity by opening browser (uses existing browser.ts)
+   */
+  async askPerplexity(goal, screen) {
+    try {
+      const browser = await import("./browser-YLFWQXIY.js");
+      const question = `How do I ${goal}? I can see ${screen.slice(0, 200)}. Give me the exact next step.`;
+      const result = await browser.askAI("perplexity", question);
+      if (result.response) {
+        return {
+          action: "suggested",
+          value: result.response.slice(0, 500),
+          reasoning: "From Perplexity web search",
+          source: "perplexity",
+          confidence: 0.7
+        };
+      }
+    } catch (error) {
+    }
+    return null;
+  }
+  /**
+   * Search Google for help
+   */
+  async askWebSearch(goal) {
+    try {
+      const browser = await import("./browser-YLFWQXIY.js");
+      const searchQuery = `how to ${goal} step by step`;
+      const result = await browser.webSearch(searchQuery);
+      if (result.description) {
+        return {
+          action: "suggested",
+          value: result.description.slice(0, 500),
+          reasoning: "From web search results",
+          source: "google",
+          confidence: 0.5
+        };
+      }
+    } catch (error) {
+    }
+    return null;
+  }
+  /**
+   * Parse AI response into structured suggestion
+   */
+  parseSuggestion(content, source, baseConfidence) {
+    const actionMatch = content.match(/ACTION:\s*(\w+)/i);
+    const valueMatch = content.match(/VALUE:\s*(.+?)(?:\n|$)/i);
+    const reasoningMatch = content.match(/REASONING:\s*(.+?)(?:\n|$)/i);
+    if (!actionMatch) return null;
+    return {
+      action: actionMatch[1].toLowerCase(),
+      value: valueMatch?.[1]?.trim() || "",
+      reasoning: reasoningMatch?.[1]?.trim() || "No reasoning provided",
+      source,
+      confidence: baseConfidence
+    };
+  }
+  /**
+   * Ask Claude.ai via browser automation
+   */
+  async askClaude(query) {
+    try {
+      const browser = await import("./browser-YLFWQXIY.js");
+      await browser.openUrl("https://claude.ai");
+      await this.sleep(3e3);
+      await typeText(query);
+      await this.sleep(500);
+      await pressKey("Return");
+      await this.sleep(8e3);
+      const screen = await describeScreen();
+      return {
+        action: "suggested",
+        value: screen.description.slice(0, 500),
+        reasoning: "From Claude.ai",
+        source: "claude_web",
+        confidence: 0.75
+      };
+    } catch (error) {
+      return null;
+    }
+  }
+  /**
+   * Ask ChatGPT via browser automation
+   */
+  async askChatGPT(query) {
+    try {
+      const browser = await import("./browser-YLFWQXIY.js");
+      await browser.openUrl("https://chat.openai.com");
+      await this.sleep(3e3);
+      await typeText(query);
+      await this.sleep(500);
+      await pressKey("Return");
+      await this.sleep(8e3);
+      const screen = await describeScreen();
+      return {
+        action: "suggested",
+        value: screen.description.slice(0, 500),
+        reasoning: "From ChatGPT",
+        source: "chatgpt_web",
+        confidence: 0.75
+      };
+    } catch (error) {
+      return null;
+    }
+  }
+  sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+  /**
+   * Get memory stats
+   */
+  getStats() {
+    return {
+      ...this.memory.stats,
+      memorySize: this.memory.learned.length
+    };
+  }
+  /**
+   * Get all learned actions (for debugging/display)
+   */
+  getAllLearned() {
+    return [...this.memory.learned];
+  }
+  /**
+   * Clear all memory (for testing)
+   */
+  async clearMemory() {
+    this.memory = this.createEmptyMemory();
+    await this.save();
+    this.emit("cleared");
+  }
+};
+var learnerInstance = null;
+function getLearner() {
+  if (!learnerInstance) {
+    learnerInstance = new AgentLearner();
+  }
+  return learnerInstance;
+}
+var learner_default = AgentLearner;
+
+export {
+  AgentLearner,
+  getLearner,
+  learner_default
+};