@projectservan8n/cnapse 0.8.2 → 0.10.0

package/dist/ProviderSelector-GZYF26LL.js

@@ -0,0 +1,7 @@
+import {
+  ProviderSelector
+} from "./chunk-7SDY7OPA.js";
+import "./chunk-COKO6V5J.js";
+export {
+  ProviderSelector
+};

package/dist/autonomous-VGEVIXXQ.js

@@ -0,0 +1,419 @@
+import {
+  getLearner
+} from "./chunk-WSBJFRQH.js";
+import {
+  chat
+} from "./chunk-GP73OJCZ.js";
+import {
+  clickMouse,
+  getMousePosition,
+  keyCombo,
+  moveMouse,
+  pressKey,
+  scrollMouse,
+  typeText
+} from "./chunk-TFHK5CYF.js";
+import {
+  captureScreenshot,
+  describeScreen
+} from "./chunk-OIVTPXE4.js";
+import "./chunk-COKO6V5J.js";
+
+// src/agents/autonomous.ts
+import { EventEmitter } from "events";
+var DEFAULT_CONFIG = {
+  maxAttempts: 25,
+  actionDelayMs: 1500,
+  stuckThreshold: 3,
+  verifyActions: true,
+  humanLikeTiming: true,
+  learnFromSuccess: true,
+  askForHelpWhenStuck: true
+};
+var AutonomousAgent = class extends EventEmitter {
+  state;
+  config;
+  learner;
+  abortController = null;
+  constructor(config = {}) {
+    super();
+    this.config = { ...DEFAULT_CONFIG, ...config };
+    this.learner = getLearner();
+    this.state = this.createInitialState("");
+  }
+  createInitialState(goal) {
+    return {
+      goal,
+      isActive: false,
+      isPaused: false,
+      currentAction: null,
+      actionHistory: [],
+      stuckCount: 0,
+      attemptCount: 0,
+      lastScreenHash: "",
+      startTime: Date.now(),
+      confidence: 100
+    };
+  }
+  /**
+   * Start pursuing a goal autonomously
+   */
+  async start(goal) {
+    if (this.state.isActive) {
+      return { success: false, message: "Agent is already running" };
+    }
+    this.state = this.createInitialState(goal);
+    this.state.isActive = true;
+    this.abortController = new AbortController();
+    this.emit("started", { goal });
+    try {
+      await this.learner.load();
+      while (this.state.isActive && this.state.attemptCount < this.config.maxAttempts) {
+        if (this.state.isPaused) {
+          await this.sleep(500);
+          continue;
+        }
+        this.state.attemptCount++;
+        this.emit("attempt", { count: this.state.attemptCount, max: this.config.maxAttempts });
+        const observation = await this.observe();
+        if (!observation) continue;
+        const remembered = await this.learner.recall(goal, observation.description);
+        if (remembered) {
+          this.emit("recalled", remembered);
+          const result2 = await this.executeAction(remembered.actionType, remembered.actionValue);
+          if (result2.success) {
+            await this.learner.learn(
+              observation.description,
+              goal,
+              remembered.actionType,
+              remembered.actionValue,
+              "memory"
+            );
+          }
+          continue;
+        }
+        const decision = await this.think(observation.description);
+        if (decision.action === "done") {
+          this.state.isActive = false;
+          this.emit("completed", { success: true, attempts: this.state.attemptCount });
+          return { success: true, message: "Goal accomplished!" };
+        }
+        if (decision.action === "stuck") {
+          this.state.stuckCount++;
+          if (this.state.stuckCount >= this.config.stuckThreshold && this.config.askForHelpWhenStuck) {
+            this.emit("asking_help", { stuckCount: this.state.stuckCount });
+            const suggestions = await this.learner.getHelp(
+              goal,
+              observation.description,
+              this.state.actionHistory.slice(-5).map((a) => `${a.action}: ${a.value}`)
+            );
+            if (suggestions.length > 0) {
+              const suggestion = suggestions[0];
+              this.emit("trying_suggestion", suggestion);
+              const result2 = await this.executeAction(suggestion.action, suggestion.value);
+              if (result2.success && this.config.learnFromSuccess) {
+                await this.learner.learn(
+                  observation.description,
+                  goal,
+                  suggestion.action,
+                  suggestion.value,
+                  suggestion.source
+                );
+                this.state.stuckCount = 0;
+              }
+            }
+          }
+          continue;
+        }
+        const result = await this.executeAction(decision.action, decision.value);
+        if (this.config.verifyActions) {
+          const afterScreen = await captureScreenshot();
+          const screenChanged = afterScreen !== observation.screenshot;
+          if (screenChanged) {
+            this.state.stuckCount = 0;
+            this.state.confidence = Math.min(100, this.state.confidence + 5);
+            if (result.success && this.config.learnFromSuccess) {
+              await this.learner.learn(
+                observation.description,
+                goal,
+                decision.action,
+                decision.value,
+                "self"
+              );
+            }
+          } else {
+            this.state.stuckCount++;
+            this.state.confidence = Math.max(0, this.state.confidence - 10);
+          }
+        }
+        if (this.config.humanLikeTiming) {
+          const delay = this.config.actionDelayMs + Math.random() * 500;
+          await this.sleep(delay);
+        } else {
+          await this.sleep(this.config.actionDelayMs);
+        }
+      }
+      this.state.isActive = false;
+      this.emit("completed", { success: false, attempts: this.state.attemptCount });
+      return {
+        success: false,
+        message: `Reached max attempts (${this.config.maxAttempts}). Goal may be partially complete.`
+      };
+    } catch (error) {
+      this.state.isActive = false;
+      const message = error instanceof Error ? error.message : "Unknown error";
+      this.emit("error", { error: message });
+      return { success: false, message };
+    }
+  }
+  /**
+   * Stop the agent
+   */
+  stop() {
+    this.state.isActive = false;
+    this.abortController?.abort();
+    this.emit("stopped", { attempts: this.state.attemptCount });
+  }
+  /**
+   * Pause the agent
+   */
+  pause() {
+    this.state.isPaused = true;
+    this.emit("paused");
+  }
+  /**
+   * Resume the agent
+   */
+  resume() {
+    this.state.isPaused = false;
+    this.emit("resumed");
+  }
+  /**
+   * Observe current screen state
+   */
+  async observe() {
+    try {
+      this.emit("observing");
+      const result = await describeScreen();
+      this.emit("observed", { description: result.description.slice(0, 200) });
+      return result;
+    } catch (error) {
+      this.emit("observe_error", { error });
+      return null;
+    }
+  }
+  /**
+   * Think about what action to take next
+   */
+  async think(screenDescription) {
+    this.emit("thinking");
+    const prompt = this.buildThinkingPrompt(screenDescription);
+    try {
+      const response = await chat([{ role: "user", content: prompt }]);
+      const decision = this.parseDecision(response.content);
+      this.emit("decided", decision);
+      return decision;
+    } catch (error) {
+      return { action: "stuck", value: "", reasoning: "Failed to get AI decision" };
+    }
+  }
+  buildThinkingPrompt(screenDescription) {
+    const recentActions = this.state.actionHistory.slice(-5).map((a) => `- ${a.action}: ${a.value} (${a.result})`).join("\n");
+    return `GOAL: ${this.state.goal}
+
+CURRENT SCREEN: ${screenDescription}
+
+PREVIOUS ACTIONS:
+${recentActions || "None yet"}
+
+ATTEMPT: ${this.state.attemptCount}/${this.config.maxAttempts}
+STUCK COUNT: ${this.state.stuckCount}
+
+Based on what you see, what's the SINGLE next action to take?
+
+Available actions:
+- click: Click at current mouse position
+- clickAt: Click at specific coordinates (VALUE: x,y)
+- type: Type text (VALUE: text to type)
+- press: Press a key (VALUE: Enter, Tab, Escape, etc.)
+- keyCombo: Press key combination (VALUE: command+s, control+c, etc.)
+- scroll: Scroll (VALUE: up or down)
+- navigate: Open URL (VALUE: full URL)
+- moveTo: Move mouse (VALUE: x,y coordinates)
+- wait: Wait for something (VALUE: seconds)
+- done: Goal is accomplished
+- stuck: Can't figure out what to do
+
+Respond EXACTLY in this format:
+ACTION: <action_type>
+VALUE: <parameter>
+REASONING: <brief why>`;
+  }
+  parseDecision(content) {
+    const actionMatch = content.match(/ACTION:\s*(\w+)/i);
+    const valueMatch = content.match(/VALUE:\s*(.+?)(?:\n|$)/i);
+    const reasoningMatch = content.match(/REASONING:\s*(.+?)(?:\n|$)/i);
+    return {
+      action: actionMatch?.[1]?.toLowerCase() || "stuck",
+      value: valueMatch?.[1]?.trim() || "",
+      reasoning: reasoningMatch?.[1]?.trim() || "No reasoning provided"
+    };
+  }
+  /**
+   * Execute an action
+   */
+  async executeAction(action, value) {
+    const record = {
+      timestamp: Date.now(),
+      action,
+      value,
+      result: "pending",
+      screenBefore: this.state.lastScreenHash,
+      reasoning: ""
+    };
+    this.state.currentAction = `${action}: ${value}`;
+    this.emit("executing", { action, value });
+    try {
+      switch (action) {
+        case "click":
+          await clickMouse("left");
+          break;
+        case "clickat":
+        case "clickAt": {
+          const [x, y] = value.split(",").map((n) => parseInt(n.trim()));
+          if (!isNaN(x) && !isNaN(y)) {
+            await moveMouse(x, y);
+            await this.sleep(100);
+            await clickMouse("left");
+          }
+          break;
+        }
+        case "type":
+          if (this.config.humanLikeTiming) {
+            await this.typeHumanLike(value);
+          } else {
+            await typeText(value);
+          }
+          break;
+        case "press":
+          await pressKey(value || "Return");
+          break;
+        case "keycombo":
+        case "keyCombo": {
+          const keys = value.split("+").map((k) => k.trim().toLowerCase());
+          await keyCombo(keys);
+          break;
+        }
+        case "scroll":
+          const amount = value.toLowerCase().includes("up") ? 3 : -3;
+          await scrollMouse(amount);
+          break;
+        case "navigate": {
+          const browser = await import("./browser-YLFWQXIY.js");
+          const url = value.startsWith("http") ? value : `https://${value}`;
+          await browser.openUrl(url);
+          break;
+        }
+        case "moveto":
+        case "moveTo": {
+          const [mx, my] = value.split(",").map((n) => parseInt(n.trim()));
+          if (!isNaN(mx) && !isNaN(my)) {
+            if (this.config.humanLikeTiming) {
+              await this.moveMouseSmooth(mx, my);
+            } else {
+              await moveMouse(mx, my);
+            }
+          }
+          break;
+        }
+        case "wait": {
+          const seconds = parseFloat(value) || 2;
+          await this.sleep(seconds * 1e3);
+          break;
+        }
+        case "done":
+        case "stuck":
+          break;
+        default:
+          record.result = "failure";
+          this.state.actionHistory.push(record);
+          return { success: false, error: `Unknown action: ${action}` };
+      }
+      record.result = "success";
+      this.state.actionHistory.push(record);
+      this.emit("executed", { action, value, success: true });
+      return { success: true };
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : "Unknown error";
+      record.result = "failure";
+      this.state.actionHistory.push(record);
+      this.emit("executed", { action, value, success: false, error: errorMsg });
+      return { success: false, error: errorMsg };
+    } finally {
+      this.state.currentAction = null;
+    }
+  }
+  /**
+   * Type text with human-like timing
+   */
+  async typeHumanLike(text) {
+    const baseDelay = 50;
+    for (const char of text) {
+      await typeText(char);
+      const delay = baseDelay + Math.random() * 30;
+      await this.sleep(delay);
+      if (Math.random() < 0.05) {
+        await this.sleep(200 + Math.random() * 300);
+      }
+    }
+  }
+  /**
+   * Move mouse smoothly (basic linear interpolation)
+   */
+  async moveMouseSmooth(targetX, targetY) {
+    const currentPos = await getMousePosition();
+    const match = currentPos.output.match(/(\d+),\s*(\d+)/);
+    if (!match) {
+      await moveMouse(targetX, targetY);
+      return;
+    }
+    const startX = parseInt(match[1]);
+    const startY = parseInt(match[2]);
+    const steps = 10;
+    for (let i = 1; i <= steps; i++) {
+      const t = i / steps;
+      const x = Math.round(startX + (targetX - startX) * t);
+      const y = Math.round(startY + (targetY - startY) * t);
+      await moveMouse(x, y);
+      await this.sleep(20);
+    }
+  }
+  sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+  /**
+   * Get current state
+   */
+  getState() {
+    return { ...this.state };
+  }
+  /**
+   * Get action history
+   */
+  getHistory() {
+    return [...this.state.actionHistory];
+  }
+};
+var agentInstance = null;
+function getAutonomousAgent(config) {
+  if (!agentInstance) {
+    agentInstance = new AutonomousAgent(config);
+  }
+  return agentInstance;
+}
+var autonomous_default = AutonomousAgent;
+export {
+  AutonomousAgent,
+  autonomous_default as default,
+  getAutonomousAgent
+};

