@projectservan8n/cnapse 0.5.5 → 0.5.7

package/dist/index.js

@@ -534,18 +534,99 @@ function ProviderSelector({ onClose, onSelect }) {
 // src/hooks/useChat.ts
 import { useState as useState3, useCallback, useRef, useEffect as useEffect2 } from "react";
 
+// src/lib/system.ts
+import os from "os";
+import { exec as exec2 } from "child_process";
+import { promisify as promisify2 } from "util";
+var execAsync2 = promisify2(exec2);
+var cachedSystemInfo = null;
+async function getSystemInfo() {
+  if (cachedSystemInfo) return cachedSystemInfo;
+  const platform = os.platform();
+  const cpus = os.cpus();
+  let osName = platform;
+  const osVersion = os.release();
+  if (platform === "win32") {
+    try {
+      const { stdout } = await execAsync2("wmic os get Caption /value", { timeout: 5e3 });
+      const match = stdout.match(/Caption=(.+)/);
+      if (match) osName = match[1].trim();
+    } catch {
+      osName = `Windows ${osVersion}`;
+    }
+  } else if (platform === "darwin") {
+    try {
+      const { stdout } = await execAsync2("sw_vers -productName && sw_vers -productVersion", { timeout: 5e3 });
+      const lines = stdout.trim().split("\n");
+      osName = `${lines[0]} ${lines[1]}`;
+    } catch {
+      osName = `macOS ${osVersion}`;
+    }
+  } else if (platform === "linux") {
+    try {
+      const { stdout } = await execAsync2("cat /etc/os-release | grep PRETTY_NAME", { timeout: 5e3 });
+      const match = stdout.match(/PRETTY_NAME="(.+)"/);
+      if (match) osName = match[1];
+    } catch {
+      osName = `Linux ${osVersion}`;
+    }
+  }
+  cachedSystemInfo = {
+    platform,
+    osName,
+    osVersion,
+    arch: os.arch(),
+    cpuModel: cpus[0]?.model || "Unknown CPU",
+    cpuCores: cpus.length,
+    totalMemoryGB: Math.round(os.totalmem() / 1024 ** 3 * 10) / 10,
+    freeMemoryGB: Math.round(os.freemem() / 1024 ** 3 * 10) / 10,
+    username: os.userInfo().username,
+    hostname: os.hostname(),
+    homeDir: os.homedir(),
+    shell: process.env.SHELL || process.env.COMSPEC || "unknown"
+  };
+  return cachedSystemInfo;
+}
+async function getSystemContext() {
+  const info = await getSystemInfo();
+  return `SYSTEM INFO:
+- OS: ${info.osName} (${info.arch})
+- CPU: ${info.cpuModel} (${info.cpuCores} cores)
+- RAM: ${info.totalMemoryGB}GB total, ${info.freeMemoryGB}GB free
+- User: ${info.username}@${info.hostname}
+- Home: ${info.homeDir}
+- Shell: ${info.shell}`;
+}
+function getCwd() {
+  return process.cwd();
+}
+
 // 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.
+var BASE_PROMPT = `You are C-napse, an AI assistant for PC automation running on the user's desktop.
+You have access to their system and can help with coding, file management, shell commands, and more.
 
 When responding:
 - Be direct and practical
 - Use markdown formatting for code blocks
-- If asked to do something, explain what you'll do first`;
+- If asked to do something, explain what you'll do first
+- Give commands specific to the user's OS (use the system info below)
+- Be aware of the user's current working directory`;
+var systemContextCache = null;
+async function getSystemPrompt() {
+  if (!systemContextCache) {
+    systemContextCache = await getSystemContext();
+  }
+  const cwd = getCwd();
+  return `${BASE_PROMPT}
+
+${systemContextCache}
+- Current directory: ${cwd}`;
+}
 async function chat(messages, systemPrompt) {
   const config = getConfig();
+  const finalPrompt = systemPrompt || await getSystemPrompt();
   const allMessages = [
-    { role: "system", content: systemPrompt || SYSTEM_PROMPT },
+    { role: "system", content: finalPrompt },
     ...messages
   ];
   switch (config.provider) {
@@ -664,134 +745,163 @@ async function chatOpenAI(messages, model) {
   const content = data.choices?.[0]?.message?.content || "";
   return { content, model };
 }
-
-// src/lib/screen.ts
-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 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 execAsync2(`system_profiler SPDisplaysDataType | grep Resolution | head -1`);
-      return `Screen ${stdout.trim()}`;
-    } else {
-      const { stdout } = await execAsync2(`xdpyinfo | grep dimensions | awk '{print $2}'`);
-      return `Screen ${stdout.trim()} captured`;
+async function chatWithVision(messages, screenshotBase64) {
+  const config = getConfig();
+  const systemPrompt = await getSystemPrompt();
+  const visionPrompt = systemPrompt + "\n\nYou can see the user's screen. Describe what you see and help them with their request.";
+  switch (config.provider) {
+    case "openrouter":
+      return chatWithVisionOpenRouter(messages, screenshotBase64, visionPrompt);
+    case "ollama":
+      return chatWithVisionOllama(messages, screenshotBase64, visionPrompt);
+    case "anthropic":
+      return chatWithVisionAnthropic(messages, screenshotBase64, visionPrompt);
+    case "openai":
+      return chatWithVisionOpenAI(messages, screenshotBase64, visionPrompt);
+    default:
+      throw new Error(`Vision not supported for provider: ${config.provider}`);
+  }
+}
+async function chatWithVisionOpenRouter(messages, screenshot, systemPrompt) {
+  const apiKey = getApiKey("openrouter");
+  if (!apiKey) throw new Error("OpenRouter API key not configured");
+  const config = getConfig();
+  let model = config.model;
+  if (!model.includes("gpt-5") && !model.includes("claude") && !model.includes("gemini")) {
+    model = "openai/gpt-5-nano";
+  }
+  const lastUserIdx = messages.length - 1;
+  const visionMessages = messages.map((m, i) => {
+    if (i === lastUserIdx && m.role === "user") {
+      return {
+        role: "user",
+        content: [
+          { type: "text", text: m.content },
+          { type: "image_url", image_url: { url: `data:image/png;base64,${screenshot}` } }
+        ]
+      };
     }
-  } catch {
-    return null;
+    return m;
+  });
+  const response = await fetch("https://openrouter.ai/api/v1/chat/completions", {
+    method: "POST",
+    headers: {
+      "Authorization": `Bearer ${apiKey}`,
+      "Content-Type": "application/json",
+      "HTTP-Referer": config.openrouter.siteUrl,
+      "X-Title": config.openrouter.appName
+    },
+    body: JSON.stringify({
+      model,
+      messages: [{ role: "system", content: systemPrompt }, ...visionMessages],
+      max_tokens: 2048
+    })
+  });
+  if (!response.ok) {
+    const error = await response.text();
+    throw new Error(`OpenRouter vision error: ${response.status} - ${error}`);
   }
+  const data = await response.json();
+  return { content: data.choices?.[0]?.message?.content || "", model };
 }
+async function chatWithVisionOllama(messages, screenshot, systemPrompt) {
+  const config = getConfig();
+  const visionModels = ["llava", "llama3.2-vision", "bakllava"];
+  const model = visionModels.find((m) => config.model.includes(m)) || "llava";
+  const lastUserMsg = messages.filter((m) => m.role === "user").pop();
+  const response = await fetch(`${config.ollamaHost}/api/generate`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      model,
+      prompt: `${systemPrompt}
 
-// 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;
+User: ${lastUserMsg?.content || "What do you see?"}`,
+      images: [screenshot],
+      stream: false
+    })
+  });
+  if (!response.ok) {
+    const error = await response.text();
+    throw new Error(`Ollama vision error: ${error}`);
+  }
+  const data = await response.json();
+  return { content: data.response || "", model };
+}
+async function chatWithVisionAnthropic(messages, screenshot, systemPrompt) {
+  const apiKey = getApiKey("anthropic");
+  if (!apiKey) throw new Error("Anthropic API key not configured");
+  const chatMessages = messages.filter((m) => m.role !== "system");
+  const lastUserIdx = chatMessages.length - 1;
+  const visionMessages = chatMessages.map((m, i) => {
+    if (i === lastUserIdx && m.role === "user") {
+      return {
+        role: "user",
+        content: [
+          { type: "image", source: { type: "base64", media_type: "image/png", data: screenshot } },
+          { type: "text", text: m.content }
+        ]
+      };
     }
-    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);
+    return { role: m.role, content: m.content };
+  });
+  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: 2048,
+      system: systemPrompt,
+      messages: visionMessages
+    })
+  });
+  if (!response.ok) {
+    const error = await response.text();
+    throw new Error(`Anthropic vision error: ${error}`);
+  }
+  const data = await response.json();
+  return { content: data.content?.[0]?.text || "", model: "claude-3-5-sonnet-20241022" };
+}
+async function chatWithVisionOpenAI(messages, screenshot, systemPrompt) {
+  const apiKey = getApiKey("openai");
+  if (!apiKey) throw new Error("OpenAI API key not configured");
+  const lastUserIdx = messages.length - 1;
+  const visionMessages = messages.map((m, i) => {
+    if (i === lastUserIdx && m.role === "user") {
+      return {
+        role: "user",
+        content: [
+          { type: "text", text: m.content },
+          { type: "image_url", image_url: { url: `data:image/png;base64,${screenshot}` } }
+        ]
+      };
     }
-  }, [messages, isProcessing, screenWatch]);
-  const clearMessages = useCallback(() => {
-    setMessages([WELCOME_MESSAGE]);
-    setError(null);
-  }, []);
-  return {
-    messages,
-    isProcessing,
-    error,
-    sendMessage,
-    addSystemMessage,
-    clearMessages
-  };
+    return m;
+  });
+  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-4o",
+      messages: [{ role: "system", content: systemPrompt }, ...visionMessages],
+      max_tokens: 2048
+    })
+  });
+  if (!response.ok) {
+    const error = await response.text();
+    throw new Error(`OpenAI vision error: ${error}`);
+  }
+  const data = await response.json();
+  return { content: data.choices?.[0]?.message?.content || "", model: "gpt-4o" };
 }
 
