@projectservan8n/cnapse 0.2.1 → 0.5.0

package/dist/index.js

@@ -1,55 +1,21 @@
 #!/usr/bin/env node
+import {
+  getApiKey,
+  getConfig,
+  setApiKey,
+  setModel,
+  setProvider
+} from "./chunk-COKO6V5J.js";
 
 // src/index.tsx
 import { render } from "ink";
 
 // src/components/App.tsx
-import { useState } from "react";
-import { Box as Box5, Text as Text5, useApp, useInput } 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";
-
-// src/lib/config.ts
-import Conf from "conf";
-var config = new Conf({
-  projectName: "cnapse",
-  defaults: {
-    provider: "ollama",
-    model: "qwen2.5:0.5b",
-    apiKeys: {},
-    ollamaHost: "http://localhost:11434",
-    openrouter: {
-      siteUrl: "https://github.com/projectservan8n/C-napse",
-      appName: "C-napse"
-    }
-  }
-});
-function getConfig() {
-  return {
-    provider: config.get("provider"),
-    model: config.get("model"),
-    apiKeys: config.get("apiKeys"),
-    ollamaHost: config.get("ollamaHost"),
-    openrouter: config.get("openrouter")
-  };
-}
-function setProvider(provider) {
-  config.set("provider", provider);
-}
-function setModel(model) {
-  config.set("model", model);
-}
-function setApiKey(provider, key) {
-  const keys = config.get("apiKeys");
-  keys[provider] = key;
-  config.set("apiKeys", keys);
-}
-function getApiKey(provider) {
-  return config.get("apiKeys")[provider];
-}
-
-// src/components/Header.tsx
 import { jsx, jsxs } from "react/jsx-runtime";
 var ASCII_BANNER = `
   \u2588\u2588\u2588\u2588\u2588\u2588\u2557      \u2588\u2588\u2588\u2557   \u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557
@@ -59,15 +25,18 @@ var ASCII_BANNER = `
  \u255A\u2588\u2588\u2588\u2588\u2588\u2588\u2557      \u2588\u2588\u2551 \u255A\u2588\u2588\u2588\u2588\u2551\u2588\u2588\u2551  \u2588\u2588\u2551\u2588\u2588\u2551     \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557
   \u255A\u2550\u2550\u2550\u2550\u2550\u255D      \u255A\u2550\u255D  \u255A\u2550\u2550\u2550\u255D\u255A\u2550\u255D  \u255A\u2550\u255D\u255A\u2550\u255D     \u255A\u2550\u2550\u2550\u2550\u2550\u2550\u255D\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u255D
 `.trim();
-function Header() {
-  const config2 = getConfig();
+function Header({ screenWatch = false, telegramEnabled = false }) {
+  const config = getConfig();
   return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [
     /* @__PURE__ */ jsx(Text, { color: "cyan", children: ASCII_BANNER }),
     /* @__PURE__ */ jsx(Box, { justifyContent: "center", children: /* @__PURE__ */ jsxs(Text, { color: "gray", children: [
-      config2.provider,
+      config.provider,
       " \u2502 ",
-      config2.model
-    ] }) })
+      config.model,
+      screenWatch && /* @__PURE__ */ jsx(Text, { color: "yellow", children: " \u2502 \u{1F5A5}\uFE0F Screen" }),
+      telegramEnabled && /* @__PURE__ */ jsx(Text, { color: "blue", children: " \u2502 \u{1F4F1} Telegram" })
+    ] }) }),
+    /* @__PURE__ */ jsx(Box, { justifyContent: "center", children: /* @__PURE__ */ jsx(Text, { color: "gray", dimColor: true, children: "Press Ctrl+H for help" }) })
   ] });
 }
 
@@ -129,6 +98,236 @@ function StatusBar({ status }) {
   return /* @__PURE__ */ jsx4(Box4, { children: /* @__PURE__ */ jsx4(Text4, { backgroundColor: "gray", color: "white", children: ` ${status} \u2502 Ctrl+C: Exit \u2502 Enter: Send ` }) });
 }
 
+// src/components/HelpMenu.tsx
+import React, { useState } from "react";
+import { Box as Box5, Text as Text5, useInput } from "ink";
+import { jsx as jsx5, jsxs as jsxs4 } from "react/jsx-runtime";
+var MENU_ITEMS = [
+  // Navigation
+  { command: "/help", shortcut: "Ctrl+H", description: "Show this help menu", category: "navigation" },
+  { command: "/clear", shortcut: "Ctrl+L", description: "Clear chat history", category: "navigation" },
+  { command: "/quit", shortcut: "Ctrl+C", description: "Exit C-napse", category: "navigation" },
+  // Actions
+  { 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", shortcut: "Ctrl+P", description: "Change AI provider", category: "settings" }
+];
+function HelpMenu({ onClose, onSelect }) {
+  const [selectedIndex, setSelectedIndex] = useState(0);
+  const [selectedCategory, setSelectedCategory] = useState("all");
+  const filteredItems = selectedCategory === "all" ? MENU_ITEMS : MENU_ITEMS.filter((item) => item.category === selectedCategory);
+  useInput((input, key) => {
+    if (key.escape) {
+      onClose();
+      return;
+    }
+    if (key.upArrow) {
+      setSelectedIndex((prev) => prev > 0 ? prev - 1 : filteredItems.length - 1);
+    }
+    if (key.downArrow) {
+      setSelectedIndex((prev) => prev < filteredItems.length - 1 ? prev + 1 : 0);
+    }
+    if (key.leftArrow || key.rightArrow) {
+      const categories2 = ["all", "navigation", "actions", "settings"];
+      const currentIdx = categories2.indexOf(selectedCategory);
+      if (key.leftArrow) {
+        setSelectedCategory(categories2[currentIdx > 0 ? currentIdx - 1 : categories2.length - 1]);
+      } else {
+        setSelectedCategory(categories2[currentIdx < categories2.length - 1 ? currentIdx + 1 : 0]);
+      }
+      setSelectedIndex(0);
+    }
+    if (key.return) {
+      const item = filteredItems[selectedIndex];
+      if (item) {
+        onSelect(item.command);
+        onClose();
+      }
+    }
+  });
+  const categories = [
+    { key: "all", label: "All" },
+    { key: "navigation", label: "Navigation" },
+    { key: "actions", label: "Actions" },
+    { key: "settings", label: "Settings" }
+  ];
+  return /* @__PURE__ */ jsxs4(
+    Box5,
+    {
+      flexDirection: "column",
+      borderStyle: "round",
+      borderColor: "cyan",
+      padding: 1,
+      width: 60,
+      children: [
+        /* @__PURE__ */ jsx5(Box5, { justifyContent: "center", marginBottom: 1, children: /* @__PURE__ */ jsx5(Text5, { bold: true, color: "cyan", children: "C-napse Help" }) }),
+        /* @__PURE__ */ jsx5(Box5, { justifyContent: "center", marginBottom: 1, children: categories.map((cat, idx) => /* @__PURE__ */ jsxs4(React.Fragment, { children: [
+          /* @__PURE__ */ jsx5(
+            Text5,
+            {
+              color: selectedCategory === cat.key ? "cyan" : "gray",
+              bold: selectedCategory === cat.key,
+              children: cat.label
+            }
+          ),
+          idx < categories.length - 1 && /* @__PURE__ */ jsx5(Text5, { color: "gray", children: " \u2502 " })
+        ] }, cat.key)) }),
+        /* @__PURE__ */ jsx5(Box5, { marginBottom: 1, children: /* @__PURE__ */ jsx5(Text5, { color: "gray", dimColor: true, children: "Use \u2190\u2192 to switch tabs, \u2191\u2193 to navigate, Enter to select" }) }),
+        /* @__PURE__ */ jsx5(Box5, { flexDirection: "column", children: filteredItems.map((item, index) => /* @__PURE__ */ jsxs4(Box5, { children: [
+          /* @__PURE__ */ jsx5(Text5, { color: index === selectedIndex ? "cyan" : "white", children: index === selectedIndex ? "\u276F " : "  " }),
+          /* @__PURE__ */ jsx5(Box5, { width: 12, children: /* @__PURE__ */ jsx5(Text5, { bold: index === selectedIndex, color: index === selectedIndex ? "cyan" : "white", children: item.command }) }),
+          item.shortcut && /* @__PURE__ */ jsx5(Box5, { width: 10, children: /* @__PURE__ */ jsx5(Text5, { color: "yellow", dimColor: true, children: item.shortcut }) }),
+          /* @__PURE__ */ jsx5(Text5, { color: "gray", children: item.description })
+        ] }, item.command)) }),
+        /* @__PURE__ */ jsx5(Box5, { marginTop: 1, justifyContent: "center", children: /* @__PURE__ */ jsx5(Text5, { color: "gray", dimColor: true, children: "Press Esc to close" }) })
+      ]
+    }
+  );
+}
+
+// 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.
@@ -137,23 +336,23 @@ When responding:
 - Be direct and practical
 - Use markdown formatting for code blocks
 - If asked to do something, explain what you'll do first`;