package/dist/browser-YLFWQXIY.js

@@ -0,0 +1,87 @@
+import {
+  askAI,
+  browser_default,
+  click,
+  clickElement,
+  closeBrowser,
+  closeTab,
+  elementExists,
+  focusAddressBar,
+  getFullAIResponse,
+  getPage,
+  getPageText,
+  getTextContent,
+  goBack,
+  goForward,
+  googleDocsType,
+  googleSheetsType,
+  initBrowser,
+  navigateTo,
+  newTab,
+  nextTab,
+  openGmailCompose,
+  openGoogleDoc,
+  openGoogleSheet,
+  openOutlookCompose,
+  openUrl,
+  pressKey,
+  refresh,
+  research,
+  scroll,
+  searchGoogle,
+  sendGmail,
+  sendOutlook,
+  takeScreenshot,
+  typeInBrowser,
+  typeInElement,
+  typeSlowly,
+  typeUrl,
+  waitForNavigation,
+  waitForText,
+  webSearch
+} from "./chunk-MOKGR7WE.js";
+import "./chunk-TFHK5CYF.js";
+import "./chunk-OIVTPXE4.js";
+import "./chunk-COKO6V5J.js";
+export {
+  askAI,
+  click,
+  clickElement,
+  closeBrowser,
+  closeTab,
+  browser_default as default,
+  elementExists,
+  focusAddressBar,
+  getFullAIResponse,
+  getPage,
+  getPageText,
+  getTextContent,
+  goBack,
+  goForward,
+  googleDocsType,
+  googleSheetsType,
+  initBrowser,
+  navigateTo,
+  newTab,
+  nextTab,
+  openGmailCompose,
+  openGoogleDoc,
+  openGoogleSheet,
+  openOutlookCompose,
+  openUrl,
+  pressKey,
+  refresh,
+  research,
+  scroll,
+  searchGoogle,
+  sendGmail,
+  sendOutlook,
+  takeScreenshot,
+  typeInBrowser,
+  typeInElement,
+  typeSlowly,
+  typeUrl,
+  waitForNavigation,
+  waitForText,
+  webSearch
+};

