@projectservan8n/cnapse 0.4.0 → 0.5.1

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,349 @@ function HelpMenu({ onClose, onSelect }) {
   );
 }
 
+// src/components/ProviderSelector.tsx
+import { useState as useState2, useEffect } from "react";
+import { Box as Box6, Text as Text6, useInput as useInput2 } from "ink";
+import TextInput2 from "ink-text-input";
+import Spinner from "ink-spinner";
+
+// src/lib/ollama.ts
+import { exec } from "child_process";
+import { promisify } from "util";
+var execAsync = promisify(exec);
+async function checkOllamaStatus() {
+  try {
+    const { stdout } = await execAsync("ollama list", { timeout: 1e4 });
+    const lines = stdout.trim().split("\n");
+    const models = [];
+    for (let i = 1; i < lines.length; i++) {
+      const line = lines[i];
+      if (!line?.trim()) continue;
+      const parts = line.split(/\s{2,}/);
+      if (parts.length >= 3) {
+        models.push({
+          name: parts[0]?.trim() || "",
+          size: parts[2]?.trim() || "",
+          modified: parts[3]?.trim() || ""
+        });
+      }
+    }
+    return {
+      installed: true,
+      running: true,
+      models
+    };
+  } catch (err2) {
+    const errorMsg = err2 instanceof Error ? err2.message : "Unknown error";
+    if (errorMsg.includes("connect") || errorMsg.includes("refused")) {
+      return {
+        installed: true,
+        running: false,
+        models: [],
+        error: "Ollama is not running. Start it with: ollama serve"
+      };
+    }
+    if (errorMsg.includes("not found") || errorMsg.includes("not recognized")) {
+      return {
+        installed: false,
+        running: false,
+        models: [],
+        error: "Ollama not installed. Get it at: https://ollama.ai"
+      };
+    }
+    return {
+      installed: false,
+      running: false,
+      models: [],
+      error: errorMsg
+    };
+  }
+}
+function hasModel(status, modelId) {
+  const modelName = modelId.split(":")[0]?.toLowerCase() || "";
+  return status.models.some((m) => m.name.toLowerCase().startsWith(modelName));
+}
+
+// src/components/ProviderSelector.tsx
+import { Fragment, jsx as jsx6, jsxs as jsxs5 } from "react/jsx-runtime";
+var PROVIDERS = [
+  {
+    id: "ollama",
+    name: "Ollama",
+    description: "Local AI - Free, private",
+    needsApiKey: false,
+    models: [
+      { id: "qwen2.5:0.5b", name: "Qwen 2.5 0.5B (fast)", recommended: true },
+      { id: "qwen2.5:1.5b", name: "Qwen 2.5 1.5B" },
+      { id: "qwen2.5:7b", name: "Qwen 2.5 7B (quality)" },
+      { id: "llama3.2:1b", name: "Llama 3.2 1B" },
+      { id: "llama3.2:3b", name: "Llama 3.2 3B" },
+      { id: "codellama:7b", name: "Code Llama 7B" },
+      { id: "llava:7b", name: "LLaVA 7B (vision)" }
+    ]
+  },
+  {
+    id: "openrouter",
+    name: "OpenRouter",
+    description: "Many models, pay-per-use",
+    needsApiKey: true,
+    models: [
+      { id: "qwen/qwen-2.5-coder-32b-instruct", name: "Qwen Coder 32B", recommended: true },
+      { id: "anthropic/claude-3.5-sonnet", name: "Claude 3.5 Sonnet" },
+      { id: "openai/gpt-4o", name: "GPT-4o" },
+      { id: "openai/gpt-4o-mini", name: "GPT-4o Mini" },
+      { id: "google/gemini-pro-1.5", name: "Gemini Pro 1.5" }
+    ]
+  },
+  {
+    id: "anthropic",
+    name: "Anthropic",
+    description: "Claude - Best reasoning",
+    needsApiKey: true,
+    models: [
+      { id: "claude-3-5-sonnet-20241022", name: "Claude 3.5 Sonnet", recommended: true },
+      { id: "claude-3-opus-20240229", name: "Claude 3 Opus" },
+      { id: "claude-3-haiku-20240307", name: "Claude 3 Haiku" }
+    ]
+  },
+  {
+    id: "openai",
+    name: "OpenAI",
+    description: "GPT models",
+    needsApiKey: true,
+    models: [
+      { id: "gpt-4o", name: "GPT-4o", recommended: true },
+      { id: "gpt-4o-mini", name: "GPT-4o Mini" },
+      { id: "gpt-4-turbo", name: "GPT-4 Turbo" }
+    ]
+  }
+];
+function ProviderSelector({ onClose, onSelect }) {
+  const config = getConfig();
+  const [step, setStep] = 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 [apiKeyInput, setApiKeyInput] = useState2("");
+  const [selectedProvider, setSelectedProvider] = useState2(null);
+  const [ollamaStatus, setOllamaStatus] = useState2(null);
+  const [checkingOllama, setCheckingOllama] = useState2(false);
+  useEffect(() => {
+    if (step === "model" && selectedProvider?.id === "ollama" && !ollamaStatus) {
+      setCheckingOllama(true);
+      checkOllamaStatus().then((status) => {
+        setOllamaStatus(status);
+        setCheckingOllama(false);
+        if (!status.running) {
+          setStep("ollamaError");
+        }
+      });
+    }
+  }, [step, selectedProvider, ollamaStatus]);
+  useInput2((input, key) => {
+    if (key.escape) {
+      onClose();
+      return;
+    }
+    if (step === "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 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 (!config.apiKeys[apiKeyProvider]) {
+            setStep("apiKey");
+          } else {
+            setStep("model");
+          }
+        } else {
+          setStep("model");
+        }
+      }
+    } else if (step === "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];
+        if (selectedProvider.id === "ollama" && ollamaStatus && !hasModel(ollamaStatus, model.id)) {
+        }
+        setProvider(selectedProvider.id);
+        setModel(model.id);
+        setStep("done");
+        onSelect(selectedProvider.id, model.id);
+        setTimeout(() => onClose(), 1500);
+      } else if (key.leftArrow || input === "b") {
+        setStep("provider");
+        setOllamaStatus(null);
+      }
+    } else if (step === "ollamaError") {
+      if (key.return || input === "b") {
+        setStep("provider");
+        setOllamaStatus(null);
+      }
+    }
+  });
+  const handleApiKeySubmit = (value) => {
+    if (value.trim() && selectedProvider) {
+      setApiKey(selectedProvider.id, value.trim());
+      setStep("model");
+    }
+  };
+  if (step === "provider") {
+    return /* @__PURE__ */ jsxs5(Box6, { flexDirection: "column", borderStyle: "round", borderColor: "cyan", padding: 1, width: 60, 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", dimColor: true, children: "Arrows to navigate, Enter to select" }) }),
+      PROVIDERS.map((provider, index) => {
+        const isSelected = index === providerIndex;
+        const isCurrent = provider.id === config.provider;
+        const hasKey = provider.needsApiKey && provider.id !== "ollama" ? !!config.apiKeys[provider.id] : true;
+        return /* @__PURE__ */ jsxs5(Box6, { flexDirection: "column", children: [
+          /* @__PURE__ */ jsxs5(Text6, { color: isSelected ? "cyan" : "white", children: [
+            isSelected ? "\u276F " : "  ",
+            provider.name,
+            isCurrent && /* @__PURE__ */ jsx6(Text6, { color: "green", children: " (current)" }),
+            provider.needsApiKey && !hasKey && /* @__PURE__ */ jsx6(Text6, { color: "red", children: " (needs key)" }),
+            provider.needsApiKey && hasKey && !isCurrent && /* @__PURE__ */ jsx6(Text6, { color: "yellow", children: " (key saved)" })
+          ] }),
+          isSelected && /* @__PURE__ */ jsxs5(Text6, { color: "gray", children: [
+            "    ",
+            provider.description
+          ] })
+        ] }, provider.id);
+      }),
+      /* @__PURE__ */ jsx6(Box6, { marginTop: 1, children: /* @__PURE__ */ jsx6(Text6, { color: "gray", dimColor: true, children: "Press Esc to cancel" }) })
+    ] });
+  }
+  if (step === "apiKey" && selectedProvider) {
+    return /* @__PURE__ */ jsxs5(Box6, { flexDirection: "column", borderStyle: "round", borderColor: "cyan", padding: 1, width: 60, children: [
+      /* @__PURE__ */ jsx6(Box6, { marginBottom: 1, children: /* @__PURE__ */ jsx6(Text6, { bold: true, color: "cyan", children: "Enter API Key" }) }),
+      /* @__PURE__ */ jsxs5(Text6, { children: [
+        /* @__PURE__ */ jsx6(Text6, { color: "green", children: "\u2713" }),
+        " Provider: ",
+        selectedProvider.name
+      ] }),
+      /* @__PURE__ */ jsxs5(Box6, { marginTop: 1, flexDirection: "column", children: [
+        /* @__PURE__ */ jsxs5(Text6, { color: "gray", dimColor: true, children: [
+          selectedProvider.id === "openrouter" && "Get key: openrouter.ai/keys",
+          selectedProvider.id === "anthropic" && "Get key: console.anthropic.com",
+          selectedProvider.id === "openai" && "Get key: platform.openai.com/api-keys"
+        ] }),
+        /* @__PURE__ */ jsxs5(Box6, { marginTop: 1, children: [
+          /* @__PURE__ */ jsx6(Text6, { color: "cyan", children: "\u276F " }),
+          /* @__PURE__ */ jsx6(
+            TextInput2,
+            {
+              value: apiKeyInput,
+              onChange: setApiKeyInput,
+              onSubmit: handleApiKeySubmit,
+              mask: "*"
+            }
+          )
+        ] })
+      ] }),
+      /* @__PURE__ */ jsx6(Box6, { marginTop: 1, children: /* @__PURE__ */ jsx6(Text6, { color: "gray", dimColor: true, children: "Press Esc to cancel" }) })
+    ] });
+  }
+  if (step === "ollamaError" && ollamaStatus) {
+    return /* @__PURE__ */ jsxs5(Box6, { flexDirection: "column", borderStyle: "round", borderColor: "red", padding: 1, width: 60, children: [
+      /* @__PURE__ */ jsx6(Box6, { marginBottom: 1, children: /* @__PURE__ */ jsx6(Text6, { bold: true, color: "red", children: "Ollama Not Available" }) }),
+      /* @__PURE__ */ jsx6(Text6, { color: "red", children: ollamaStatus.error }),
+      /* @__PURE__ */ jsxs5(Box6, { marginTop: 1, flexDirection: "column", children: [
+        !ollamaStatus.installed && /* @__PURE__ */ jsxs5(Fragment, { children: [
+          /* @__PURE__ */ jsx6(Text6, { children: "1. Install Ollama from https://ollama.ai" }),
+          /* @__PURE__ */ jsx6(Text6, { children: "2. Run: ollama pull qwen2.5:0.5b" }),
+          /* @__PURE__ */ jsx6(Text6, { children: "3. Try again" })
+        ] }),
+        ollamaStatus.installed && !ollamaStatus.running && /* @__PURE__ */ jsxs5(Fragment, { children: [
+          /* @__PURE__ */ jsx6(Text6, { children: "1. Start Ollama: ollama serve" }),
+          /* @__PURE__ */ jsx6(Text6, { children: "2. Or run any model: ollama run qwen2.5:0.5b" }),
+          /* @__PURE__ */ jsx6(Text6, { children: "3. Try again" })
+        ] })
+      ] }),
+      /* @__PURE__ */ jsx6(Box6, { marginTop: 1, children: /* @__PURE__ */ jsx6(Text6, { color: "gray", dimColor: true, children: "Press Enter or B to go back" }) })
+    ] });
+  }
+  if (step === "model" && selectedProvider) {
+    const isOllama = selectedProvider.id === "ollama";
+    return /* @__PURE__ */ jsxs5(Box6, { flexDirection: "column", borderStyle: "round", borderColor: "cyan", padding: 1, width: 60, children: [
+      /* @__PURE__ */ jsx6(Box6, { marginBottom: 1, children: /* @__PURE__ */ jsx6(Text6, { bold: true, color: "cyan", children: "Select Model" }) }),
+      /* @__PURE__ */ jsxs5(Text6, { children: [
+        /* @__PURE__ */ jsx6(Text6, { color: "green", children: "\u2713" }),
+        " Provider: ",
+        selectedProvider.name
+      ] }),
+      isOllama && checkingOllama && /* @__PURE__ */ jsxs5(Box6, { marginY: 1, children: [
+        /* @__PURE__ */ jsx6(Text6, { color: "cyan", children: /* @__PURE__ */ jsx6(Spinner, { type: "dots" }) }),
+        /* @__PURE__ */ jsx6(Text6, { children: " Checking Ollama status..." })
+      ] }),
+      isOllama && ollamaStatus && ollamaStatus.running && /* @__PURE__ */ jsxs5(Text6, { color: "green", children: [
+        "\u2713 Ollama running (",
+        ollamaStatus.models.length,
+        " models installed)"
+      ] }),
+      /* @__PURE__ */ jsx6(Box6, { marginTop: 1, marginBottom: 1, children: /* @__PURE__ */ jsx6(Text6, { 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 === config.model && selectedProvider.id === config.provider;
+        let modelStatus = "";
+        if (isOllama && ollamaStatus) {
+          const available = hasModel(ollamaStatus, model.id);
+          modelStatus = available ? " (installed)" : " (not installed)";
+        }
+        return /* @__PURE__ */ jsxs5(Text6, { color: isSelected ? "cyan" : "white", children: [
+          isSelected ? "\u276F " : "  ",
+          model.name,
+          model.recommended && /* @__PURE__ */ jsx6(Text6, { color: "yellow", children: " *" }),
+          isCurrent && /* @__PURE__ */ jsx6(Text6, { color: "green", children: " (current)" }),
+          isOllama && ollamaStatus && (hasModel(ollamaStatus, model.id) ? /* @__PURE__ */ jsx6(Text6, { color: "green", children: modelStatus }) : /* @__PURE__ */ jsx6(Text6, { color: "red", children: modelStatus }))
+        ] }, model.id);
+      }),
+      isOllama && /* @__PURE__ */ jsxs5(Box6, { marginTop: 1, flexDirection: "column", children: [
+        /* @__PURE__ */ jsx6(Text6, { color: "gray", dimColor: true, children: "* = Recommended" }),
+        ollamaStatus && !hasModel(ollamaStatus, selectedProvider.models[modelIndex]?.id || "") && /* @__PURE__ */ jsxs5(Text6, { color: "yellow", children: [
+          "Run: ollama pull ",
+          selectedProvider.models[modelIndex]?.id
+        ] })
+      ] }),
+      /* @__PURE__ */ jsx6(Box6, { marginTop: 1, children: /* @__PURE__ */ jsx6(Text6, { color: "gray", dimColor: true, children: "Press Esc to cancel" }) })
+    ] });
+  }
+  if (step === "done" && selectedProvider) {
+    return /* @__PURE__ */ jsxs5(Box6, { flexDirection: "column", borderStyle: "round", borderColor: "green", padding: 1, width: 60, children: [
+      /* @__PURE__ */ jsx6(Text6, { color: "green", bold: true, children: "Configuration Updated!" }),
+      /* @__PURE__ */ jsxs5(Text6, { children: [
+        /* @__PURE__ */ jsx6(Text6, { color: "green", children: "\u2713" }),
+        " Provider: ",
+        selectedProvider.name
+      ] }),
+      /* @__PURE__ */ jsxs5(Text6, { children: [
+        /* @__PURE__ */ jsx6(Text6, { color: "green", children: "\u2713" }),
+        " Model: ",
+        selectedProvider.models[modelIndex]?.name
+      ] }),
+      selectedProvider.id === "ollama" && ollamaStatus && !hasModel(ollamaStatus, selectedProvider.models[modelIndex]?.id || "") && /* @__PURE__ */ jsxs5(Text6, { color: "yellow", children: [
+        "Remember to run: ollama pull ",
+        selectedProvider.models[modelIndex]?.id
+      ] })
+    ] });
+  }
+  return null;
+}
+
+// src/hooks/useChat.ts
+import { useState as useState3, useCallback, useRef, useEffect as useEffect2 } 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.
@@ -322,24 +666,24 @@ async function chatOpenAI(messages, model) {
 }
 
 // src/lib/screen.ts
-import { exec } from "child_process";
-import { promisify } from "util";
-var execAsync = promisify(exec);
+import { exec as exec2 } from "child_process";
+import { promisify as promisify2 } from "util";
+var execAsync2 = promisify2(exec2);
 async function getScreenDescription() {
   try {
     const platform = process.platform;
     if (platform === "win32") {
-      const { stdout } = await execAsync(`
+      const { stdout } = await execAsync2(`
         Add-Type -AssemblyName System.Windows.Forms
         $screen = [System.Windows.Forms.Screen]::PrimaryScreen.Bounds
         Write-Output "$($screen.Width)x$($screen.Height)"
       `, { shell: "powershell.exe" });
       return `Screen ${stdout.trim()} captured`;
     } else if (platform === "darwin") {
-      const { stdout } = await execAsync(`system_profiler SPDisplaysDataType | grep Resolution | head -1`);
+      const { stdout } = await execAsync2(`system_profiler SPDisplaysDataType | grep Resolution | head -1`);
       return `Screen ${stdout.trim()}`;
     } else {
-      const { stdout } = await execAsync(`xdpyinfo | grep dimensions | awk '{print $2}'`);
+      const { stdout } = await execAsync2(`xdpyinfo | grep dimensions | awk '{print $2}'`);
       return `Screen ${stdout.trim()} captured`;
     }
   } catch {
@@ -347,6 +691,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);
+  useEffect2(() => {
+    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();
@@ -367,17 +812,17 @@ async function captureScreenshot() {
   }
 }
 async function captureScreenFallback() {
-  const { exec: exec5 } = await import("child_process");
-  const { promisify: promisify5 } = await import("util");
+  const { exec: exec6 } = await import("child_process");
+  const { promisify: promisify6 } = 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 execAsync6 = promisify6(exec6);
+  const tempFile = join2(tmpdir(), `cnapse-screen-${Date.now()}.png`);
   try {
     const platform = process.platform;
     if (platform === "win32") {
-      await execAsync5(`
+      await execAsync6(`
         Add-Type -AssemblyName System.Windows.Forms
         $screen = [System.Windows.Forms.Screen]::PrimaryScreen.Bounds
         $bitmap = New-Object System.Drawing.Bitmap($screen.Width, $screen.Height)
@@ -388,9 +833,9 @@ async function captureScreenFallback() {
         $bitmap.Dispose()
       `, { shell: "powershell.exe" });
     } else if (platform === "darwin") {
-      await execAsync5(`screencapture -x "${tempFile}"`);
+      await execAsync6(`screencapture -x "${tempFile}"`);
     } else {
-      await execAsync5(`gnome-screenshot -f "${tempFile}" 2>/dev/null || scrot "${tempFile}" 2>/dev/null || import -window root "${tempFile}"`);
+      await execAsync6(`gnome-screenshot -f "${tempFile}" 2>/dev/null || scrot "${tempFile}" 2>/dev/null || import -window root "${tempFile}"`);
     }
     const imageBuffer = await readFile(tempFile);
     await unlink(tempFile).catch(() => {
@@ -551,25 +996,59 @@ 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 useEffect3, useRef as useRef2 } from "react";
+
 // src/services/telegram.ts
 import { EventEmitter } from "events";
 
 // src/tools/shell.ts
-import { exec as exec4 } from "child_process";
-import { promisify as promisify4 } from "util";
+import { exec as exec5 } from "child_process";
+import { promisify as promisify5 } from "util";
 
 // src/tools/clipboard.ts
 import clipboardy from "clipboardy";
 
 // src/tools/process.ts
-import { exec as exec2 } from "child_process";
-import { promisify as promisify2 } from "util";
-var execAsync2 = promisify2(exec2);
-
-// src/tools/computer.ts
 import { exec as exec3 } from "child_process";
 import { promisify as promisify3 } from "util";
 var execAsync3 = promisify3(exec3);
+
+// src/tools/computer.ts
+import { exec as exec4 } from "child_process";
+import { promisify as promisify4 } from "util";
+var execAsync4 = promisify4(exec4);
 async function clickMouse(button = "left") {
   try {
     if (process.platform === "win32") {
@@ -579,12 +1058,12 @@ Add-Type -MemberDefinition @"
 public static extern void mouse_event(long dwFlags, long dx, long dy, long cButtons, long dwExtraInfo);
 "@ -Name Mouse -Namespace Win32
 ${button === "left" ? "[Win32.Mouse]::mouse_event(0x02, 0, 0, 0, 0); [Win32.Mouse]::mouse_event(0x04, 0, 0, 0, 0)" : button === "right" ? "[Win32.Mouse]::mouse_event(0x08, 0, 0, 0, 0); [Win32.Mouse]::mouse_event(0x10, 0, 0, 0, 0)" : "[Win32.Mouse]::mouse_event(0x20, 0, 0, 0, 0); [Win32.Mouse]::mouse_event(0x40, 0, 0, 0, 0)"}`;
-      await execAsync3(`powershell -Command "${script.replace(/\n/g, " ")}"`, { shell: "cmd.exe" });
+      await execAsync4(`powershell -Command "${script.replace(/\n/g, " ")}"`, { shell: "cmd.exe" });
     } else if (process.platform === "darwin") {
-      await execAsync3(`cliclick c:.`);
+      await execAsync4(`cliclick c:.`);
     } else {
       const btn = button === "left" ? "1" : button === "right" ? "3" : "2";
-      await execAsync3(`xdotool click ${btn}`);
+      await execAsync4(`xdotool click ${btn}`);
     }
     return ok(`Clicked ${button} button`);
   } catch (error) {
@@ -595,13 +1074,13 @@ async function typeText(text) {
   try {
     if (process.platform === "win32") {
       const escapedText = text.replace(/'/g, "''").replace(/[+^%~(){}[\]]/g, "{$&}");
-      await execAsync3(`powershell -Command "Add-Type -AssemblyName System.Windows.Forms; [System.Windows.Forms.SendKeys]::SendWait('${escapedText}')"`, { shell: "cmd.exe" });
+      await execAsync4(`powershell -Command "Add-Type -AssemblyName System.Windows.Forms; [System.Windows.Forms.SendKeys]::SendWait('${escapedText}')"`, { shell: "cmd.exe" });
     } else if (process.platform === "darwin") {
       const escaped = text.replace(/'/g, "'\\''");
-      await execAsync3(`osascript -e 'tell application "System Events" to keystroke "${escaped}"'`);
+      await execAsync4(`osascript -e 'tell application "System Events" to keystroke "${escaped}"'`);
     } else {
       const escaped = text.replace(/'/g, "'\\''");
-      await execAsync3(`xdotool type '${escaped}'`);
+      await execAsync4(`xdotool type '${escaped}'`);
     }
     return ok(`Typed: ${text}`);
   } catch (error) {
@@ -642,7 +1121,7 @@ async function pressKey(key) {
         "f12": "{F12}"
       };
       const winKey = winKeyMap[key.toLowerCase()] || key;
-      await execAsync3(`powershell -Command "Add-Type -AssemblyName System.Windows.Forms; [System.Windows.Forms.SendKeys]::SendWait('${winKey}')"`, { shell: "cmd.exe" });
+      await execAsync4(`powershell -Command "Add-Type -AssemblyName System.Windows.Forms; [System.Windows.Forms.SendKeys]::SendWait('${winKey}')"`, { shell: "cmd.exe" });
     } else if (process.platform === "darwin") {
       const macKeyMap = {
         "return": 36,
@@ -660,12 +1139,12 @@ async function pressKey(key) {
       };
       const keyCode = macKeyMap[key.toLowerCase()];
       if (keyCode) {
-        await execAsync3(`osascript -e 'tell application "System Events" to key code ${keyCode}'`);
+        await execAsync4(`osascript -e 'tell application "System Events" to key code ${keyCode}'`);
       } else {
-        await execAsync3(`osascript -e 'tell application "System Events" to keystroke "${key}"'`);
+        await execAsync4(`osascript -e 'tell application "System Events" to keystroke "${key}"'`);
       }
     } else {
-      await execAsync3(`xdotool key ${key}`);
+      await execAsync4(`xdotool key ${key}`);
     }
     return ok(`Pressed: ${key}`);
   } catch (error) {
@@ -678,7 +1157,7 @@ async function keyCombo(keys) {
       const hasWin = keys.some((k) => k.toLowerCase() === "meta" || k.toLowerCase() === "win");
       const hasR = keys.some((k) => k.toLowerCase() === "r");
       if (hasWin && hasR) {
-        await execAsync3(`powershell -Command "$shell = New-Object -ComObject WScript.Shell; $shell.Run('explorer shell:::{2559a1f3-21d7-11d4-bdaf-00c04f60b9f0}')"`, { shell: "cmd.exe" });
+        await execAsync4(`powershell -Command "$shell = New-Object -ComObject WScript.Shell; $shell.Run('explorer shell:::{2559a1f3-21d7-11d4-bdaf-00c04f60b9f0}')"`, { shell: "cmd.exe" });
         return ok(`Pressed: ${keys.join("+")}`);
       }
       const modifierMap = {
@@ -698,7 +1177,7 @@ async function keyCombo(keys) {
         }
       }
       combo += regularKeys.join("");
-      await execAsync3(`powershell -Command "Add-Type -AssemblyName System.Windows.Forms; [System.Windows.Forms.SendKeys]::SendWait('${combo}')"`, { shell: "cmd.exe" });
+      await execAsync4(`powershell -Command "Add-Type -AssemblyName System.Windows.Forms; [System.Windows.Forms.SendKeys]::SendWait('${combo}')"`, { shell: "cmd.exe" });
     } else if (process.platform === "darwin") {
       const modifiers = keys.filter((k) => ["control", "ctrl", "alt", "shift", "command", "meta"].includes(k.toLowerCase()));
       const regular = keys.filter((k) => !["control", "ctrl", "alt", "shift", "command", "meta"].includes(k.toLowerCase()));
@@ -714,9 +1193,9 @@ async function keyCombo(keys) {
         };
         cmd += " using {" + modifiers.map((m) => modMap[m.toLowerCase()]).join(", ") + "}";
       }
-      await execAsync3(`osascript -e '${cmd}'`);
+      await execAsync4(`osascript -e '${cmd}'`);
     } else {
-      await execAsync3(`xdotool key ${keys.join("+")}`);
+      await execAsync4(`xdotool key ${keys.join("+")}`);
     }
     return ok(`Pressed: ${keys.join("+")}`);
   } catch (error) {
@@ -727,11 +1206,11 @@ async function focusWindow(title) {
   try {
     if (process.platform === "win32") {
       const escaped = title.replace(/'/g, "''");
-      await execAsync3(`powershell -Command "$wshell = New-Object -ComObject wscript.shell; $wshell.AppActivate('${escaped}')"`, { shell: "cmd.exe" });
+      await execAsync4(`powershell -Command "$wshell = New-Object -ComObject wscript.shell; $wshell.AppActivate('${escaped}')"`, { shell: "cmd.exe" });
     } else if (process.platform === "darwin") {
-      await execAsync3(`osascript -e 'tell application "${title}" to activate'`);
+      await execAsync4(`osascript -e 'tell application "${title}" to activate'`);
     } else {
-      await execAsync3(`wmctrl -a "${title}"`);
+      await execAsync4(`wmctrl -a "${title}"`);
     }
     return ok(`Focused window: ${title}`);
   } catch (error) {
@@ -748,13 +1227,13 @@ function err(error) {
 }
 
 // src/tools/shell.ts
-var execAsync4 = promisify4(exec4);
+var execAsync5 = promisify5(exec5);
 async function runCommand(cmd, timeout = 3e4) {
   try {
     const isWindows = process.platform === "win32";
     const shell = isWindows ? "cmd.exe" : "/bin/sh";
     const shellArg = isWindows ? "/C" : "-c";
-    const { stdout, stderr } = await execAsync4(cmd, {
+    const { stdout, stderr } = await execAsync5(cmd, {
       shell,
       timeout,
       maxBuffer: 10 * 1024 * 1024
@@ -991,48 +1470,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);
+  useEffect3(() => {
+    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:
 
-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
+${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
 
-Respond ONLY with a JSON array of steps, no other text:
+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
+
+## 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 +1805,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 +1817,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 +1865,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}`);
-    } catch (err2) {
-      const errorMsg = err2 instanceof Error ? err2.message : "Vision analysis failed";
-      addSystemMessage(`\u274C Screen capture failed: ${errorMsg}`);
-    } 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.");
-      }
+${description}`);
     } catch (err2) {
-      const errorMsg = err2 instanceof Error ? err2.message : "Task failed";
-      addSystemMessage(`\u274C Task error: ${errorMsg}`);
+      chat2.addSystemMessage(`\u274C ${vision.error || "Vision failed"}`);
     } 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,94 +2120,102 @@ ${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];
-  switch (command) {
-    case "auth": {
-      const provider = args[1];
-      const key = args[2];
-      if (!provider || !key) {
-        console.log("Usage: cnapse auth <provider> <api-key>");
-        console.log("Providers: openrouter, anthropic, openai");
-        process.exit(1);
-      }
-      if (!["openrouter", "anthropic", "openai"].includes(provider)) {
-        console.log(`Invalid provider: ${provider}`);
-        console.log("Valid providers: openrouter, anthropic, openai");
-        process.exit(1);
-      }
-      setApiKey(provider, key);
-      console.log(`\u2713 ${provider} API key saved`);
-      process.exit(0);
-    }
-    case "config": {
-      const subcommand = args[1];
-      if (subcommand === "set") {
+async function main() {
+  if (args.length > 0) {
+    const command = args[0];
+    switch (command) {
+      case "auth": {
+        const provider = args[1];
         const key = args[2];
-        const value = args[3];
-        if (key === "provider") {
-          if (!["openrouter", "ollama", "anthropic", "openai"].includes(value)) {
-            console.log("Valid providers: openrouter, ollama, anthropic, openai");
-            process.exit(1);
-          }
-          setProvider(value);
-          console.log(`\u2713 Provider set to: ${value}`);
-        } else if (key === "model") {
-          setModel(value);
-          console.log(`\u2713 Model set to: ${value}`);
-        } else {
-          console.log("Usage: cnapse config set <provider|model> <value>");
+        if (!provider || !key) {
+          console.log("Usage: cnapse auth <provider> <api-key>");
+          console.log("Providers: openrouter, anthropic, openai");
+          process.exit(1);
+        }
+        if (!["openrouter", "anthropic", "openai"].includes(provider)) {
+          console.log(`Invalid provider: ${provider}`);
+          console.log("Valid providers: openrouter, anthropic, openai");
+          process.exit(1);
         }
+        setApiKey(provider, key);
+        console.log(`\u2713 ${provider} API key saved`);
         process.exit(0);
       }
-      if (subcommand === "show" || !subcommand) {
-        const config = getConfig();
-        console.log("\nC-napse Configuration:");
-        console.log(`  Provider: ${config.provider}`);
-        console.log(`  Model: ${config.model}`);
-        console.log(`  Ollama Host: ${config.ollamaHost}`);
-        console.log(`  API Keys configured:`);
-        console.log(`    - OpenRouter: ${config.apiKeys.openrouter ? "\u2713" : "\u2717"}`);
-        console.log(`    - Anthropic: ${config.apiKeys.anthropic ? "\u2713" : "\u2717"}`);
-        console.log(`    - OpenAI: ${config.apiKeys.openai ? "\u2713" : "\u2717"}`);
-        console.log("");
-        process.exit(0);
+      case "config": {
+        const subcommand = args[1];
+        if (!subcommand) {
+          const { ConfigUI } = await import("./ConfigUI-V5TM6KKS.js");
+          render(/* @__PURE__ */ jsx8(ConfigUI, {}));
+          return;
+        }
+        if (subcommand === "set") {
+          const key = args[2];
+          const value = args[3];
+          if (key === "provider") {
+            if (!["openrouter", "ollama", "anthropic", "openai"].includes(value)) {
+              console.log("Valid providers: openrouter, ollama, anthropic, openai");
+              process.exit(1);
+            }
+            setProvider(value);
+            console.log(`\u2713 Provider set to: ${value}`);
+          } else if (key === "model") {
+            setModel(value);
+            console.log(`\u2713 Model set to: ${value}`);
+          } else {
+            console.log("Usage: cnapse config set <provider|model> <value>");
+          }
+          process.exit(0);
+        }
+        if (subcommand === "show") {
+          const config = getConfig();
+          console.log("\nC-napse Configuration:");
+          console.log(`  Provider: ${config.provider}`);
+          console.log(`  Model: ${config.model}`);
+          console.log(`  Ollama Host: ${config.ollamaHost}`);
+          console.log(`  API Keys configured:`);
+          console.log(`    - OpenRouter: ${config.apiKeys.openrouter ? "\u2713" : "\u2717"}`);
+          console.log(`    - Anthropic: ${config.apiKeys.anthropic ? "\u2713" : "\u2717"}`);
+          console.log(`    - OpenAI: ${config.apiKeys.openai ? "\u2713" : "\u2717"}`);
+          console.log("");
+          process.exit(0);
+        }
+        console.log("Usage: cnapse config [show|set <key> <value>]");
+        process.exit(1);
       }
-      console.log("Usage: cnapse config [show|set <key> <value>]");
-      process.exit(1);
-    }
-    case "help":
-    case "--help":
-    case "-h": {
-      console.log(`
+      case "help":
+      case "--help":
+      case "-h": {
+        console.log(`
 C-napse - Autonomous PC Intelligence
 
 Usage:
   cnapse                     Start interactive chat
   cnapse init                Interactive setup wizard
-  cnapse auth <provider> <key>  Set API key
-  cnapse config              Show configuration
+  cnapse config              Interactive configuration
+  cnapse config show         Show current configuration
   cnapse config set <k> <v>  Set config value
+  cnapse auth <provider> <key>  Set API key
   cnapse help                Show this help
 
 Providers:
@@ -1575,28 +2226,31 @@ Providers:
 
 Quick Start:
   cnapse init                # Interactive setup
+  cnapse config              # Change provider/model
 
 Manual Setup:
   cnapse auth openrouter sk-or-xxxxx
   cnapse config set provider openrouter
   cnapse config set model qwen/qwen-2.5-coder-32b-instruct
 `);
-      process.exit(0);
-    }
-    case "version":
-    case "--version":
-    case "-v": {
-      console.log("cnapse v0.2.0");
-      process.exit(0);
-    }
-    case "init": {
-      const { Setup } = await import("./Setup-Q32JPHGP.js");
-      render(/* @__PURE__ */ jsx7(Setup, {}));
-      process.exit(0);
-    }
-    default: {
-      break;
+        process.exit(0);
+      }
+      case "version":
+      case "--version":
+      case "-v": {
+        console.log("cnapse v0.5.0");
+        process.exit(0);
+      }
+      case "init": {
+        const { Setup } = await import("./Setup-Q32JPHGP.js");
+        render(/* @__PURE__ */ jsx8(Setup, {}));
+        return;
+      }
+      default: {
+        break;
+      }
     }
   }
+  render(/* @__PURE__ */ jsx8(App, {}));
 }
-render(/* @__PURE__ */ jsx7(App, {}));
+main();