@projectservan8n/cnapse 0.2.1 → 0.4.0

package/src/components/TaskProgress.tsx

@@ -0,0 +1,68 @@
+import React from 'react';
+import { Box, Text } from 'ink';
+import type { Task, TaskStep } from '../lib/tasks.js';
+
+interface TaskProgressProps {
+  task: Task;
+}
+
+const statusEmoji: Record<Task['status'], string> = {
+  pending: '⏳',
+  running: '🔄',
+  completed: '✅',
+  failed: '❌',
+};
+
+const stepStatusEmoji: Record<TaskStep['status'], string> = {
+  pending: '○',
+  running: '◐',
+  completed: '●',
+  failed: '✗',
+  skipped: '◌',
+};
+
+const stepStatusColor: Record<TaskStep['status'], string> = {
+  pending: 'gray',
+  running: 'yellow',
+  completed: 'green',
+  failed: 'red',
+  skipped: 'gray',
+};
+
+export function TaskProgress({ task }: TaskProgressProps) {
+  return (
+    <Box flexDirection="column" borderStyle="round" borderColor="cyan" padding={1} marginY={1}>
+      <Box marginBottom={1}>
+        <Text bold>
+          {statusEmoji[task.status]} Task: {task.description}
+        </Text>
+      </Box>
+
+      {task.steps.map((step, index) => (
+        <Box key={step.id} marginLeft={2}>
+          <Text color={stepStatusColor[step.status]}>
+            {stepStatusEmoji[step.status]} {step.description}
+          </Text>
+          {step.result && (
+            <Text color="gray" dimColor> → {step.result}</Text>
+          )}
+          {step.error && (
+            <Text color="red"> (Error: {step.error})</Text>
+          )}
+        </Box>
+      ))}
+
+      {task.status === 'completed' && (
+        <Box marginTop={1}>
+          <Text color="green">✓ Task completed</Text>
+        </Box>
+      )}
+
+      {task.status === 'failed' && (
+        <Box marginTop={1}>
+          <Text color="red">✗ Task failed</Text>
+        </Box>
+      )}
+    </Box>
+  );
+}

package/src/index.tsx

@@ -112,56 +112,9 @@ Manual Setup:
     }
 
     case 'init': {
-      // Interactive setup
-      const readline = await import('readline');
-      const rl = readline.createInterface({
-        input: process.stdin,
-        output: process.stdout,
-      });
-
-      const question = (q: string): Promise<string> =>
-        new Promise((resolve) => rl.question(q, resolve));
-
-      console.log('\n🚀 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'] as const;
-      const providerIndex = parseInt(providerChoice || '1') - 1;
-      const provider = providers[providerIndex] || 'ollama';
-
-      setProvider(provider);
-      console.log(`✓ Provider set to: ${provider}`);
-
-      if (provider !== 'ollama') {
-        const apiKey = await question(`\nEnter your ${provider} API key: `);
-        if (apiKey) {
-          setApiKey(provider as any, apiKey);
-          console.log(`✓ API key saved`);
-        }
-      }
-
-      // Set default model based on provider
-      const defaultModels: Record<string, string> = {
-        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(`\nModel [${defaultModels[provider]}]: `);
-      setModel(model || defaultModels[provider]!);
-      console.log(`✓ Model set to: ${model || defaultModels[provider]}`);
-
-      rl.close();
-
-      console.log('\n✅ Setup complete! Run `cnapse` to start chatting.\n');
+      // Interactive setup with Ink UI
+      const { Setup } = await import('./components/Setup.js');
+      render(<Setup />);
       process.exit(0);
     }
 

package/src/lib/api.ts

@@ -18,11 +18,11 @@ When responding:
 - Use markdown formatting for code blocks
 - If asked to do something, explain what you'll do first`;
 
-export async function chat(messages: Message[]): Promise<ChatResponse> {
+export async function chat(messages: Message[], systemPrompt?: string): Promise<ChatResponse> {
   const config = getConfig();
 
   const allMessages: Message[] = [
-    { role: 'system', content: SYSTEM_PROMPT },
+    { role: 'system', content: systemPrompt || SYSTEM_PROMPT },
     ...messages,
   ];
 

package/src/lib/config.ts

@@ -7,12 +7,17 @@ interface ConfigSchema {
     openrouter?: string;
     anthropic?: string;
     openai?: string;
+    telegram?: string;
   };
   ollamaHost: string;
   openrouter: {
     siteUrl: string;
     appName: string;
   };
+  telegram: {
+    chatId?: number;
+    enabled: boolean;
+  };
 }
 
 const config = new Conf<ConfigSchema>({
@@ -26,6 +31,9 @@ const config = new Conf<ConfigSchema>({
       siteUrl: 'https://github.com/projectservan8n/C-napse',
       appName: 'C-napse',
     },
+    telegram: {
+      enabled: false,
+    },
   },
 });
 
@@ -36,6 +44,7 @@ export function getConfig() {
     apiKeys: config.get('apiKeys'),
     ollamaHost: config.get('ollamaHost'),
     openrouter: config.get('openrouter'),
+    telegram: config.get('telegram'),
   };
 }
 
@@ -57,4 +66,16 @@ export function getApiKey(provider: keyof ConfigSchema['apiKeys']): string | und
   return config.get('apiKeys')[provider];
 }
 