package/dist/{chunk-OPX7FFL6.js → chunk-7SDY7OPA.js}

@@ -1,52 +1,16 @@
+import {
+  getConfig,
+  setApiKey,
+  setModel,
+  setProvider
+} from "./chunk-COKO6V5J.js";
+
 // src/components/ProviderSelector.tsx
 import { useState, useEffect } from "react";
 import { Box, Text, useInput } from "ink";
 import TextInput from "ink-text-input";
 import Spinner from "ink-spinner";
 
-// src/lib/config.ts
-import Conf from "conf";
-var config = new Conf({
-  projectName: "cnapse",
-  defaults: {
-    provider: "ollama",
-    model: "qwen2.5:0.5b",
-    apiKeys: {},
-    ollamaHost: "http://localhost:11434",
-    openrouter: {
-      siteUrl: "https://github.com/projectservan8n/C-napse",
-      appName: "C-napse"
-    },
-    telegram: {
-      enabled: false
-    }
-  }
-});
-function getConfig() {
-  return {
-    provider: config.get("provider"),
-    model: config.get("model"),
-    apiKeys: config.get("apiKeys"),
-    ollamaHost: config.get("ollamaHost"),
-    openrouter: config.get("openrouter"),
-    telegram: config.get("telegram")
-  };
-}
-function setProvider(provider) {
-  config.set("provider", provider);
-}
-function setModel(model) {
-  config.set("model", model);
-}
-function setApiKey(provider, key) {
-  const keys = config.get("apiKeys");
-  keys[provider] = key;
-  config.set("apiKeys", keys);
-}
-function getApiKey(provider) {
-  return config.get("apiKeys")[provider];
-}
-
 // src/lib/ollama.ts
 import { exec } from "child_process";
 import { promisify } from "util";