-// src/hooks/useVision.ts
-import { useState as useState4, useCallback as useCallback2 } from "react";
-
 // src/lib/vision.ts
 async function describeScreen() {
   const screenshot = await captureScreenshot();
@@ -996,7 +1106,98 @@ async function analyzeWithOpenAI(base64Image, prompt) {
   return data.choices?.[0]?.message?.content || "Unable to analyze image";
 }
 
+// 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 screenWatchRef = useRef(screenWatch);
+  useEffect2(() => {
+    screenWatchRef.current = screenWatch;
+  }, [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 }));
+      apiMessages.push({ role: "user", content });
+      let response;
+      if (screenWatchRef.current) {
+        const screenshot = await captureScreenshot();
+        if (screenshot) {
+          response = await chatWithVision(apiMessages, screenshot);
+        } else {
+          response = await chat(apiMessages);
+        }
+      } else {
+        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]);
+  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";
 function useVision() {
   const [isAnalyzing, setIsAnalyzing] = useState4(false);
   const [lastDescription, setLastDescription] = useState4(null);
@@ -1539,8 +1740,8 @@ 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");
+import * as os2 from "os";
+var TASK_MEMORY_FILE = path.join(os2.homedir(), ".cnapse", "task-memory.json");
 function loadTaskMemory() {
   try {
     if (fs.existsSync(TASK_MEMORY_FILE)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@projectservan8n/cnapse",
-  "version": "0.5.5",
+  "version": "0.5.7",
   "description": "Autonomous PC intelligence - AI assistant for desktop automation",
   "type": "module",
   "main": "dist/index.js",

package/src/hooks/useChat.ts

@@ -3,8 +3,8 @@
  */
 
 import { useState, useCallback, useRef, useEffect } from 'react';
-import { chat, Message } from '../lib/api.js';
-import { getScreenDescription } from '../lib/screen.js';
+import { chat, chatWithVision, Message } from '../lib/api.js';
+import { captureScreenshot } from '../lib/vision.js';
 
 export interface ChatMessage {
   id: string;
@@ -34,25 +34,11 @@ export function useChat(screenWatch: boolean = false): UseChatResult {
   const [messages, setMessages] = useState<ChatMessage[]>([WELCOME_MESSAGE]);
   const [isProcessing, setIsProcessing] = useState(false);
   const [error, setError] = useState<string | null>(null);
-  const screenContextRef = useRef<string | null>(null);
+  const screenWatchRef = useRef(screenWatch);
 
-  // Screen watching effect
+  // Keep ref in sync with prop
   useEffect(() => {
-    if (!screenWatch) {
-      screenContextRef.current = null;
-      return;
-    }
-
-    const checkScreen = async () => {
-      const desc = await getScreenDescription();
-      if (desc) {
-        screenContextRef.current = desc;
-      }
-    };
-
-    checkScreen();
-    const interval = setInterval(checkScreen, 5000);
-    return () => clearInterval(interval);
+    screenWatchRef.current = screenWatch;
   }, [screenWatch]);
 
   const addSystemMessage = useCallback((content: string) => {
@@ -100,16 +86,23 @@ export function useChat(screenWatch: boolean = false): UseChatResult {
         .slice(-10)
         .map(m => ({ role: m.role as 'user' | 'assistant', content: m.content }));
 
-      // Add screen context if watching
-      let finalContent = content;
-      if (screenWatch && screenContextRef.current) {
-        finalContent = `[Screen context: ${screenContextRef.current}]\n\n${content}`;
+      apiMessages.push({ role: 'user', content });
+
+      let response;
+
+      // If screen watching is enabled, capture screenshot and use vision API
+      if (screenWatchRef.current) {
+        const screenshot = await captureScreenshot();
+        if (screenshot) {
+          response = await chatWithVision(apiMessages, screenshot);
+        } else {
+          // Fallback to regular chat if screenshot fails
+          response = await chat(apiMessages);
+        }
+      } else {
+        response = await chat(apiMessages);
       }
 
-      apiMessages.push({ role: 'user', content: finalContent });
-
-      const response = await chat(apiMessages);
-
       // Update assistant message
       setMessages(prev =>
         prev.map(m =>
@@ -131,7 +124,7 @@ export function useChat(screenWatch: boolean = false): UseChatResult {
     } finally {
       setIsProcessing(false);
     }
-  }, [messages, isProcessing, screenWatch]);
+  }, [messages, isProcessing]);
 
   const clearMessages = useCallback(() => {
     setMessages([WELCOME_MESSAGE]);

package/src/lib/api.ts

@@ -1,4 +1,5 @@
 import { getConfig, getApiKey } from './config.js';
+import { getSystemContext, getCwd } from './system.js';
 
 export interface Message {
   role: 'system' | 'user' | 'assistant';
@@ -10,19 +11,36 @@ export interface ChatResponse {
   model: string;
 }
 
-const 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.
+const BASE_PROMPT = `You are C-napse, an AI assistant for PC automation running on the user's desktop.
+You have access to their system and can help with coding, file management, shell commands, and more.
 
 When responding:
 - Be direct and practical
 - Use markdown formatting for code blocks
-- If asked to do something, explain what you'll do first`;
+- If asked to do something, explain what you'll do first
+- Give commands specific to the user's OS (use the system info below)
+- Be aware of the user's current working directory`;
+
+// Cache system context to avoid repeated calls
+let systemContextCache: string | null = null;
+
+async function getSystemPrompt(): Promise<string> {
+  if (!systemContextCache) {
+    systemContextCache = await getSystemContext();
+  }
+  const cwd = getCwd();
+  return `${BASE_PROMPT}
+
+${systemContextCache}
+- Current directory: ${cwd}`;
+}
 
 export async function chat(messages: Message[], systemPrompt?: string): Promise<ChatResponse> {
   const config = getConfig();
+  const finalPrompt = systemPrompt || await getSystemPrompt();
 
   const allMessages: Message[] = [
-    { role: 'system', content: systemPrompt || SYSTEM_PROMPT },
+    { role: 'system', content: finalPrompt },
     ...messages,
   ];
 
@@ -166,6 +184,194 @@ async function chatOpenAI(messages: Message[], model: string): Promise<ChatRespo
   return { content, model };
 }
 
+/**
+ * Chat with vision - sends screenshot along with messages
+ */
+export async function chatWithVision(messages: Message[], screenshotBase64: string): Promise<ChatResponse> {
+  const config = getConfig();
+  const systemPrompt = await getSystemPrompt();
+
+  // Add vision context to system prompt
+  const visionPrompt = systemPrompt + '\n\nYou can see the user\'s screen. Describe what you see and help them with their request.';
+
+  switch (config.provider) {
+    case 'openrouter':
+      return chatWithVisionOpenRouter(messages, screenshotBase64, visionPrompt);
+    case 'ollama':
+      return chatWithVisionOllama(messages, screenshotBase64, visionPrompt);
+    case 'anthropic':
+      return chatWithVisionAnthropic(messages, screenshotBase64, visionPrompt);
+    case 'openai':
+      return chatWithVisionOpenAI(messages, screenshotBase64, visionPrompt);
+    default:
+      throw new Error(`Vision not supported for provider: ${config.provider}`);
+  }
+}
+
+async function chatWithVisionOpenRouter(messages: Message[], screenshot: string, systemPrompt: string): Promise<ChatResponse> {
+  const apiKey = getApiKey('openrouter');
+  if (!apiKey) throw new Error('OpenRouter API key not configured');
+
+  const config = getConfig();
+
+  // Use vision-capable model - prefer GPT-5 Nano or Claude
+  let model = config.model;
+  if (!model.includes('gpt-5') && !model.includes('claude') && !model.includes('gemini')) {
+    model = 'openai/gpt-5-nano'; // Default to GPT-5 Nano for vision
+  }
+
+  // Build messages with image in the last user message
+  const lastUserIdx = messages.length - 1;
+  const visionMessages = messages.map((m, i) => {
+    if (i === lastUserIdx && m.role === 'user') {
+      return {
+        role: 'user',
+        content: [
+          { type: 'text', text: m.content },
+          { type: 'image_url', image_url: { url: `data:image/png;base64,${screenshot}` } },
+        ],
+      };
+    }
+    return m;
+  });
+
+  const response = await fetch('https://openrouter.ai/api/v1/chat/completions', {
+    method: 'POST',
+    headers: {
+      'Authorization': `Bearer ${apiKey}`,
+      'Content-Type': 'application/json',
+      'HTTP-Referer': config.openrouter.siteUrl,
+      'X-Title': config.openrouter.appName,
+    },
+    body: JSON.stringify({
+      model,
+      messages: [{ role: 'system', content: systemPrompt }, ...visionMessages],
+      max_tokens: 2048,
+    }),
+  });
+
+  if (!response.ok) {
+    const error = await response.text();
+    throw new Error(`OpenRouter vision error: ${response.status} - ${error}`);
+  }
+
+  const data = await response.json() as any;
+  return { content: data.choices?.[0]?.message?.content || '', model };
+}
+
+async function chatWithVisionOllama(messages: Message[], screenshot: string, systemPrompt: string): Promise<ChatResponse> {
+  const config = getConfig();
+
+  // Use vision model
+  const visionModels = ['llava', 'llama3.2-vision', 'bakllava'];
+  const model = visionModels.find(m => config.model.includes(m)) || 'llava';
+
+  const lastUserMsg = messages.filter(m => m.role === 'user').pop();
+
+  const response = await fetch(`${config.ollamaHost}/api/generate`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({
+      model,
+      prompt: `${systemPrompt}\n\nUser: ${lastUserMsg?.content || 'What do you see?'}`,
+      images: [screenshot],
+      stream: false,
+    }),
+  });
+
+  if (!response.ok) {
+    const error = await response.text();
+    throw new Error(`Ollama vision error: ${error}`);
+  }
+
+  const data = await response.json() as any;
+  return { content: data.response || '', model };
+}
+
+async function chatWithVisionAnthropic(messages: Message[], screenshot: string, systemPrompt: string): Promise<ChatResponse> {
+  const apiKey = getApiKey('anthropic');
+  if (!apiKey) throw new Error('Anthropic API key not configured');
+
+  const chatMessages = messages.filter(m => m.role !== 'system');
+  const lastUserIdx = chatMessages.length - 1;
+
+  const visionMessages = chatMessages.map((m, i) => {
+    if (i === lastUserIdx && m.role === 'user') {
+      return {
+        role: 'user',
+        content: [
+          { type: 'image', source: { type: 'base64', media_type: 'image/png', data: screenshot } },
+          { type: 'text', text: m.content },
+        ],
+      };
+    }
+    return { role: m.role, content: m.content };
+  });
+
+  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: 2048,
+      system: systemPrompt,
+      messages: visionMessages,
+    }),
+  });
+
+  if (!response.ok) {
+    const error = await response.text();
+    throw new Error(`Anthropic vision error: ${error}`);
+  }
+
+  const data = await response.json() as any;
+  return { content: data.content?.[0]?.text || '', model: 'claude-3-5-sonnet-20241022' };
+}
+
+async function chatWithVisionOpenAI(messages: Message[], screenshot: string, systemPrompt: string): Promise<ChatResponse> {
+  const apiKey = getApiKey('openai');
+  if (!apiKey) throw new Error('OpenAI API key not configured');
+
+  const lastUserIdx = messages.length - 1;
+  const visionMessages = messages.map((m, i) => {
+    if (i === lastUserIdx && m.role === 'user') {
+      return {
+        role: 'user',
+        content: [
+          { type: 'text', text: m.content },
+          { type: 'image_url', image_url: { url: `data:image/png;base64,${screenshot}` } },
+        ],
+      };
+    }
+    return m;
+  });
+
+  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-4o',
+      messages: [{ role: 'system', content: systemPrompt }, ...visionMessages],
+      max_tokens: 2048,
+    }),
+  });
+
+  if (!response.ok) {
+    const error = await response.text();
+    throw new Error(`OpenAI vision error: ${error}`);
+  }
+
+  const data = await response.json() as any;
+  return { content: data.choices?.[0]?.message?.content || '', model: 'gpt-4o' };
+}
+
 export async function testConnection(): Promise<boolean> {
   try {
     await chat([{ role: 'user', content: 'hi' }]);

package/src/lib/system.ts

@@ -0,0 +1,105 @@
+/**
+ * System information utilities
+ */
+
+import os from 'os';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+
+const execAsync = promisify(exec);
+
+export interface SystemInfo {
+  platform: string;
+  osName: string;
+  osVersion: string;
+  arch: string;
+  cpuModel: string;
+  cpuCores: number;
+  totalMemoryGB: number;
+  freeMemoryGB: number;
+  username: string;
+  hostname: string;
+  homeDir: string;
+  shell: string;
+}
+
+let cachedSystemInfo: SystemInfo | null = null;
+
+/**
+ * Get detailed system information
+ */
+export async function getSystemInfo(): Promise<SystemInfo> {
+  if (cachedSystemInfo) return cachedSystemInfo;
+
+  const platform = os.platform();
+  const cpus = os.cpus();
+
+  let osName: string = platform;
+  const osVersion = os.release();
+
+  // Get friendly OS name
+  if (platform === 'win32') {
+    try {
+      const { stdout } = await execAsync('wmic os get Caption /value', { timeout: 5000 });
+      const match = stdout.match(/Caption=(.+)/);
+      if (match) osName = match[1].trim();
+    } catch {
+      osName = `Windows ${osVersion}`;
+    }
+  } else if (platform === 'darwin') {
+    try {
+      const { stdout } = await execAsync('sw_vers -productName && sw_vers -productVersion', { timeout: 5000 });
+      const lines = stdout.trim().split('\n');
+      osName = `${lines[0]} ${lines[1]}`;
+    } catch {
+      osName = `macOS ${osVersion}`;
+    }
+  } else if (platform === 'linux') {
+    try {
+      const { stdout } = await execAsync('cat /etc/os-release | grep PRETTY_NAME', { timeout: 5000 });
+      const match = stdout.match(/PRETTY_NAME="(.+)"/);
+      if (match) osName = match[1];
+    } catch {
+      osName = `Linux ${osVersion}`;
+    }
+  }
+
+  cachedSystemInfo = {
+    platform,
+    osName,
+    osVersion,
+    arch: os.arch(),
+    cpuModel: cpus[0]?.model || 'Unknown CPU',
+    cpuCores: cpus.length,
+    totalMemoryGB: Math.round(os.totalmem() / (1024 ** 3) * 10) / 10,
+    freeMemoryGB: Math.round(os.freemem() / (1024 ** 3) * 10) / 10,
+    username: os.userInfo().username,
+    hostname: os.hostname(),
+    homeDir: os.homedir(),
+    shell: process.env.SHELL || process.env.COMSPEC || 'unknown',
+  };
+
+  return cachedSystemInfo;
+}
+
+/**
+ * Get a formatted system context string for AI prompts
+ */
+export async function getSystemContext(): Promise<string> {
+  const info = await getSystemInfo();
+
+  return `SYSTEM INFO:
+- OS: ${info.osName} (${info.arch})
+- CPU: ${info.cpuModel} (${info.cpuCores} cores)
+- RAM: ${info.totalMemoryGB}GB total, ${info.freeMemoryGB}GB free
+- User: ${info.username}@${info.hostname}
+- Home: ${info.homeDir}
+- Shell: ${info.shell}`;
+}
+
+/**
+ * Get current working directory
+ */
+export function getCwd(): string {
+  return process.cwd();
+}