@projectservan8n/cnapse 0.4.0 → 0.5.0

package/dist/index.js

@@ -11,8 +11,8 @@ import {
 import { render } from "ink";
 
 // src/components/App.tsx
-import { useState as useState2, useEffect, useRef } from "react";
-import { Box as Box6, Text as Text6, useApp, useInput as useInput2 } from "ink";
+import { useState as useState7, useCallback as useCallback5 } from "react";
+import { Box as Box7, Text as Text7, useApp, useInput as useInput3 } from "ink";
 
 // src/components/Header.tsx
 import { Box, Text } from "ink";
@@ -111,11 +111,12 @@ var MENU_ITEMS = [
   { command: "/screen", shortcut: "Ctrl+S", description: "Take screenshot and describe", category: "actions" },
   { command: "/task", description: "Run multi-step task", category: "actions" },
   { command: "/telegram", shortcut: "Ctrl+T", description: "Toggle Telegram bot", category: "actions" },
+  { command: "/memory", description: "View/clear learned task patterns", category: "actions" },
   // Settings
   { command: "/config", description: "Show/edit configuration", category: "settings" },
   { command: "/watch", shortcut: "Ctrl+W", description: "Toggle screen watching", category: "settings" },
   { command: "/model", description: "Change AI model", category: "settings" },
-  { command: "/provider", description: "Change AI provider", category: "settings" }
+  { command: "/provider", shortcut: "Ctrl+P", description: "Change AI provider", category: "settings" }
 ];
 function HelpMenu({ onClose, onSelect }) {
   const [selectedIndex, setSelectedIndex] = useState(0);
@@ -190,6 +191,143 @@ function HelpMenu({ onClose, onSelect }) {
   );
 }
 
+// src/components/ProviderSelector.tsx
+import { useState as useState2 } from "react";
+import { Box as Box6, Text as Text6, useInput as useInput2 } from "ink";
+import { jsx as jsx6, jsxs as jsxs5 } from "react/jsx-runtime";
+var PROVIDERS = [
+  {
+    id: "ollama",
+    name: "Ollama",
+    description: "Local AI - Free, private, no API key",
+    defaultModel: "qwen2.5:0.5b",
+    models: ["qwen2.5:0.5b", "qwen2.5:1.5b", "qwen2.5:7b", "llama3.2:1b", "llama3.2:3b", "mistral:7b", "codellama:7b", "llava:7b"]
+  },
+  {
+    id: "openrouter",
+    name: "OpenRouter",
+    description: "Many models, pay-per-use",
+    defaultModel: "qwen/qwen-2.5-coder-32b-instruct",
+    models: [
+      "qwen/qwen-2.5-coder-32b-instruct",
+      "anthropic/claude-3.5-sonnet",
+      "openai/gpt-4o",
+      "openai/gpt-4o-mini",
+      "google/gemini-pro-1.5",
+      "meta-llama/llama-3.1-70b-instruct"
+    ]
+  },
+  {
+    id: "anthropic",
+    name: "Anthropic",
+    description: "Claude models - Best for coding",
+    defaultModel: "claude-3-5-sonnet-20241022",
+    models: ["claude-3-5-sonnet-20241022", "claude-3-opus-20240229", "claude-3-haiku-20240307"]
+  },
+  {
+    id: "openai",
+    name: "OpenAI",
+    description: "GPT models",
+    defaultModel: "gpt-4o",
+    models: ["gpt-4o", "gpt-4o-mini", "gpt-4-turbo", "gpt-3.5-turbo"]
+  }
+];
+function ProviderSelector({ onClose, onSelect }) {
+  const config = getConfig();
+  const [mode, setMode] = useState2("provider");
+  const [providerIndex, setProviderIndex] = useState2(() => {
+    const idx = PROVIDERS.findIndex((p) => p.id === config.provider);
+    return idx >= 0 ? idx : 0;
+  });
+  const [modelIndex, setModelIndex] = useState2(0);
+  const [selectedProvider, setSelectedProvider] = useState2(null);
+  useInput2((input, key) => {
+    if (key.escape) {
+      onClose();
+      return;
+    }
+    if (mode === "provider") {
+      if (key.upArrow) {
+        setProviderIndex((prev) => prev > 0 ? prev - 1 : PROVIDERS.length - 1);
+      } else if (key.downArrow) {
+        setProviderIndex((prev) => prev < PROVIDERS.length - 1 ? prev + 1 : 0);
+      } else if (key.return) {
+        const provider = PROVIDERS[providerIndex];
+        setSelectedProvider(provider);
+        const currentModelIdx = provider.models.findIndex((m) => m === config.model);
+        setModelIndex(currentModelIdx >= 0 ? currentModelIdx : 0);
+        setMode("model");
+      }
+    } else if (mode === "model" && selectedProvider) {
+      if (key.upArrow) {
+        setModelIndex((prev) => prev > 0 ? prev - 1 : selectedProvider.models.length - 1);
+      } else if (key.downArrow) {
+        setModelIndex((prev) => prev < selectedProvider.models.length - 1 ? prev + 1 : 0);
+      } else if (key.return) {
+        const model = selectedProvider.models[modelIndex];
+        setProvider(selectedProvider.id);
+        setModel(model);
+        onSelect(selectedProvider.id, model);
+        onClose();
+      } else if (key.leftArrow || input === "b") {
+        setMode("provider");
+      }
+    }
+  });
+  if (mode === "provider") {
+    return /* @__PURE__ */ jsxs5(Box6, { flexDirection: "column", borderStyle: "round", borderColor: "cyan", padding: 1, children: [
+      /* @__PURE__ */ jsx6(Box6, { marginBottom: 1, children: /* @__PURE__ */ jsx6(Text6, { bold: true, color: "cyan", children: "Select Provider" }) }),
+      /* @__PURE__ */ jsx6(Box6, { marginBottom: 1, children: /* @__PURE__ */ jsx6(Text6, { color: "gray", children: "Use arrows to navigate, Enter to select, Esc to cancel" }) }),
+      PROVIDERS.map((provider, index) => {
+        const isSelected = index === providerIndex;
+        const isCurrent = provider.id === config.provider;
+        return /* @__PURE__ */ jsxs5(Box6, { marginY: 0, children: [
+          /* @__PURE__ */ jsxs5(Text6, { color: isSelected ? "cyan" : "white", children: [
+            isSelected ? "\u276F " : "  ",
+            provider.name,
+            isCurrent && /* @__PURE__ */ jsx6(Text6, { color: "green", children: " (current)" })
+          ] }),
+          isSelected && /* @__PURE__ */ jsxs5(Text6, { color: "gray", children: [
+            " - ",
+            provider.description
+          ] })
+        ] }, provider.id);
+      }),
+      /* @__PURE__ */ jsx6(Box6, { marginTop: 1, borderStyle: "single", borderColor: "gray", paddingX: 1, children: /* @__PURE__ */ jsxs5(Text6, { color: "gray", children: [
+        "Current: ",
+        config.provider,
+        " / ",
+        config.model
+      ] }) })
+    ] });
+  }
+  return /* @__PURE__ */ jsxs5(Box6, { flexDirection: "column", borderStyle: "round", borderColor: "cyan", padding: 1, children: [
+    /* @__PURE__ */ jsx6(Box6, { marginBottom: 1, children: /* @__PURE__ */ jsxs5(Text6, { bold: true, color: "cyan", children: [
+      "Select Model for ",
+      selectedProvider?.name
+    ] }) }),
+    /* @__PURE__ */ jsx6(Box6, { marginBottom: 1, children: /* @__PURE__ */ jsx6(Text6, { color: "gray", children: "Arrows to navigate, Enter to select, B/Left to go back" }) }),
+    selectedProvider?.models.map((model, index) => {
+      const isSelected = index === modelIndex;
+      const isCurrent = model === config.model && selectedProvider.id === config.provider;
+      const isDefault = model === selectedProvider.defaultModel;
+      return /* @__PURE__ */ jsx6(Box6, { marginY: 0, children: /* @__PURE__ */ jsxs5(Text6, { color: isSelected ? "cyan" : "white", children: [
+        isSelected ? "\u276F " : "  ",
+        model,
+        isCurrent && /* @__PURE__ */ jsx6(Text6, { color: "green", children: " (current)" }),
+        isDefault && !isCurrent && /* @__PURE__ */ jsx6(Text6, { color: "yellow", children: " (default)" })
+      ] }) }, model);
+    }),
+    /* @__PURE__ */ jsx6(Box6, { marginTop: 1, borderStyle: "single", borderColor: "gray", paddingX: 1, children: /* @__PURE__ */ jsxs5(Text6, { color: "gray", children: [
+      "Provider: ",
+      selectedProvider?.name
+    ] }) })
+  ] });
+}
+
+// src/hooks/useChat.ts
+import { useState as useState3, useCallback, useRef, useEffect } from "react";
+
 // src/lib/api.ts
 var SYSTEM_PROMPT = `You are C-napse, a helpful AI assistant for PC automation running on the user's desktop.
 You can help with coding, file management, shell commands, and more. Be concise and helpful.
@@ -347,6 +485,107 @@ async function getScreenDescription() {
   }
 }
 
+// src/hooks/useChat.ts
+var WELCOME_MESSAGE = {
+  id: "0",
+  role: "system",
+  content: "Welcome to C-napse! Type your message and press Enter.\n\nShortcuts: Ctrl+H for help, Ctrl+P for provider",
+  timestamp: /* @__PURE__ */ new Date()
+};
+function useChat(screenWatch = false) {
+  const [messages, setMessages] = useState3([WELCOME_MESSAGE]);
+  const [isProcessing, setIsProcessing] = useState3(false);
+  const [error, setError] = useState3(null);
+  const screenContextRef = useRef(null);
+  useEffect(() => {
+    if (!screenWatch) {
+      screenContextRef.current = null;
+      return;
+    }
+    const checkScreen = async () => {
+      const desc = await getScreenDescription();
+      if (desc) {
+        screenContextRef.current = desc;
+      }
+    };
+    checkScreen();
+    const interval = setInterval(checkScreen, 5e3);
+    return () => clearInterval(interval);
+  }, [screenWatch]);
+  const addSystemMessage = useCallback((content) => {
+    setMessages((prev) => [
+      ...prev,
+      {
+        id: Date.now().toString(),
+        role: "system",
+        content,
+        timestamp: /* @__PURE__ */ new Date()
+      }
+    ]);
+  }, []);
+  const sendMessage = useCallback(async (content) => {
+    if (!content.trim() || isProcessing) return;
+    setError(null);
+    const userMsg = {
+      id: Date.now().toString(),
+      role: "user",
+      content,
+      timestamp: /* @__PURE__ */ new Date()
+    };
+    const assistantId = (Date.now() + 1).toString();
+    const assistantMsg = {
+      id: assistantId,
+      role: "assistant",
+      content: "",
+      timestamp: /* @__PURE__ */ new Date(),
+      isStreaming: true
+    };
+    setMessages((prev) => [...prev, userMsg, assistantMsg]);
+    setIsProcessing(true);
+    try {
+      const apiMessages = messages.filter((m) => m.role === "user" || m.role === "assistant").slice(-10).map((m) => ({ role: m.role, content: m.content }));
+      let finalContent = content;
+      if (screenWatch && screenContextRef.current) {
+        finalContent = `[Screen context: ${screenContextRef.current}]
+
+${content}`;
+      }
+      apiMessages.push({ role: "user", content: finalContent });
+      const response = await chat(apiMessages);
+      setMessages(
+        (prev) => prev.map(
+          (m) => m.id === assistantId ? { ...m, content: response.content || "(no response)", isStreaming: false } : m
+        )
+      );
+    } catch (err2) {
+      const errorMsg = err2 instanceof Error ? err2.message : "Unknown error";
+      setError(errorMsg);
+      setMessages(
+        (prev) => prev.map(
+          (m) => m.id === assistantId ? { ...m, content: `Error: ${errorMsg}`, isStreaming: false } : m
+        )
+      );
+    } finally {
+      setIsProcessing(false);
+    }
+  }, [messages, isProcessing, screenWatch]);
+  const clearMessages = useCallback(() => {
+    setMessages([WELCOME_MESSAGE]);
+    setError(null);
+  }, []);
+  return {
+    messages,
+    isProcessing,
+    error,
+    sendMessage,
+    addSystemMessage,
+    clearMessages
+  };
+}
+
+// src/hooks/useVision.ts
+import { useState as useState4, useCallback as useCallback2 } from "react";
+
 // src/lib/vision.ts
 async function describeScreen() {
   const screenshot = await captureScreenshot();
@@ -370,10 +609,10 @@ async function captureScreenFallback() {
   const { exec: exec5 } = await import("child_process");
   const { promisify: promisify5 } = await import("util");
   const { tmpdir } = await import("os");
-  const { join } = await import("path");
+  const { join: join2 } = await import("path");
   const { readFile, unlink } = await import("fs/promises");
   const execAsync5 = promisify5(exec5);
-  const tempFile = join(tmpdir(), `cnapse-screen-${Date.now()}.png`);
+  const tempFile = join2(tmpdir(), `cnapse-screen-${Date.now()}.png`);
   try {
     const platform = process.platform;
     if (platform === "win32") {
@@ -551,6 +790,40 @@ async function analyzeWithOpenAI(base64Image, prompt) {
   return data.choices?.[0]?.message?.content || "Unable to analyze image";
 }
 
+// src/hooks/useVision.ts
+function useVision() {
+  const [isAnalyzing, setIsAnalyzing] = useState4(false);
+  const [lastDescription, setLastDescription] = useState4(null);
+  const [lastScreenshot, setLastScreenshot] = useState4(null);
+  const [error, setError] = useState4(null);
+  const analyze = useCallback2(async () => {
+    setIsAnalyzing(true);
+    setError(null);
+    try {
+      const result = await describeScreen();
+      setLastDescription(result.description);
+      setLastScreenshot(result.screenshot);
+      return result.description;
+    } catch (err2) {
+      const errorMsg = err2 instanceof Error ? err2.message : "Vision analysis failed";
+      setError(errorMsg);
+      throw err2;
+    } finally {
+      setIsAnalyzing(false);
+    }
+  }, []);
+  return {
+    isAnalyzing,
+    lastDescription,
+    lastScreenshot,
+    error,
+    analyze
+  };
+}
+
+// src/hooks/useTelegram.ts
+import { useState as useState5, useCallback as useCallback3, useEffect as useEffect2, useRef as useRef2 } from "react";
+
 // src/services/telegram.ts
 import { EventEmitter } from "events";
 
@@ -991,48 +1264,231 @@ function getTelegramBot() {
   return instance;
 }
 
+// src/hooks/useTelegram.ts
+function useTelegram(onMessage) {
+  const [isEnabled, setIsEnabled] = useState5(false);
+  const [isStarting, setIsStarting] = useState5(false);
+  const [error, setError] = useState5(null);
+  const [lastMessage, setLastMessage] = useState5(null);
+  const onMessageRef = useRef2(onMessage);
+  useEffect2(() => {
+    onMessageRef.current = onMessage;
+  }, [onMessage]);
+  const start = useCallback3(async () => {
+    if (isEnabled) return;
+    setIsStarting(true);
+    setError(null);
+    try {
+      const bot = getTelegramBot();
+      bot.on("message", (msg) => {
+        setLastMessage(msg);
+        onMessageRef.current?.(msg);
+      });
+      bot.on("error", (err2) => {
+        setError(err2.message);
+      });
+      await bot.start();
+      setIsEnabled(true);
+    } catch (err2) {
+      const errorMsg = err2 instanceof Error ? err2.message : "Failed to start Telegram bot";
+      setError(errorMsg);
+      throw err2;
+    } finally {
+      setIsStarting(false);
+    }
+  }, [isEnabled]);
+  const stop = useCallback3(async () => {
+    if (!isEnabled) return;
+    try {
+      const bot = getTelegramBot();
+      await bot.stop();
+      setIsEnabled(false);
+    } catch (err2) {
+      const errorMsg = err2 instanceof Error ? err2.message : "Failed to stop Telegram bot";
+      setError(errorMsg);
+      throw err2;
+    }
+  }, [isEnabled]);
+  const toggle = useCallback3(async () => {
+    if (isEnabled) {
+      await stop();
+    } else {
+      await start();
+    }
+  }, [isEnabled, start, stop]);
+  return {
+    isEnabled,
+    isStarting,
+    error,
+    lastMessage,
+    toggle,
+    start,
+    stop
+  };
+}
+
+// src/hooks/useTasks.ts
+import { useState as useState6, useCallback as useCallback4 } from "react";
+
 // src/lib/tasks.ts
-async function parseTask(input) {
-  const systemPrompt = `You are a task parser for PC automation. Convert user requests into specific, executable steps.
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+var TASK_MEMORY_FILE = path.join(os.homedir(), ".cnapse", "task-memory.json");
+function loadTaskMemory() {
+  try {
+    if (fs.existsSync(TASK_MEMORY_FILE)) {
+      const data = fs.readFileSync(TASK_MEMORY_FILE, "utf-8");
+      return JSON.parse(data);
+    }
+  } catch {
+  }
+  return { patterns: [], version: 1 };
+}
+function saveTaskPattern(input, steps) {
+  try {
+    const memory = loadTaskMemory();
+    const normalized = normalizeInput(input);
+    const existing = memory.patterns.find((p) => p.normalizedInput === normalized);
+    if (existing) {
+      existing.steps = steps;
+      existing.successCount++;
+      existing.lastUsed = (/* @__PURE__ */ new Date()).toISOString();
+    } else {
+      memory.patterns.push({
+        input,
+        normalizedInput: normalized,
+        steps,
+        successCount: 1,
+        lastUsed: (/* @__PURE__ */ new Date()).toISOString()
+      });
+    }
+    memory.patterns = memory.patterns.sort((a, b) => b.successCount - a.successCount).slice(0, 100);
+    const dir = path.dirname(TASK_MEMORY_FILE);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+    fs.writeFileSync(TASK_MEMORY_FILE, JSON.stringify(memory, null, 2));
+  } catch {
+  }
+}
+function normalizeInput(input) {
+  return input.toLowerCase().replace(/[^\w\s]/g, " ").replace(/\s+/g, " ").trim();
+}
+function findSimilarPatterns(input) {
+  const memory = loadTaskMemory();
+  const normalized = normalizeInput(input);
+  const words = normalized.split(" ").filter((w) => w.length > 2);
+  return memory.patterns.filter((pattern) => {
+    const patternWords = pattern.normalizedInput.split(" ");
+    const matches = words.filter((w) => patternWords.includes(w));
+    return matches.length >= Math.min(2, words.length * 0.5);
+  }).sort((a, b) => b.successCount - a.successCount).slice(0, 3);
+}
+function buildChainOfThoughtPrompt(input) {
+  const similarPatterns = findSimilarPatterns(input);
+  let learnedExamples = "";
+  if (similarPatterns.length > 0) {
+    learnedExamples = `
+## LEARNED PATTERNS (from successful past tasks)
+These patterns worked before - use them as reference:
+
+${similarPatterns.map((p, i) => `
+Pattern ${i + 1} (used ${p.successCount} times):
+Input: "${p.input}"
+Steps: ${JSON.stringify(p.steps, null, 2)}
+`).join("\n")}
+`;
+  }
+  return `You are a task parser for Windows PC automation. Your job is to convert natural language into precise, executable steps.
+
+## THINKING PROCESS
+Before outputting steps, THINK through these questions:
+
+1. **WHAT** is the main goal?
+   - What application needs to open?
+   - What action needs to happen inside it?
+   - What is the expected end result?
+
+2. **HOW** to achieve it on Windows?
+   - Use Win+R (meta+r) to open Run dialog for apps
+   - Wait 1-3 seconds after opening apps for them to load
+   - Use keyboard shortcuts when possible (faster, more reliable)
+   - Common shortcuts: Ctrl+S (save), Ctrl+O (open), Ctrl+N (new), Alt+F4 (close)
+
+3. **SEQUENCE** - what order makes sense?
+   - Open app FIRST
+   - WAIT for it to load
+   - THEN interact with it
+   - Add waits between actions that need time
 
-Available actions:
-- open_app: Open an application (e.g., "open_app:notepad", "open_app:vscode")
-- type_text: Type text (e.g., "type_text:Hello World")
-- press_key: Press a key (e.g., "press_key:enter", "press_key:escape")
-- key_combo: Key combination (e.g., "key_combo:control+s", "key_combo:alt+f4")
-- click: Click mouse (e.g., "click:left", "click:right")
-- wait: Wait seconds (e.g., "wait:2")
-- focus_window: Focus window by title (e.g., "focus_window:Notepad")
-- screenshot: Take screenshot and describe
+4. **EDGE CASES** - what could go wrong?
+   - App might already be open -> focus_window first
+   - Dialogs might appear -> handle or dismiss them
+   - Typing too fast -> add small waits
 
-Respond ONLY with a JSON array of steps, no other text:
+## AVAILABLE ACTIONS
+- open_app: Open app via Run dialog (e.g., "open_app:notepad", "open_app:code", "open_app:chrome")
+- type_text: Type text string (e.g., "type_text:Hello World")
+- press_key: Single key (e.g., "press_key:enter", "press_key:escape", "press_key:tab")
+- key_combo: Key combination (e.g., "key_combo:control+s", "key_combo:alt+f4", "key_combo:meta+r")
+- click: Mouse click (e.g., "click:left", "click:right")
+- wait: Wait N seconds (e.g., "wait:2" - use 1-3s for app loads)
+- focus_window: Focus by title (e.g., "focus_window:Notepad")
+- screenshot: Capture and describe screen
+${learnedExamples}
+## EXAMPLES WITH REASONING
+
+### Example 1: "open notepad and type hello"
+Thinking:
+- Goal: Open Notepad, then type text into it
+- How: Win+R -> notepad -> Enter to open, then type
+- Sequence: Open -> Wait for load -> Type
+- Edge case: Need wait time for Notepad window to be ready
+
+Output:
 [
-  { "description": "Human readable step", "action": "action_type:params" },
-  ...
+  { "description": "Open Notepad via Run dialog", "action": "open_app:notepad" },
+  { "description": "Wait for Notepad to fully load", "action": "wait:2" },
+  { "description": "Type the greeting text", "action": "type_text:hello" }
+]
+
+### Example 2: "save the current document"
+Thinking:
+- Goal: Save whatever is in the current app
+- How: Ctrl+S is universal save shortcut
+- Sequence: Just the key combo, maybe wait for save
+- Edge case: If file is new, Save As dialog might appear
+
+Output:
+[
+  { "description": "Press Ctrl+S to save", "action": "key_combo:control+s" },
+  { "description": "Wait for save to complete", "action": "wait:1" }
 ]
 
-Example input: "open notepad and type hello world"
-Example output:
+### Example 3: "close this window"
+Thinking:
+- Goal: Close the current active window
+- How: Alt+F4 closes active window on Windows
+- Sequence: Single action
+- Edge case: Might prompt to save - user handles that
+
+Output:
 [
-  { "description": "Open Notepad", "action": "open_app:notepad" },
-  { "description": "Wait for Notepad to open", "action": "wait:2" },
-  { "description": "Type hello world", "action": "type_text:Hello World" }
+  { "description": "Close active window with Alt+F4", "action": "key_combo:alt+f4" }
 ]
 
-Example input: "open vscode, go to folder E:\\Projects, then open terminal"
-Example output:
+## YOUR TASK
+Now parse this request: "${input}"
+
+First, briefly think through the 4 questions above, then output ONLY a JSON array:
 [
-  { "description": "Open VS Code", "action": "open_app:code" },
-  { "description": "Wait for VS Code to load", "action": "wait:3" },
-  { "description": "Open folder with Ctrl+K Ctrl+O", "action": "key_combo:control+k" },
-  { "description": "Wait for dialog", "action": "wait:1" },
-  { "description": "Continue folder open", "action": "key_combo:control+o" },
-  { "description": "Wait for folder dialog", "action": "wait:1" },
-  { "description": "Type folder path", "action": "type_text:E:\\\\Projects" },
-  { "description": "Press Enter to open folder", "action": "press_key:enter" },
-  { "description": "Wait for folder to load", "action": "wait:2" },
-  { "description": "Open terminal with Ctrl+\`", "action": "key_combo:control+\`" }
+  { "description": "Human readable step", "action": "action_type:params" },
+  ...
 ]`;
+}
+async function parseTask(input) {
+  const systemPrompt = buildChainOfThoughtPrompt(input);
   const messages = [
     { role: "user", content: input }
   ];
@@ -1143,6 +1599,11 @@ async function executeTask(task, onProgress) {
   }
   if (task.status !== "failed") {
     task.status = "completed";
+    const steps = task.steps.map((s) => ({
+      description: s.description,
+      action: s.action
+    }));
+    saveTaskPattern(task.description, steps);
   }
   task.completedAt = /* @__PURE__ */ new Date();
   return task;
@@ -1150,6 +1611,24 @@ async function executeTask(task, onProgress) {
 function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
+function getTaskMemoryStats() {
+  const memory = loadTaskMemory();
+  const totalUses = memory.patterns.reduce((sum, p) => sum + p.successCount, 0);
+  const topPatterns = memory.patterns.sort((a, b) => b.successCount - a.successCount).slice(0, 5).map((p) => `"${p.input}" (${p.successCount}x)`);
+  return {
+    patternCount: memory.patterns.length,
+    totalUses,
+    topPatterns
+  };
+}
+function clearTaskMemory() {
+  try {
+    if (fs.existsSync(TASK_MEMORY_FILE)) {
+      fs.unlinkSync(TASK_MEMORY_FILE);
+    }
+  } catch {
+  }
+}
 function formatTask(task) {
   const statusEmoji = {
     pending: "\u23F3",
@@ -1180,293 +1659,251 @@ function formatTask(task) {
   return output;
 }
 
+// src/hooks/useTasks.ts
+function useTasks(onProgress) {
+  const [isRunning, setIsRunning] = useState6(false);
+  const [currentTask, setCurrentTask] = useState6(null);
+  const [currentStep, setCurrentStep] = useState6(null);
+  const [error, setError] = useState6(null);
+  const run = useCallback4(async (description) => {
+    setIsRunning(true);
+    setError(null);
+    try {
+      const task = await parseTask(description);
+      setCurrentTask(task);
+      const result = await executeTask(task, (updatedTask, step) => {
+        setCurrentTask({ ...updatedTask });
+        setCurrentStep(step);
+        onProgress?.(updatedTask, step);
+      });
+      setCurrentTask(result);
+      return result;
+    } catch (err2) {
+      const errorMsg = err2 instanceof Error ? err2.message : "Task failed";
+      setError(errorMsg);
+      throw err2;
+    } finally {
+      setIsRunning(false);
+      setCurrentStep(null);
+    }
+  }, [onProgress]);
+  return {
+    isRunning,
+    currentTask,
+    currentStep,
+    error,
+    run,
+    format: formatTask,
+    getMemoryStats: getTaskMemoryStats,
+    clearMemory: clearTaskMemory
+  };
+}
+
 // src/components/App.tsx
-import { jsx as jsx6, jsxs as jsxs5 } from "react/jsx-runtime";
+import { jsx as jsx7, jsxs as jsxs6 } from "react/jsx-runtime";
 function App() {
   const { exit } = useApp();
-  const [messages, setMessages] = useState2([
-    {
-      id: "0",
-      role: "system",
-      content: "Welcome to C-napse! Type your message and press Enter.\n\nShortcuts:\n  Ctrl+C - Exit\n  Ctrl+W - Toggle screen watch\n  /clear - Clear chat\n  /help  - Show help",
-      timestamp: /* @__PURE__ */ new Date()
-    }
-  ]);
-  const [input, setInput] = useState2("");
-  const [isProcessing, setIsProcessing] = useState2(false);
-  const [status, setStatus] = useState2("Ready");
-  const [error, setError] = useState2(null);
-  const [screenWatch, setScreenWatch] = useState2(false);
-  const [showHelpMenu, setShowHelpMenu] = useState2(false);
-  const [telegramEnabled, setTelegramEnabled] = useState2(false);
-  const screenContextRef = useRef(null);
-  useEffect(() => {
-    if (!screenWatch) {
-      screenContextRef.current = null;
-      return;
-    }
-    const checkScreen = async () => {
-      const desc = await getScreenDescription();
-      if (desc) {
-        screenContextRef.current = desc;
-      }
-    };
-    checkScreen();
-    const interval = setInterval(checkScreen, 5e3);
-    return () => clearInterval(interval);
-  }, [screenWatch]);
-  useInput2((inputChar, key) => {
-    if (showHelpMenu) {
-      return;
-    }
-    if (key.ctrl && inputChar === "c") {
-      exit();
-    }
-    if (key.ctrl && inputChar === "l") {
-      setMessages([messages[0]]);
-      setError(null);
+  const [overlay, setOverlay] = useState7("none");
+  const [screenWatch, setScreenWatch] = useState7(false);
+  const [status, setStatus] = useState7("Ready");
+  const chat2 = useChat(screenWatch);
+  const vision = useVision();
+  const telegram = useTelegram((msg) => {
+    chat2.addSystemMessage(`\u{1F4F1} Telegram [${msg.from}]: ${msg.text}`);
+  });
+  const tasks = useTasks((task, step) => {
+    if (step.status === "running") {
+      setStatus(`Running: ${step.description}`);
     }
+  });
+  useInput3((inputChar, key) => {
+    if (overlay !== "none") return;
+    if (key.ctrl && inputChar === "c") exit();
+    if (key.ctrl && inputChar === "l") chat2.clearMessages();
+    if (key.ctrl && inputChar === "h") setOverlay("help");
+    if (key.ctrl && inputChar === "p") setOverlay("provider");
     if (key.ctrl && inputChar === "w") {
       setScreenWatch((prev) => {
         const newState = !prev;
-        addSystemMessage(
-          newState ? "\u{1F5A5}\uFE0F Screen watching enabled. AI will have context of your screen." : "\u{1F5A5}\uFE0F Screen watching disabled."
+        chat2.addSystemMessage(
+          newState ? "\u{1F5A5}\uFE0F Screen watching enabled." : "\u{1F5A5}\uFE0F Screen watching disabled."
         );
         return newState;
       });
     }
-    if (key.ctrl && inputChar === "h") {
-      setShowHelpMenu(true);
-    }
     if (key.ctrl && inputChar === "t") {
-      setTelegramEnabled((prev) => {
-        const newState = !prev;
-        addSystemMessage(
-          newState ? "\u{1F4F1} Telegram bot enabled." : "\u{1F4F1} Telegram bot disabled."
-        );
-        return newState;
-      });
+      handleTelegramToggle();
     }
   });
-  const handleSubmit = async (value) => {
-    if (!value.trim() || isProcessing) return;
-    const userInput = value.trim();
-    setInput("");
-    setError(null);
-    if (userInput.startsWith("/")) {
-      handleCommand(userInput);
-      return;
-    }
-    const userMsg = {
-      id: Date.now().toString(),
-      role: "user",
-      content: userInput,
-      timestamp: /* @__PURE__ */ new Date()
-    };
-    setMessages((prev) => [...prev, userMsg]);
-    const assistantId = (Date.now() + 1).toString();
-    setMessages((prev) => [
-      ...prev,
-      {
-        id: assistantId,
-        role: "assistant",
-        content: "",
-        timestamp: /* @__PURE__ */ new Date(),
-        isStreaming: true
-      }
-    ]);
-    setIsProcessing(true);
-    setStatus("Thinking...");
-    try {
-      const apiMessages = messages.filter((m) => m.role === "user" || m.role === "assistant").slice(-10).map((m) => ({ role: m.role, content: m.content }));
-      let finalInput = userInput;
-      if (screenWatch && screenContextRef.current) {
-        finalInput = `[Screen context: ${screenContextRef.current}]
-
-${userInput}`;
-      }
-      apiMessages.push({ role: "user", content: finalInput });
-      const response = await chat(apiMessages);
-      setMessages(
-        (prev) => prev.map(
-          (m) => m.id === assistantId ? { ...m, content: response.content || "(no response)", isStreaming: false } : m
-        )
-      );
-    } catch (err2) {
-      const errorMsg = err2 instanceof Error ? err2.message : "Unknown error";
-      setError(errorMsg);
-      setMessages(
-        (prev) => prev.map(
-          (m) => m.id === assistantId ? { ...m, content: `Error: ${errorMsg}`, isStreaming: false } : m
-        )
-      );
-    } finally {
-      setIsProcessing(false);
-      setStatus("Ready");
-    }
-  };
-  const handleCommand = (cmd) => {
+  const handleCommand = useCallback5(async (cmd) => {
     const parts = cmd.slice(1).split(" ");
     const command = parts[0];
     const args2 = parts.slice(1).join(" ");
     switch (command) {
       case "clear":
-        setMessages([messages[0]]);
-        addSystemMessage("Chat cleared.");
+        chat2.clearMessages();
+        chat2.addSystemMessage("Chat cleared.");
         break;
       case "help":
-        setShowHelpMenu(true);
+        setOverlay("help");
+        break;
+      case "provider":
+      case "model":
+        setOverlay("provider");
+        break;
+      case "config": {
+        const config = getConfig();
+        chat2.addSystemMessage(
+          `\u2699\uFE0F Configuration:
+  Provider: ${config.provider}
+  Model: ${config.model}
+  Ollama: ${config.ollamaHost}
+
+Use /provider to change`
+        );
+        break;
+      }
+      case "screen":
+        await handleScreenCommand();
         break;
       case "watch":
         setScreenWatch((prev) => {
           const newState = !prev;
-          addSystemMessage(
+          chat2.addSystemMessage(
             newState ? "\u{1F5A5}\uFE0F Screen watching enabled." : "\u{1F5A5}\uFE0F Screen watching disabled."
           );
           return newState;
         });
         break;
       case "telegram":
-        handleTelegramToggle();
-        break;
-      case "screen":
-        handleScreenCommand();
+        await handleTelegramToggle();
         break;
       case "task":
         if (args2) {
-          handleTaskCommand(args2);
+          await handleTaskCommand(args2);
         } else {
-          addSystemMessage("Usage: /task <description>\nExample: /task open notepad and type hello");
+          chat2.addSystemMessage("Usage: /task <description>\nExample: /task open notepad and type hello");
         }
         break;
-      case "config":
-        addSystemMessage("\u2699\uFE0F Configuration:\n  Provider: Use cnapse config\n  Model: Use cnapse config set model <name>");
-        break;
-      case "model":
-        addSystemMessage("\u{1F916} Model selection coming soon.\nUse: cnapse config set model <name>");
-        break;
-      case "provider":
-        addSystemMessage("\u{1F50C} Provider selection coming soon.\nUse: cnapse config set provider <name>");
+      case "memory":
+        if (args2 === "clear") {
+          tasks.clearMemory();
+          chat2.addSystemMessage("\u{1F9E0} Task memory cleared.");
+        } else {
+          const stats = tasks.getMemoryStats();
+          chat2.addSystemMessage(
+            `\u{1F9E0} Task Memory:
+
+  Learned patterns: ${stats.patternCount}
+  Total successful uses: ${stats.totalUses}
+
+` + (stats.topPatterns.length > 0 ? `  Top patterns:
+${stats.topPatterns.map((p) => `    \u2022 ${p}`).join("\n")}
+
+` : "  No patterns learned yet.\n\n") + `The more you use /task, the smarter it gets!
+Use /memory clear to reset.`
+          );
+        }
         break;
       case "quit":
       case "exit":
         exit();
         break;
       default:
-        addSystemMessage(`Unknown command: ${command}
-Type /help to see available commands.`);
+        chat2.addSystemMessage(`Unknown command: ${command}
+Type /help for commands`);
     }
-  };
-  const handleHelpMenuSelect = (command) => {
-    handleCommand(command);
-  };
-  const handleScreenCommand = async () => {
-    addSystemMessage("\u{1F4F8} Taking screenshot and analyzing...");
-    setStatus("Analyzing screen...");
-    setIsProcessing(true);
+  }, [chat2, exit]);
+  const handleScreenCommand = useCallback5(async () => {
+    chat2.addSystemMessage("\u{1F4F8} Analyzing screen...");
+    setStatus("Analyzing...");
     try {
-      const result = await describeScreen();
-      addSystemMessage(`\u{1F5A5}\uFE0F Screen Analysis:
+      const description = await vision.analyze();
+      chat2.addSystemMessage(`\u{1F5A5}\uFE0F Screen:
 
-${result.description}`);
+${description}`);
     } catch (err2) {
-      const errorMsg = err2 instanceof Error ? err2.message : "Vision analysis failed";
-      addSystemMessage(`\u274C Screen capture failed: ${errorMsg}`);
+      chat2.addSystemMessage(`\u274C ${vision.error || "Vision failed"}`);
     } finally {
-      setIsProcessing(false);
       setStatus("Ready");
     }
-  };
-  const handleTaskCommand = async (taskDescription) => {
-    addSystemMessage(`\u{1F4CB} Parsing task: ${taskDescription}`);
-    setStatus("Parsing task...");
-    setIsProcessing(true);
-    try {
-      const task = await parseTask(taskDescription);
-      addSystemMessage(`\u{1F4CB} Task planned (${task.steps.length} steps):
-${formatTask(task)}`);
-      addSystemMessage("\u{1F680} Executing task...");
-      setStatus("Executing task...");
-      await executeTask(task, (updatedTask, currentStep) => {
-        if (currentStep.status === "running") {
-          setStatus(`Running: ${currentStep.description}`);
-        }
-      });
-      addSystemMessage(`
-${formatTask(task)}`);
-      if (task.status === "completed") {
-        addSystemMessage("\u2705 Task completed successfully!");
-      } else {
-        addSystemMessage("\u274C Task failed. Check the steps above for errors.");
-      }
-    } catch (err2) {
-      const errorMsg = err2 instanceof Error ? err2.message : "Task failed";
-      addSystemMessage(`\u274C Task error: ${errorMsg}`);
-    } finally {
-      setIsProcessing(false);
-      setStatus("Ready");
-    }
-  };
-  const handleTelegramToggle = async () => {
-    const bot = getTelegramBot();
-    if (telegramEnabled) {
-      try {
-        await bot.stop();
-        setTelegramEnabled(false);
-        addSystemMessage("\u{1F4F1} Telegram bot stopped.");
-      } catch (err2) {
-        const errorMsg = err2 instanceof Error ? err2.message : "Failed to stop bot";
-        addSystemMessage(`\u274C Error stopping bot: ${errorMsg}`);
-      }
+  }, [chat2, vision]);
+  const handleTelegramToggle = useCallback5(async () => {
+    if (telegram.isEnabled) {
+      await telegram.stop();
+      chat2.addSystemMessage("\u{1F4F1} Telegram stopped.");
     } else {
-      addSystemMessage("\u{1F4F1} Starting Telegram bot...");
+      chat2.addSystemMessage("\u{1F4F1} Starting Telegram...");
       setStatus("Starting Telegram...");
       try {
-        bot.on("message", (msg) => {
-          addSystemMessage(`\u{1F4F1} Telegram [${msg.from}]: ${msg.text}`);
-        });
-        bot.on("error", (error2) => {
-          addSystemMessage(`\u{1F4F1} Telegram error: ${error2.message}`);
-        });
-        await bot.start();
-        setTelegramEnabled(true);
-        addSystemMessage(
-          "\u{1F4F1} Telegram bot started!\n\nOpen Telegram and send /start to your bot to connect.\nCommands: /screen, /describe, /run <cmd>, /status"
+        await telegram.start();
+        chat2.addSystemMessage(
+          "\u{1F4F1} Telegram started!\nSend /start to your bot to connect.\nCommands: /screen, /describe, /run, /status"
         );
-      } catch (err2) {
-        const errorMsg = err2 instanceof Error ? err2.message : "Failed to start bot";
-        addSystemMessage(`\u274C Telegram error: ${errorMsg}`);
+      } catch {
+        chat2.addSystemMessage(`\u274C ${telegram.error || "Telegram failed"}`);
       } finally {
         setStatus("Ready");
       }
     }
-  };
-  const addSystemMessage = (content) => {
-    setMessages((prev) => [
-      ...prev,
+  }, [chat2, telegram]);
+  const handleTaskCommand = useCallback5(async (description) => {
+    chat2.addSystemMessage(`\u{1F4CB} Parsing: ${description}`);
+    setStatus("Parsing task...");
+    try {
+      const task = await tasks.run(description);
+      chat2.addSystemMessage(`
+${tasks.format(task)}`);
+      chat2.addSystemMessage(
+        task.status === "completed" ? "\u2705 Task completed!" : "\u274C Task failed."
+      );
+    } catch {
+      chat2.addSystemMessage(`\u274C ${tasks.error || "Task failed"}`);
+    } finally {
+      setStatus("Ready");
+    }
+  }, [chat2, tasks]);
+  const handleSubmit = useCallback5(async (value) => {
+    if (!value.trim()) return;
+    if (value.startsWith("/")) {
+      await handleCommand(value);
+    } else {
+      setStatus("Thinking...");
+      await chat2.sendMessage(value);
+      setStatus("Ready");
+    }
+  }, [chat2, handleCommand]);
+  const handleProviderSelect = useCallback5((provider, model) => {
+    chat2.addSystemMessage(`\u2705 Updated: ${provider} / ${model}`);
+  }, [chat2]);
+  if (overlay === "help") {
+    return /* @__PURE__ */ jsx7(Box7, { flexDirection: "column", height: "100%", alignItems: "center", justifyContent: "center", children: /* @__PURE__ */ jsx7(
+      HelpMenu,
       {
-        id: Date.now().toString(),
-        role: "system",
-        content,
-        timestamp: /* @__PURE__ */ new Date()
+        onClose: () => setOverlay("none"),
+        onSelect: (cmd) => {
+          setOverlay("none");
+          handleCommand(cmd);
+        }
       }
-    ]);
-  };
-  const visibleMessages = messages.slice(-20);
-  if (showHelpMenu) {
-    return /* @__PURE__ */ jsx6(Box6, { flexDirection: "column", height: "100%", alignItems: "center", justifyContent: "center", children: /* @__PURE__ */ jsx6(
-      HelpMenu,
+    ) });
+  }
+  if (overlay === "provider") {
+    return /* @__PURE__ */ jsx7(Box7, { flexDirection: "column", height: "100%", alignItems: "center", justifyContent: "center", children: /* @__PURE__ */ jsx7(
+      ProviderSelector,
       {
-        onClose: () => setShowHelpMenu(false),
-        onSelect: handleHelpMenuSelect
+        onClose: () => setOverlay("none"),
+        onSelect: handleProviderSelect
       }
     ) });
   }
-  return /* @__PURE__ */ jsxs5(Box6, { flexDirection: "column", height: "100%", children: [
-    /* @__PURE__ */ jsx6(Header, { screenWatch, telegramEnabled }),
-    /* @__PURE__ */ jsxs5(Box6, { flexDirection: "column", flexGrow: 1, borderStyle: "round", borderColor: "gray", padding: 1, children: [
-      /* @__PURE__ */ jsx6(Text6, { bold: true, color: "gray", children: " Chat " }),
-      visibleMessages.map((msg) => /* @__PURE__ */ jsx6(
+  const visibleMessages = chat2.messages.slice(-20);
+  const isProcessing = chat2.isProcessing || vision.isAnalyzing || tasks.isRunning || telegram.isStarting;
+  return /* @__PURE__ */ jsxs6(Box7, { flexDirection: "column", height: "100%", children: [
+    /* @__PURE__ */ jsx7(Header, { screenWatch, telegramEnabled: telegram.isEnabled }),
+    /* @__PURE__ */ jsxs6(Box7, { flexDirection: "column", flexGrow: 1, borderStyle: "round", borderColor: "gray", padding: 1, children: [
+      /* @__PURE__ */ jsx7(Text7, { bold: true, color: "gray", children: " Chat " }),
+      visibleMessages.map((msg) => /* @__PURE__ */ jsx7(
         ChatMessage,
         {
           role: msg.role,
@@ -1477,25 +1914,26 @@ ${formatTask(task)}`);
         msg.id
       ))
     ] }),
-    error && /* @__PURE__ */ jsx6(Box6, { marginY: 1, children: /* @__PURE__ */ jsxs5(Text6, { color: "red", children: [
+    chat2.error && /* @__PURE__ */ jsx7(Box7, { marginY: 1, children: /* @__PURE__ */ jsxs6(Text7, { color: "red", children: [
       "Error: ",
-      error
+      chat2.error
     ] }) }),
-    /* @__PURE__ */ jsx6(
+    /* @__PURE__ */ jsx7(
       ChatInput,
       {
-        value: input,
-        onChange: setInput,
+        value: "",
+        onChange: () => {
+        },
         onSubmit: handleSubmit,
         isProcessing
       }
     ),
-    /* @__PURE__ */ jsx6(StatusBar, { status })
+    /* @__PURE__ */ jsx7(StatusBar, { status })
   ] });
 }
 
 // src/index.tsx
-import { jsx as jsx7 } from "react/jsx-runtime";
+import { jsx as jsx8 } from "react/jsx-runtime";
 var args = process.argv.slice(2);
 if (args.length > 0) {
   const command = args[0];
@@ -1591,7 +2029,7 @@ Manual Setup:
     }
     case "init": {
       const { Setup } = await import("./Setup-Q32JPHGP.js");
-      render(/* @__PURE__ */ jsx7(Setup, {}));
+      render(/* @__PURE__ */ jsx8(Setup, {}));
       process.exit(0);
     }
     default: {
@@ -1599,4 +2037,4 @@ Manual Setup:
     }
   }
 }
-render(/* @__PURE__ */ jsx7(App, {}));
+render(/* @__PURE__ */ jsx8(App, {}));