@@ -159,10 +123,10 @@ var PROVIDERS = [
   }
 ];
 function ProviderSelector({ onClose, onSelect }) {
-  const config2 = getConfig();
+  const config = getConfig();
   const [step, setStep] = useState("provider");
   const [providerIndex, setProviderIndex] = useState(() => {
-    const idx = PROVIDERS.findIndex((p) => p.id === config2.provider);
+    const idx = PROVIDERS.findIndex((p) => p.id === config.provider);
     return idx >= 0 ? idx : 0;
   });
   const [modelIndex, setModelIndex] = useState(0);
@@ -195,12 +159,12 @@ function ProviderSelector({ onClose, onSelect }) {
       } else if (key.return) {
         const provider = PROVIDERS[providerIndex];
         setSelectedProvider(provider);
-        const currentIdx = provider.models.findIndex((m) => m.id === config2.model);
+        const currentIdx = provider.models.findIndex((m) => m.id === config.model);
         const recommendedIdx = provider.models.findIndex((m) => m.recommended);
         setModelIndex(currentIdx >= 0 ? currentIdx : recommendedIdx >= 0 ? recommendedIdx : 0);
         if (provider.needsApiKey) {
           const apiKeyProvider = provider.id;
-          if (!config2.apiKeys[apiKeyProvider]) {
+          if (!config.apiKeys[apiKeyProvider]) {
             setStep("apiKey");
           } else {
             setStep("model");
@@ -246,8 +210,8 @@ function ProviderSelector({ onClose, onSelect }) {
       /* @__PURE__ */ jsx(Box, { marginBottom: 1, children: /* @__PURE__ */ jsx(Text, { color: "gray", dimColor: true, children: "Arrows to navigate, Enter to select" }) }),
       PROVIDERS.map((provider, index) => {
         const isSelected = index === providerIndex;
-        const isCurrent = provider.id === config2.provider;
-        const hasKey = provider.needsApiKey && provider.id !== "ollama" ? !!config2.apiKeys[provider.id] : true;
+        const isCurrent = provider.id === config.provider;
+        const hasKey = provider.needsApiKey && provider.id !== "ollama" ? !!config.apiKeys[provider.id] : true;
         return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
           /* @__PURE__ */ jsxs(Text, { color: isSelected ? "cyan" : "white", children: [
             isSelected ? "\u276F " : "  ",
@@ -335,7 +299,7 @@ function ProviderSelector({ onClose, onSelect }) {
       /* @__PURE__ */ jsx(Box, { marginTop: 1, marginBottom: 1, children: /* @__PURE__ */ jsx(Text, { color: "gray", dimColor: true, children: "Arrows to navigate, Enter to select, B to go back" }) }),
       selectedProvider.models.map((model, index) => {
         const isSelected = index === modelIndex;
-        const isCurrent = model.id === config2.model && selectedProvider.id === config2.provider;
+        const isCurrent = model.id === config.model && selectedProvider.id === config.provider;
         let modelStatus = "";
         if (isOllama && ollamaStatus) {
           const available = hasModel(ollamaStatus, model.id);
@@ -382,10 +346,5 @@ function ProviderSelector({ onClose, onSelect }) {
 }
 
 export {
-  getConfig,
-  setProvider,
-  setModel,
-  setApiKey,
-  getApiKey,
   ProviderSelector
 };

package/dist/chunk-COKO6V5J.js

@@ -0,0 +1,50 @@
+// src/lib/config.ts
+import Conf from "conf";
+var config = new Conf({
+  projectName: "cnapse",
+  defaults: {
+    provider: "ollama",
+    model: "qwen2.5:0.5b",
+    apiKeys: {},
+    ollamaHost: "http://localhost:11434",
+    openrouter: {
+      siteUrl: "https://github.com/projectservan8n/C-napse",
+      appName: "C-napse"
+    },
+    telegram: {
+      enabled: false
+    }
+  }
+});
+function getConfig() {
+  return {
+    provider: config.get("provider"),
+    model: config.get("model"),
+    apiKeys: config.get("apiKeys"),
+    ollamaHost: config.get("ollamaHost"),
+    openrouter: config.get("openrouter"),
+    telegram: config.get("telegram")
+  };
+}
+function setProvider(provider) {
+  config.set("provider", provider);
+}
+function setModel(model) {
+  config.set("model", model);
+}
+function setApiKey(provider, key) {
+  const keys = config.get("apiKeys");
+  keys[provider] = key;
+  config.set("apiKeys", keys);
+}
+function getApiKey(provider) {
+  return config.get("apiKeys")[provider];
+}
+
+export {
+  getConfig,
+  setProvider,
+  setModel,
+  setApiKey,
+  getApiKey
+};