+export function setTelegramChatId(chatId: number) {
+  const telegram = config.get('telegram');
+  telegram.chatId = chatId;
+  config.set('telegram', telegram);
+}
+
+export function setTelegramEnabled(enabled: boolean) {
+  const telegram = config.get('telegram');
+  telegram.enabled = enabled;
+  config.set('telegram', telegram);
+}
+
 export { config };

package/src/lib/screen.ts

@@ -0,0 +1,118 @@
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import { tmpdir } from 'os';
+import { join } from 'path';
+import { readFile, unlink } from 'fs/promises';
+
+const execAsync = promisify(exec);
+
+let lastScreenHash: string | null = null;
+let isCapturing = false;
+
+/**
+ * Capture screenshot and return base64 encoded image
+ * Uses platform-specific tools
+ */
+export async function captureScreen(): Promise<string | null> {
+  if (isCapturing) return null;
+  isCapturing = true;
+
+  const tempFile = join(tmpdir(), `cnapse-screen-${Date.now()}.png`);
+
+  try {
+    const platform = process.platform;
+
+    if (platform === 'win32') {
+      // Windows: Use PowerShell to capture screen
+      await execAsync(`
+        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') {
+      // macOS: Use screencapture
+      await execAsync(`screencapture -x "${tempFile}"`);
+    } else {
+      // Linux: Try various tools
+      try {
+        await execAsync(`gnome-screenshot -f "${tempFile}" 2>/dev/null || scrot "${tempFile}" 2>/dev/null || import -window root "${tempFile}"`);
+      } catch {
+        return null;
+      }
+    }
+
+    // Read the file and convert to base64
+    const imageBuffer = await readFile(tempFile);
+    const base64 = imageBuffer.toString('base64');
+
+    // Clean up
+    await unlink(tempFile).catch(() => {});
+
+    return base64;
+  } catch (error) {
+    return null;
+  } finally {
+    isCapturing = false;
+  }
+}
+
+/**
+ * Simple hash function for change detection
+ */
+function simpleHash(str: string): string {
+  let hash = 0;
+  for (let i = 0; i < str.length; i += 100) {
+    const char = str.charCodeAt(i);
+    hash = ((hash << 5) - hash) + char;
+    hash = hash & hash;
+  }
+  return hash.toString(16);
+}
+
+/**
+ * Check if screen has changed since last capture
+ */
+export async function checkScreenChange(): Promise<{ changed: boolean; image: string | null }> {
+  const image = await captureScreen();
+
+  if (!image) {
+    return { changed: false, image: null };
+  }
+
+  const currentHash = simpleHash(image);
+  const changed = lastScreenHash !== null && lastScreenHash !== currentHash;
+  lastScreenHash = currentHash;
+
+  return { changed, image };
+}
+
+/**
+ * Get screen description for context (simplified - just dimensions)
+ */
+export async function getScreenDescription(): Promise<string | null> {
+  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`;
+    }
+  } catch {
+    return null;
+  }
+}

package/src/lib/tasks.ts

@@ -0,0 +1,268 @@
+/**
+ * Task Automation - Multi-step task sequencing
+ * Parses natural language into actionable steps and executes them
+ */
+
+import { chat, Message } from './api.js';
+import * as computer from '../tools/computer.js';
+import { describeScreen } from './vision.js';
+
+export type TaskStepStatus = 'pending' | 'running' | 'completed' | 'failed' | 'skipped';
+
+export interface TaskStep {
+  id: string;
+  description: string;
+  action: string; // The actual action to perform
+  status: TaskStepStatus;
+  result?: string;
+  error?: string;
+}
+
+export interface Task {
+  id: string;
+  description: string;
+  steps: TaskStep[];
+  status: 'pending' | 'running' | 'completed' | 'failed';
+  createdAt: Date;
+  completedAt?: Date;
+}
+
+export type TaskProgressCallback = (task: Task, step: TaskStep) => void;
+
+/**
+ * Parse natural language task into executable steps
+ */
+export async function parseTask(input: string): Promise<Task> {
+  const systemPrompt = `You are a task parser for PC automation. Convert user requests into specific, executable steps.
+
+Available actions:
+- open_app: Open an application (e.g., "open_app:notepad", "open_app:vscode")
+- type_text: Type text (e.g., "type_text:Hello World")
+- press_key: Press a key (e.g., "press_key:enter", "press_key:escape")
+- key_combo: Key combination (e.g., "key_combo:control+s", "key_combo:alt+f4")
+- click: Click mouse (e.g., "click:left", "click:right")
+- wait: Wait seconds (e.g., "wait:2")
+- focus_window: Focus window by title (e.g., "focus_window:Notepad")
+- screenshot: Take screenshot and describe
+
+Respond ONLY with a JSON array of steps, no other text:
+[
+  { "description": "Human readable step", "action": "action_type:params" },
+  ...
+]
+
+Example input: "open notepad and type hello world"
+Example output:
+[
+  { "description": "Open Notepad", "action": "open_app:notepad" },
+  { "description": "Wait for Notepad to open", "action": "wait:2" },
+  { "description": "Type hello world", "action": "type_text:Hello World" }
+]
+
+Example input: "open vscode, go to folder E:\\Projects, then open terminal"
+Example output:
+[
+  { "description": "Open VS Code", "action": "open_app:code" },
+  { "description": "Wait for VS Code to load", "action": "wait:3" },
+  { "description": "Open folder with Ctrl+K Ctrl+O", "action": "key_combo:control+k" },
+  { "description": "Wait for dialog", "action": "wait:1" },
+  { "description": "Continue folder open", "action": "key_combo:control+o" },
+  { "description": "Wait for folder dialog", "action": "wait:1" },
+  { "description": "Type folder path", "action": "type_text:E:\\\\Projects" },
+  { "description": "Press Enter to open folder", "action": "press_key:enter" },
+  { "description": "Wait for folder to load", "action": "wait:2" },
+  { "description": "Open terminal with Ctrl+\`", "action": "key_combo:control+\`" }
+]`;
+
+  const messages: Message[] = [
+    { role: 'user', content: input }
+  ];
+
+  try {
+    const response = await chat(messages, systemPrompt);
+    const content = response.content || '[]';
+
+    // Extract JSON from response
+    const jsonMatch = content.match(/\[[\s\S]*\]/);
+    if (!jsonMatch) {
+      throw new Error('Failed to parse task steps');
+    }
+
+    const parsedSteps = JSON.parse(jsonMatch[0]) as Array<{ description: string; action: string }>;
+
+    const steps: TaskStep[] = parsedSteps.map((step, index) => ({
+      id: `step-${index + 1}`,
+      description: step.description,
+      action: step.action,
+      status: 'pending' as TaskStepStatus,
+    }));
+
+    return {
+      id: `task-${Date.now()}`,
+      description: input,
+      steps,
+      status: 'pending',
+      createdAt: new Date(),
+    };
+  } catch (error) {
+    // If AI parsing fails, try to create a simple task
+    return {
+      id: `task-${Date.now()}`,
+      description: input,
+      steps: [{
+        id: 'step-1',
+        description: input,
+        action: `chat:${input}`,
+        status: 'pending',
+      }],
+      status: 'pending',
+      createdAt: new Date(),
+    };
+  }
+}
+
+/**
+ * Execute a single task step
+ */
+async function executeStep(step: TaskStep): Promise<void> {
+  const [actionType, ...paramParts] = step.action.split(':');
+  const params = paramParts.join(':'); // Rejoin in case params contain ':'
+
+  switch (actionType) {
+    case 'open_app':
+      // Use Windows Run dialog to open apps
+      await computer.keyCombo(['meta', 'r']);
+      await sleep(500);
+      await computer.typeText(params);
+      await sleep(300);
+      await computer.pressKey('Return');
+      step.result = `Opened ${params}`;
+      break;
+
+    case 'type_text':
+      await computer.typeText(params);
+      step.result = `Typed: ${params}`;
+      break;
+
+    case 'press_key':
+      await computer.pressKey(params);
+      step.result = `Pressed ${params}`;
+      break;
+
+    case 'key_combo':
+      const keys = params.split('+').map(k => k.trim());
+      await computer.keyCombo(keys);
+      step.result = `Pressed ${params}`;
+      break;
+
+    case 'click':
+      const button = (params || 'left') as 'left' | 'right' | 'middle';
+      await computer.clickMouse(button);
+      step.result = `Clicked ${button}`;
+      break;
+
+    case 'wait':
+      const seconds = parseInt(params) || 1;
+      await sleep(seconds * 1000);
+      step.result = `Waited ${seconds}s`;
+      break;
+
+    case 'focus_window':
+      await computer.focusWindow(params);
+      step.result = `Focused window: ${params}`;
+      break;
+
+    case 'screenshot':
+      const vision = await describeScreen();
+      step.result = vision.description;
+      break;
+
+    case 'chat':
+      // This is a fallback - just describe what user wants
+      step.result = `Task noted: ${params}`;
+      break;
+
+    default:
+      throw new Error(`Unknown action: ${actionType}`);
+  }
+}
+
+/**
+ * Execute a complete task with progress callbacks
+ */
+export async function executeTask(
+  task: Task,
+  onProgress?: TaskProgressCallback
+): Promise<Task> {
+  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';
+  }
+  task.completedAt = new Date();
+
+  return task;
+}
+
+/**
+ * Helper sleep function
+ */
+function sleep(ms: number): Promise<void> {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+/**
+ * Format task for display
+ */
+export function formatTask(task: Task): string {
+  const statusEmoji = {
+    pending: '⏳',
+    running: '🔄',
+    completed: '✅',
+    failed: '❌',
+  };
+
+  const stepStatusEmoji = {
+    pending: '○',
+    running: '◐',
+    completed: '●',
+    failed: '✗',
+    skipped: '◌',
+  };
+
+  let output = `${statusEmoji[task.status]} Task: ${task.description}\n\n`;
+
+  for (const step of task.steps) {
+    output += `  ${stepStatusEmoji[step.status]} ${step.description}`;
+    if (step.result) {
+      output += ` → ${step.result}`;
+    }
+    if (step.error) {
+      output += ` (Error: ${step.error})`;
+    }
+    output += '\n';
+  }
+
+  return output;
+}