-async function chat(messages) {
-  const config2 = getConfig();
+async function chat(messages, systemPrompt) {
+  const config = getConfig();
   const allMessages = [
-    { role: "system", content: SYSTEM_PROMPT },
+    { role: "system", content: systemPrompt || SYSTEM_PROMPT },
     ...messages
   ];
-  switch (config2.provider) {
+  switch (config.provider) {
     case "openrouter":
-      return chatOpenRouter(allMessages, config2.model);
+      return chatOpenRouter(allMessages, config.model);
     case "ollama":
-      return chatOllama(allMessages, config2.model);
+      return chatOllama(allMessages, config.model);
     case "anthropic":
-      return chatAnthropic(allMessages, config2.model);
+      return chatAnthropic(allMessages, config.model);
     case "openai":
-      return chatOpenAI(allMessages, config2.model);
+      return chatOpenAI(allMessages, config.model);
     default:
-      throw new Error(`Unknown provider: ${config2.provider}`);
+      throw new Error(`Unknown provider: ${config.provider}`);
   }
 }
 async function chatOpenRouter(messages, model) {
@@ -161,14 +360,14 @@ async function chatOpenRouter(messages, model) {
   if (!apiKey) {
     throw new Error("OpenRouter API key not configured. Run: cnapse auth openrouter <key>");
   }
-  const config2 = getConfig();
+  const config = getConfig();
   const response = await fetch("https://openrouter.ai/api/v1/chat/completions", {
     method: "POST",
     headers: {
       "Authorization": `Bearer ${apiKey}`,
       "Content-Type": "application/json",
-      "HTTP-Referer": config2.openrouter.siteUrl,
-      "X-Title": config2.openrouter.appName
+      "HTTP-Referer": config.openrouter.siteUrl,
+      "X-Title": config.openrouter.appName
     },
     body: JSON.stringify({
       model,
@@ -186,8 +385,8 @@ async function chatOpenRouter(messages, model) {
   return { content, model };
 }
 async function chatOllama(messages, model) {
-  const config2 = getConfig();
-  const response = await fetch(`${config2.ollamaHost}/api/chat`, {
+  const config = getConfig();
+  const response = await fetch(`${config.ollamaHost}/api/chat`, {
     method: "POST",
     headers: { "Content-Type": "application/json" },
     body: JSON.stringify({
@@ -260,71 +459,106 @@ async function chatOpenAI(messages, model) {
   return { content, model };
 }
 
-// src/components/App.tsx
-import { jsx as jsx5, jsxs as jsxs4 } from "react/jsx-runtime";
-function App() {
-  const { exit } = useApp();
-  const [messages, setMessages] = useState([
-    {
-      id: "0",
-      role: "system",
-      content: "Welcome to C-napse! Type your message and press Enter.\n\nShortcuts:\n  Ctrl+C - Exit\n  /clear - Clear chat\n  /help  - Show help",
-      timestamp: /* @__PURE__ */ new Date()
-    }
-  ]);
-  const [input, setInput] = useState("");
-  const [isProcessing, setIsProcessing] = useState(false);
-  const [status, setStatus] = useState("Ready");
-  const [error, setError] = useState(null);
-  useInput((inputChar, key) => {
-    if (key.ctrl && inputChar === "c") {
-      exit();
+// src/lib/screen.ts
+import { exec } from "child_process";
+import { promisify } from "util";
+var execAsync = promisify(exec);
+async function getScreenDescription() {
+  try {
+    const platform = process.platform;
+    if (platform === "win32") {
+      const { stdout } = await execAsync(`
+        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`);
+      return `Screen ${stdout.trim()}`;
+    } else {
+      const { stdout } = await execAsync(`xdpyinfo | grep dimensions | awk '{print $2}'`);
+      return `Screen ${stdout.trim()} captured`;
     }
-    if (key.ctrl && inputChar === "l") {
-      setMessages([messages[0]]);
-      setError(null);
-    }
-  });
-  const handleSubmit = async (value) => {
-    if (!value.trim() || isProcessing) return;
-    const userInput = value.trim();
-    setInput("");
-    setError(null);
-    if (userInput.startsWith("/")) {
-      handleCommand(userInput);
+  } catch {
+    return null;
+  }
+}
+
+// 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 userMsg = {
-      id: Date.now().toString(),
-      role: "user",
-      content: userInput,
-      timestamp: /* @__PURE__ */ new Date()
+    const checkScreen = async () => {
+      const desc = await getScreenDescription();
+      if (desc) {
+        screenContextRef.current = desc;
+      }
     };
-    setMessages((prev) => [...prev, userMsg]);
-    const assistantId = (Date.now() + 1).toString();
+    checkScreen();
+    const interval = setInterval(checkScreen, 5e3);
+    return () => clearInterval(interval);
+  }, [screenWatch]);
+  const addSystemMessage = useCallback((content) => {
     setMessages((prev) => [
       ...prev,
       {
-        id: assistantId,
-        role: "assistant",
-        content: "",
-        timestamp: /* @__PURE__ */ new Date(),
-        isStreaming: true
+        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);
-    setStatus("Thinking...");
     try {
       const apiMessages = messages.filter((m) => m.role === "user" || m.role === "assistant").slice(-10).map((m) => ({ role: m.role, content: m.content }));
-      apiMessages.push({ role: "user", content: userInput });
+      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 (err) {
-      const errorMsg = err instanceof Error ? err.message : "Unknown error";
+    } catch (err2) {
+      const errorMsg = err2 instanceof Error ? err2.message : "Unknown error";
       setError(errorMsg);
       setMessages(
         (prev) => prev.map(
@@ -333,43 +567,1343 @@ function App() {
       );
     } finally {
       setIsProcessing(false);
-      setStatus("Ready");
     }
+  }, [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();
+  if (!screenshot) {
+    throw new Error("Failed to capture screenshot");
+  }
+  const config = getConfig();
+  const description = await analyzeWithVision(screenshot, config.provider);
+  return { description, screenshot };
+}
+async function captureScreenshot() {
+  try {
+    const screenshotDesktop = await import("screenshot-desktop");
+    const buffer = await screenshotDesktop.default({ format: "png" });
+    return buffer.toString("base64");
+  } catch {
+    return captureScreenFallback();
+  }
+}
+async function captureScreenFallback() {
+  const { exec: exec5 } = await import("child_process");
+  const { promisify: promisify5 } = await import("util");
+  const { tmpdir } = await import("os");
+  const { join: join2 } = await import("path");
+  const { readFile, unlink } = await import("fs/promises");
+  const execAsync5 = promisify5(exec5);
+  const tempFile = join2(tmpdir(), `cnapse-screen-${Date.now()}.png`);
+  try {
+    const platform = process.platform;
+    if (platform === "win32") {
+      await execAsync5(`
+        Add-Type -AssemblyName System.Windows.Forms
+        $screen = [System.Windows.Forms.Screen]::PrimaryScreen.Bounds
+        $bitmap = New-Object System.Drawing.Bitmap($screen.Width, $screen.Height)
+        $graphics = [System.Drawing.Graphics]::FromImage($bitmap)
+        $graphics.CopyFromScreen($screen.Location, [System.Drawing.Point]::Empty, $screen.Size)
+        $bitmap.Save("${tempFile.replace(/\\/g, "\\\\")}")
+        $graphics.Dispose()
+        $bitmap.Dispose()
+      `, { shell: "powershell.exe" });
+    } else if (platform === "darwin") {
+      await execAsync5(`screencapture -x "${tempFile}"`);
+    } else {
+      await execAsync5(`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(() => {
+    });
+    return imageBuffer.toString("base64");
+  } catch {
+    return null;
+  }
+}
+async function analyzeWithVision(base64Image, provider) {
+  const prompt = `Look at this screenshot and describe:
+1. What application or window is visible
+2. Key UI elements you can see (buttons, text fields, menus)
+3. What the user appears to be doing or could do next
+4. Any notable content or state
+
+Be concise but helpful.`;
+  switch (provider) {
+    case "ollama":
+      return analyzeWithOllama(base64Image, prompt);
+    case "openrouter":
+      return analyzeWithOpenRouter(base64Image, prompt);
+    case "anthropic":
+      return analyzeWithAnthropic(base64Image, prompt);
+    case "openai":
+      return analyzeWithOpenAI(base64Image, prompt);
+    default:
+      throw new Error(`Vision not supported for provider: ${provider}`);
+  }
+}
+async function analyzeWithOllama(base64Image, prompt) {
+  const config = getConfig();
+  const ollamaHost = config.ollamaHost || "http://localhost:11434";
+  const visionModels = ["llava", "llama3.2-vision", "bakllava", "llava-llama3"];
+  const model = visionModels.find((m) => config.model.includes(m)) || "llava";
+  const response = await fetch(`${ollamaHost}/api/generate`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      model,
+      prompt,
+      images: [base64Image],
+      stream: false
+    })
+  });
+  if (!response.ok) {
+    const text = await response.text();
+    throw new Error(`Ollama vision error: ${text}`);
+  }
+  const data = await response.json();
+  return data.response || "Unable to analyze image";
+}
+async function analyzeWithOpenRouter(base64Image, prompt) {
+  const apiKey = getApiKey("openrouter");
+  if (!apiKey) throw new Error("OpenRouter API key not configured");
+  const model = "anthropic/claude-3-5-sonnet";
+  const response = await fetch("https://openrouter.ai/api/v1/chat/completions", {
+    method: "POST",
+    headers: {
+      "Authorization": `Bearer ${apiKey}`,
+      "Content-Type": "application/json",
+      "HTTP-Referer": "https://c-napse.up.railway.app",
+      "X-Title": "C-napse"
+    },
+    body: JSON.stringify({
+      model,
+      messages: [
+        {
+          role: "user",
+          content: [
+            { type: "text", text: prompt },
+            {
+              type: "image_url",
+              image_url: { url: `data:image/png;base64,${base64Image}` }
+            }
+          ]
+        }
+      ],
+      max_tokens: 1e3
+    })
+  });
+  if (!response.ok) {
+    const text = await response.text();
+    throw new Error(`OpenRouter vision error: ${text}`);
+  }
+  const data = await response.json();
+  return data.choices?.[0]?.message?.content || "Unable to analyze image";
+}
+async function analyzeWithAnthropic(base64Image, prompt) {
+  const apiKey = getApiKey("anthropic");
+  if (!apiKey) throw new Error("Anthropic API key not configured");
+  const response = await fetch("https://api.anthropic.com/v1/messages", {
+    method: "POST",
+    headers: {
+      "x-api-key": apiKey,
+      "anthropic-version": "2023-06-01",
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({
+      model: "claude-3-5-sonnet-20241022",
+      max_tokens: 1e3,
+      messages: [
+        {
+          role: "user",
+          content: [
+            {
+              type: "image",
+              source: {
+                type: "base64",
+                media_type: "image/png",
+                data: base64Image
+              }
+            },
+            { type: "text", text: prompt }
+          ]
+        }
+      ]
+    })
+  });
+  if (!response.ok) {
+    const text = await response.text();
+    throw new Error(`Anthropic vision error: ${text}`);
+  }
+  const data = await response.json();
+  return data.content?.[0]?.text || "Unable to analyze image";
+}
+async function analyzeWithOpenAI(base64Image, prompt) {
+  const apiKey = getApiKey("openai");
+  if (!apiKey) throw new Error("OpenAI API key not configured");
+  const response = await fetch("https://api.openai.com/v1/chat/completions", {
+    method: "POST",
+    headers: {
+      "Authorization": `Bearer ${apiKey}`,
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({
+      model: "gpt-4-vision-preview",
+      messages: [
+        {
+          role: "user",
+          content: [
+            { type: "text", text: prompt },
+            {
+              type: "image_url",
+              image_url: { url: `data:image/png;base64,${base64Image}` }
+            }
+          ]
+        }
+      ],
+      max_tokens: 1e3
+    })
+  });
+  if (!response.ok) {
+    const text = await response.text();
+    throw new Error(`OpenAI vision error: ${text}`);
+  }
+  const data = await response.json();
+  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";
+
+// src/tools/shell.ts
+import { exec as exec4 } from "child_process";
+import { promisify as promisify4 } 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);
+async function clickMouse(button = "left") {
+  try {
+    if (process.platform === "win32") {
+      const script = `
+Add-Type -MemberDefinition @"
+[DllImport("user32.dll",CharSet=CharSet.Auto,CallingConvention=CallingConvention.StdCall)]
+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" });
+    } else if (process.platform === "darwin") {
+      await execAsync3(`cliclick c:.`);
+    } else {
+      const btn = button === "left" ? "1" : button === "right" ? "3" : "2";
+      await execAsync3(`xdotool click ${btn}`);
+    }
+    return ok(`Clicked ${button} button`);
+  } catch (error) {
+    return err(`Failed to click: ${error instanceof Error ? error.message : "Unknown error"}`);
+  }
+}
+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" });
+    } else if (process.platform === "darwin") {
+      const escaped = text.replace(/'/g, "'\\''");
+      await execAsync3(`osascript -e 'tell application "System Events" to keystroke "${escaped}"'`);
+    } else {
+      const escaped = text.replace(/'/g, "'\\''");
+      await execAsync3(`xdotool type '${escaped}'`);
+    }
+    return ok(`Typed: ${text}`);
+  } catch (error) {
+    return err(`Failed to type: ${error instanceof Error ? error.message : "Unknown error"}`);
+  }
+}
+async function pressKey(key) {
+  try {
+    if (process.platform === "win32") {
+      const winKeyMap = {
+        "enter": "{ENTER}",
+        "return": "{ENTER}",
+        "escape": "{ESC}",
+        "esc": "{ESC}",
+        "tab": "{TAB}",
+        "space": " ",
+        "backspace": "{BACKSPACE}",
+        "delete": "{DELETE}",
+        "up": "{UP}",
+        "down": "{DOWN}",
+        "left": "{LEFT}",
+        "right": "{RIGHT}",
+        "home": "{HOME}",
+        "end": "{END}",
+        "pageup": "{PGUP}",
+        "pagedown": "{PGDN}",
+        "f1": "{F1}",
+        "f2": "{F2}",
+        "f3": "{F3}",
+        "f4": "{F4}",
+        "f5": "{F5}",
+        "f6": "{F6}",
+        "f7": "{F7}",
+        "f8": "{F8}",
+        "f9": "{F9}",
+        "f10": "{F10}",
+        "f11": "{F11}",
+        "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" });
+    } else if (process.platform === "darwin") {
+      const macKeyMap = {
+        "return": 36,
+        "enter": 36,
+        "escape": 53,
+        "esc": 53,
+        "tab": 48,
+        "space": 49,
+        "backspace": 51,
+        "delete": 117,
+        "up": 126,
+        "down": 125,
+        "left": 123,
+        "right": 124
+      };
+      const keyCode = macKeyMap[key.toLowerCase()];
+      if (keyCode) {
+        await execAsync3(`osascript -e 'tell application "System Events" to key code ${keyCode}'`);
+      } else {
+        await execAsync3(`osascript -e 'tell application "System Events" to keystroke "${key}"'`);
+      }
+    } else {
+      await execAsync3(`xdotool key ${key}`);
+    }
+    return ok(`Pressed: ${key}`);
+  } catch (error) {
+    return err(`Failed to press key: ${error instanceof Error ? error.message : "Unknown error"}`);
+  }
+}
+async function keyCombo(keys) {
+  try {
+    if (process.platform === "win32") {
+      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" });
+        return ok(`Pressed: ${keys.join("+")}`);
+      }
+      const modifierMap = {
+        "control": "^",
+        "ctrl": "^",
+        "alt": "%",
+        "shift": "+"
+      };
+      let combo = "";
+      const regularKeys = [];
+      for (const key of keys) {
+        const lower = key.toLowerCase();
+        if (modifierMap[lower]) {
+          combo += modifierMap[lower];
+        } else if (lower !== "meta" && lower !== "win") {
+          regularKeys.push(key.toLowerCase());
+        }
+      }
+      combo += regularKeys.join("");
+      await execAsync3(`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()));
+      let cmd = 'tell application "System Events" to keystroke "' + regular.join("") + '"';
+      if (modifiers.length > 0) {
+        const modMap = {
+          "control": "control down",
+          "ctrl": "control down",
+          "alt": "option down",
+          "shift": "shift down",
+          "command": "command down",
+          "meta": "command down"
+        };
+        cmd += " using {" + modifiers.map((m) => modMap[m.toLowerCase()]).join(", ") + "}";
+      }
+      await execAsync3(`osascript -e '${cmd}'`);
+    } else {
+      await execAsync3(`xdotool key ${keys.join("+")}`);
+    }
+    return ok(`Pressed: ${keys.join("+")}`);
+  } catch (error) {
+    return err(`Failed to press combo: ${error instanceof Error ? error.message : "Unknown error"}`);
+  }
+}
+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" });
+    } else if (process.platform === "darwin") {
+      await execAsync3(`osascript -e 'tell application "${title}" to activate'`);
+    } else {
+      await execAsync3(`wmctrl -a "${title}"`);
+    }
+    return ok(`Focused window: ${title}`);
+  } catch (error) {
+    return err(`Failed to focus window: ${error instanceof Error ? error.message : "Unknown error"}`);
+  }
+}
+
+// src/tools/index.ts
+function ok(output) {
+  return { success: true, output };
+}
+function err(error) {
+  return { success: false, output: "", error };
+}
+
+// src/tools/shell.ts
+var execAsync4 = promisify4(exec4);
+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, {
+      shell,
+      timeout,
+      maxBuffer: 10 * 1024 * 1024
+      // 10MB
+    });
+    if (stderr && stderr.trim()) {
+      return ok(`${stdout}
+[stderr]: ${stderr}`);
+    }
+    return ok(stdout || "(no output)");
+  } catch (error) {
+    if (error.killed) {
+      return err(`Command timed out after ${timeout}ms`);
+    }
+    const stderr = error.stderr || "";
+    const stdout = error.stdout || "";
+    return {
+      success: false,
+      output: stdout,
+      error: `Exit code: ${error.code || -1}
+${stderr}`
+    };
+  }
+}
+
+// src/services/telegram.ts
+var TelegramBotService = class extends EventEmitter {
+  bot = null;
+  isRunning = false;
+  allowedChatIds = /* @__PURE__ */ new Set();
+  constructor() {
+    super();
+  }
+  /**
+   * Start the Telegram bot
+   */
+  async start() {
+    if (this.isRunning) {
+      return;
+    }
+    const botToken = getApiKey("telegram");
+    if (!botToken) {
+      throw new Error("Telegram bot token not configured. Use: cnapse auth telegram YOUR_BOT_TOKEN");
+    }
+    try {
+      const { Telegraf } = await import("telegraf");
+      this.bot = new Telegraf(botToken);
+      const config = getConfig();
+      if (config.telegram?.chatId) {
+        this.allowedChatIds.add(config.telegram.chatId);
+      }
+      this.setupHandlers();
+      await this.bot.launch();
+      this.isRunning = true;
+      this.emit("started");
+    } catch (error) {
+      throw new Error(`Failed to start Telegram bot: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+  }
+  /**
+   * Stop the Telegram bot
+   */
+  async stop() {
+    if (!this.isRunning || !this.bot) {
+      return;
+    }
+    this.bot.stop("SIGTERM");
+    this.isRunning = false;
+    this.bot = null;
+    this.emit("stopped");
+  }
+  /**
+   * Check if bot is running
+   */
+  get running() {
+    return this.isRunning;
+  }
+  /**
+   * Setup message and command handlers
+   */
+  setupHandlers() {
+    if (!this.bot) return;
+    this.bot.command("start", async (ctx) => {
+      const chatId = ctx.chat.id;
+      this.allowedChatIds.add(chatId);
+      await ctx.reply(
+        `\u{1F916} C-napse connected!
+
+Commands:
+/screen - Take screenshot
+/describe - Screenshot + AI description
+/run <cmd> - Execute command
+/status - System status
+
+Your chat ID: ${chatId}`
+      );
+    });
+    this.bot.command("screen", async (ctx) => {
+      if (!this.isAllowed(ctx.chat.id)) {
+        await ctx.reply("\u26D4 Not authorized. Send /start first.");
+        return;
+      }
+      await ctx.reply("\u{1F4F8} Taking screenshot...");
+      try {
+        const screenshot = await captureScreenshot();
+        if (!screenshot) {
+          await ctx.reply("\u274C Failed to capture screenshot");
+          return;
+        }
+        const buffer = Buffer.from(screenshot, "base64");
+        await ctx.replyWithPhoto({ source: buffer }, { caption: "\u{1F4F8} Current screen" });
+      } catch (error) {
+        await ctx.reply(`\u274C Error: ${error instanceof Error ? error.message : "Unknown error"}`);
+      }
+    });
+    this.bot.command("describe", async (ctx) => {
+      if (!this.isAllowed(ctx.chat.id)) {
+        await ctx.reply("\u26D4 Not authorized. Send /start first.");
+        return;
+      }
+      await ctx.reply("\u{1F50D} Analyzing screen...");
+      try {
+        const result = await describeScreen();
+        const buffer = Buffer.from(result.screenshot, "base64");
+        const caption = `\u{1F5A5}\uFE0F Screen Analysis:
+
+${result.description}`.slice(0, 1024);
+        await ctx.replyWithPhoto({ source: buffer }, { caption });
+        if (result.description.length > 900) {
+          await ctx.reply(result.description);
+        }
+      } catch (error) {
+        await ctx.reply(`\u274C Error: ${error instanceof Error ? error.message : "Unknown error"}`);
+      }
+    });
+    this.bot.command("run", async (ctx) => {
+      if (!this.isAllowed(ctx.chat.id)) {
+        await ctx.reply("\u26D4 Not authorized. Send /start first.");
+        return;
+      }
+      const cmd = ctx.message.text.replace("/run ", "").trim();
+      if (!cmd) {
+        await ctx.reply("Usage: /run <command>\nExample: /run dir");
+        return;
+      }
+      await ctx.reply(`\u2699\uFE0F Running: ${cmd}`);
+      try {
+        const result = await runCommand(cmd, 3e4);
+        if (result.success) {
+          const output = result.output.slice(0, 4e3) || "(no output)";
+          await ctx.reply(`\u2705 Output:
+\`\`\`
+${output}
+\`\`\``, { parse_mode: "Markdown" });
+        } else {
+          await ctx.reply(`\u274C Error:
+\`\`\`
+${result.error}
+\`\`\``, { parse_mode: "Markdown" });
+        }
+      } catch (error) {
+        await ctx.reply(`\u274C Error: ${error instanceof Error ? error.message : "Unknown error"}`);
+      }
+    });
+    this.bot.command("status", async (ctx) => {
+      if (!this.isAllowed(ctx.chat.id)) {
+        await ctx.reply("\u26D4 Not authorized. Send /start first.");
+        return;
+      }
+      const config = getConfig();
+      const status = [
+        "\u{1F4CA} C-napse Status",
+        "",
+        `Provider: ${config.provider}`,
+        `Model: ${config.model}`,
+        `Platform: ${process.platform}`,
+        `Node: ${process.version}`
+      ].join("\n");
+      await ctx.reply(status);
+    });
+    this.bot.on("text", async (ctx) => {
+      if (!this.isAllowed(ctx.chat.id)) {
+        return;
+      }
+      if (ctx.message.text.startsWith("/")) {
+        return;
+      }
+      const message = {
+        chatId: ctx.chat.id,
+        text: ctx.message.text,
+        from: ctx.from.username || ctx.from.first_name || "User"
+      };
+      this.emit("message", message);
+      this.emit("command", "chat", ctx.message.text, ctx.chat.id);
+    });
+    this.bot.catch((err2) => {
+      this.emit("error", err2);
+    });
+  }
+  /**
+   * Check if chat is authorized
+   */
+  isAllowed(chatId) {
+    if (this.allowedChatIds.size === 0) {
+      return true;
+    }
+    return this.allowedChatIds.has(chatId);
+  }
+  /**
+   * Send a message to a specific chat
+   */
+  async sendMessage(chatId, text) {
+    if (!this.bot || !this.isRunning) {
+      throw new Error("Telegram bot is not running");
+    }
+    await this.bot.telegram.sendMessage(chatId, text);
+  }
+  /**
+   * Send a photo to a specific chat
+   */
+  async sendPhoto(chatId, base64Image, caption) {
+    if (!this.bot || !this.isRunning) {
+      throw new Error("Telegram bot is not running");
+    }
+    const buffer = Buffer.from(base64Image, "base64");
+    await this.bot.telegram.sendPhoto(chatId, { source: buffer }, { caption });
+  }
+};
+var instance = null;
+function getTelegramBot() {
+  if (!instance) {
+    instance = new TelegramBotService();
+  }
+  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
+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
+
+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": "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 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": "Close active window with Alt+F4", "action": "key_combo:alt+f4" }
+]
+
+## YOUR TASK
+Now parse this request: "${input}"
+
+First, briefly think through the 4 questions above, then output ONLY a JSON array:
+[
+  { "description": "Human readable step", "action": "action_type:params" },
+  ...
+]`;
+}
+async function parseTask(input) {
+  const systemPrompt = buildChainOfThoughtPrompt(input);
+  const messages = [
+    { role: "user", content: input }
+  ];
+  try {
+    const response = await chat(messages, systemPrompt);
+    const content = response.content || "[]";
+    const jsonMatch = content.match(/\[[\s\S]*\]/);
+    if (!jsonMatch) {
+      throw new Error("Failed to parse task steps");
+    }
+    const parsedSteps = JSON.parse(jsonMatch[0]);
+    const steps = parsedSteps.map((step, index) => ({
+      id: `step-${index + 1}`,
+      description: step.description,
+      action: step.action,
+      status: "pending"
+    }));
+    return {
+      id: `task-${Date.now()}`,
+      description: input,
+      steps,
+      status: "pending",
+      createdAt: /* @__PURE__ */ new Date()
+    };
+  } catch (error) {
+    return {
+      id: `task-${Date.now()}`,
+      description: input,
+      steps: [{
+        id: "step-1",
+        description: input,
+        action: `chat:${input}`,
+        status: "pending"
+      }],
+      status: "pending",
+      createdAt: /* @__PURE__ */ new Date()
+    };
+  }
+}
+async function executeStep(step) {
+  const [actionType, ...paramParts] = step.action.split(":");
+  const params = paramParts.join(":");
+  switch (actionType) {
+    case "open_app":
+      await keyCombo(["meta", "r"]);
+      await sleep(500);
+      await typeText(params);
+      await sleep(300);
+      await pressKey("Return");
+      step.result = `Opened ${params}`;
+      break;
+    case "type_text":
+      await typeText(params);
+      step.result = `Typed: ${params}`;
+      break;
+    case "press_key":
+      await pressKey(params);
+      step.result = `Pressed ${params}`;
+      break;
+    case "key_combo":
+      const keys = params.split("+").map((k) => k.trim());
+      await keyCombo(keys);
+      step.result = `Pressed ${params}`;
+      break;
+    case "click":
+      const button = params || "left";
+      await clickMouse(button);
+      step.result = `Clicked ${button}`;
+      break;
+    case "wait":
+      const seconds = parseInt(params) || 1;
+      await sleep(seconds * 1e3);
+      step.result = `Waited ${seconds}s`;
+      break;
+    case "focus_window":
+      await focusWindow(params);
+      step.result = `Focused window: ${params}`;
+      break;
+    case "screenshot":
+      const vision = await describeScreen();
+      step.result = vision.description;
+      break;
+    case "chat":
+      step.result = `Task noted: ${params}`;
+      break;
+    default:
+      throw new Error(`Unknown action: ${actionType}`);
+  }
+}
+async function executeTask(task, onProgress) {
+  task.status = "running";
+  for (const step of task.steps) {
+    if (task.status === "failed") {
+      step.status = "skipped";
+      continue;
+    }
+    step.status = "running";
+    onProgress?.(task, step);
+    try {
+      await executeStep(step);
+      step.status = "completed";
+    } catch (error) {
+      step.status = "failed";
+      step.error = error instanceof Error ? error.message : "Unknown error";
+      task.status = "failed";
+    }
+    onProgress?.(task, step);
+  }
+  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;
+}
+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",
+    running: "\u{1F504}",
+    completed: "\u2705",
+    failed: "\u274C"
+  };
+  const stepStatusEmoji = {
+    pending: "\u25CB",
+    running: "\u25D0",
+    completed: "\u25CF",
+    failed: "\u2717",
+    skipped: "\u25CC"
   };
-  const handleCommand = (cmd) => {
+  let output = `${statusEmoji[task.status]} Task: ${task.description}
+
+`;
+  for (const step of task.steps) {
+    output += `  ${stepStatusEmoji[step.status]} ${step.description}`;
+    if (step.result) {
+      output += ` \u2192 ${step.result}`;
+    }
+    if (step.error) {
+      output += ` (Error: ${step.error})`;
+    }
+    output += "\n";
+  }
+  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 jsx7, jsxs as jsxs6 } from "react/jsx-runtime";
+function App() {
+  const { exit } = useApp();
+  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;
+        chat2.addSystemMessage(
+          newState ? "\u{1F5A5}\uFE0F Screen watching enabled." : "\u{1F5A5}\uFE0F Screen watching disabled."
+        );
+        return newState;
+      });
+    }
+    if (key.ctrl && inputChar === "t") {
+      handleTelegramToggle();
+    }
+  });
+  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":
-        addSystemMessage(
-          "Commands:\n  /clear - Clear chat history\n  /help  - Show this help\n\nJust type naturally to chat with the AI!"
+        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;
+          chat2.addSystemMessage(
+            newState ? "\u{1F5A5}\uFE0F Screen watching enabled." : "\u{1F5A5}\uFE0F Screen watching disabled."
+          );
+          return newState;
+        });
+        break;
+      case "telegram":
+        await handleTelegramToggle();
+        break;
+      case "task":
+        if (args2) {
+          await handleTaskCommand(args2);
+        } else {
+          chat2.addSystemMessage("Usage: /task <description>\nExample: /task open notepad and type hello");
+        }
+        break;
+      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}`);
+        chat2.addSystemMessage(`Unknown command: ${command}
+Type /help for commands`);
     }
-  };
-  const addSystemMessage = (content) => {
-    setMessages((prev) => [
-      ...prev,
+  }, [chat2, exit]);
+  const handleScreenCommand = useCallback5(async () => {
+    chat2.addSystemMessage("\u{1F4F8} Analyzing screen...");
+    setStatus("Analyzing...");
+    try {
+      const description = await vision.analyze();
+      chat2.addSystemMessage(`\u{1F5A5}\uFE0F Screen:
+
+${description}`);
+    } catch (err2) {
+      chat2.addSystemMessage(`\u274C ${vision.error || "Vision failed"}`);
+    } finally {
+      setStatus("Ready");
+    }
+  }, [chat2, vision]);
+  const handleTelegramToggle = useCallback5(async () => {
+    if (telegram.isEnabled) {
+      await telegram.stop();
+      chat2.addSystemMessage("\u{1F4F1} Telegram stopped.");
+    } else {
+      chat2.addSystemMessage("\u{1F4F1} Starting Telegram...");
+      setStatus("Starting Telegram...");
+      try {
+        await telegram.start();
+        chat2.addSystemMessage(
+          "\u{1F4F1} Telegram started!\nSend /start to your bot to connect.\nCommands: /screen, /describe, /run, /status"
+        );
+      } catch {
+        chat2.addSystemMessage(`\u274C ${telegram.error || "Telegram failed"}`);
+      } finally {
+        setStatus("Ready");
+      }
+    }
+  }, [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);
-  return /* @__PURE__ */ jsxs4(Box5, { flexDirection: "column", height: "100%", children: [
-    /* @__PURE__ */ jsx5(Header, {}),
-    /* @__PURE__ */ jsxs4(Box5, { flexDirection: "column", flexGrow: 1, borderStyle: "round", borderColor: "gray", padding: 1, children: [
-      /* @__PURE__ */ jsx5(Text5, { bold: true, color: "gray", children: " Chat " }),
-      visibleMessages.map((msg) => /* @__PURE__ */ jsx5(
+    ) });
+  }
+  if (overlay === "provider") {
+    return /* @__PURE__ */ jsx7(Box7, { flexDirection: "column", height: "100%", alignItems: "center", justifyContent: "center", children: /* @__PURE__ */ jsx7(
+      ProviderSelector,
+      {
+        onClose: () => setOverlay("none"),
+        onSelect: handleProviderSelect
+      }
+    ) });
+  }
+  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,
@@ -380,25 +1914,26 @@ function App() {
         msg.id
       ))
     ] }),
-    error && /* @__PURE__ */ jsx5(Box5, { marginY: 1, children: /* @__PURE__ */ jsxs4(Text5, { color: "red", children: [
+    chat2.error && /* @__PURE__ */ jsx7(Box7, { marginY: 1, children: /* @__PURE__ */ jsxs6(Text7, { color: "red", children: [
       "Error: ",
-      error
+      chat2.error
     ] }) }),
-    /* @__PURE__ */ jsx5(
+    /* @__PURE__ */ jsx7(
       ChatInput,
       {
-        value: input,
-        onChange: setInput,
+        value: "",
+        onChange: () => {
+        },
         onSubmit: handleSubmit,
         isProcessing
       }
     ),
-    /* @__PURE__ */ jsx5(StatusBar, { status })
+    /* @__PURE__ */ jsx7(StatusBar, { status })
   ] });
 }
 
 // src/index.tsx
-import { jsx as jsx6 } 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];
@@ -441,15 +1976,15 @@ if (args.length > 0) {
         process.exit(0);
       }
       if (subcommand === "show" || !subcommand) {
-        const config2 = getConfig();
+        const config = getConfig();
         console.log("\nC-napse Configuration:");
-        console.log(`  Provider: ${config2.provider}`);
-        console.log(`  Model: ${config2.model}`);
-        console.log(`  Ollama Host: ${config2.ollamaHost}`);
+        console.log(`  Provider: ${config.provider}`);
+        console.log(`  Model: ${config.model}`);
+        console.log(`  Ollama Host: ${config.ollamaHost}`);
         console.log(`  API Keys configured:`);
-        console.log(`    - OpenRouter: ${config2.apiKeys.openrouter ? "\u2713" : "\u2717"}`);
-        console.log(`    - Anthropic: ${config2.apiKeys.anthropic ? "\u2713" : "\u2717"}`);
-        console.log(`    - OpenAI: ${config2.apiKeys.openai ? "\u2713" : "\u2717"}`);
+        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);
       }
@@ -493,45 +2028,8 @@ Manual Setup:
       process.exit(0);
     }
     case "init": {
-      const readline = await import("readline");
-      const rl = readline.createInterface({
-        input: process.stdin,
-        output: process.stdout
-      });
-      const question = (q) => new Promise((resolve) => rl.question(q, resolve));
-      console.log("\n\u{1F680} C-napse Setup\n");
-      console.log("Select a provider:");
-      console.log("  1. ollama     - Local AI (free, requires Ollama installed)");
-      console.log("  2. openrouter - OpenRouter API (pay per use, many models)");
-      console.log("  3. anthropic  - Anthropic Claude (pay per use)");
-      console.log("  4. openai     - OpenAI GPT (pay per use)");
-      console.log("");
-      const providerChoice = await question("Enter choice (1-4) [1]: ");
-      const providers = ["ollama", "openrouter", "anthropic", "openai"];
-      const providerIndex = parseInt(providerChoice || "1") - 1;
-      const provider = providers[providerIndex] || "ollama";
-      setProvider(provider);
-      console.log(`\u2713 Provider set to: ${provider}`);
-      if (provider !== "ollama") {
-        const apiKey = await question(`
-Enter your ${provider} API key: `);
-        if (apiKey) {
-          setApiKey(provider, apiKey);
-          console.log(`\u2713 API key saved`);
-        }
-      }
-      const defaultModels = {
-        ollama: "qwen2.5:0.5b",
-        openrouter: "qwen/qwen-2.5-coder-32b-instruct",
-        anthropic: "claude-3-5-sonnet-20241022",
-        openai: "gpt-4o"
-      };
-      const model = await question(`
-Model [${defaultModels[provider]}]: `);
-      setModel(model || defaultModels[provider]);
-      console.log(`\u2713 Model set to: ${model || defaultModels[provider]}`);
-      rl.close();
-      console.log("\n\u2705 Setup complete! Run `cnapse` to start chatting.\n");
+      const { Setup } = await import("./Setup-Q32JPHGP.js");
+      render(/* @__PURE__ */ jsx8(Setup, {}));
       process.exit(0);
     }
     default: {
@@ -539,4 +2037,4 @@ Model [${defaultModels[provider]}]: `);
     }
   }
 }
-render(/* @__PURE__ */ jsx6(App, {}));
+render(/* @__PURE__ */ jsx8(App, {}));