@projectservan8n/cnapse 0.2.0 → 0.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@projectservan8n/cnapse",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "description": "Autonomous PC intelligence - AI assistant for desktop automation",
   "type": "module",
   "main": "dist/index.js",
@@ -44,7 +44,9 @@
     "node-fetch": "^3.3.2",
     "figlet": "^1.7.0",
     "gradient-string": "^2.0.2",
-    "boxen": "^8.0.1"
+    "boxen": "^8.0.1",
+    "telegraf": "^4.16.3",
+    "screenshot-desktop": "^1.15.0"
   },
   "devDependencies": {
     "@types/node": "^22.0.0",

package/src/agents/coder.ts

@@ -0,0 +1,62 @@
+/**
+ * Coder Agent - Code generation and editing
+ */
+
+import type { Agent } from './types.js';
+import { filesystemTools } from '../tools/filesystem.js';
+import { shellTools } from '../tools/shell.js';
+
+export const coderAgent: Agent = {
+  name: 'coder',
+  description: 'Code generation, editing, debugging, refactoring',
+  systemPrompt: `You are the Coder agent for C-napse. You help users write, edit, and debug code.
+
+Guidelines:
+- Write clean, well-documented code
+- Follow best practices for the language
+- Include error handling
+- Add helpful comments
+- Suggest improvements when appropriate
+
+Available tools:
+- read_file: Read source files
+- write_file: Write/create files
+- list_dir: Browse project structure
+- find_files: Search for files
+- run_command: Execute build/test commands
+
+When writing code:
+1. Understand the requirements first
+2. Check existing code structure
+3. Write modular, reusable code
+4. Test when possible
+5. Explain your implementation
+
+Languages you excel at:
+- JavaScript/TypeScript
+- Python
+- Rust
+- Go
+- HTML/CSS
+- Shell scripts
+- And many more!
+
+Format code blocks with language hints:
+\`\`\`typescript
+// code here
+\`\`\``,
+  tools: [...filesystemTools, ...shellTools.slice(0, 1)], // Include run_command
+  canHandle: (intent: string) => {
+    const lower = intent.toLowerCase();
+    if (
+      lower.includes('code') ||
+      lower.includes('write') ||
+      lower.includes('function') ||
+      lower.includes('debug') ||
+      lower.includes('implement')
+    ) {
+      return 0.9;
+    }
+    return 0.2;
+  },
+};

package/src/agents/computer.ts

@@ -0,0 +1,61 @@
+/**
+ * Computer Control Agent - Mouse, keyboard, and window automation
+ */
+
+export const computerAgent = {
+  name: 'computer',
+  systemPrompt: `You are a computer control specialist. You help users automate their PC by controlling the mouse, keyboard, and windows.
+
+Available tools:
+- moveMouse(x, y) - Move mouse to screen coordinates
+- clickMouse(button) - Click mouse button ('left', 'right', 'middle')
+- doubleClick() - Double-click at current position
+- typeText(text) - Type text using keyboard
+- pressKey(key) - Press a single key (e.g., 'enter', 'escape', 'tab')
+- keyCombo(keys) - Press key combination (e.g., ['control', 'c'] for copy)
+- getActiveWindow() - Get info about the currently focused window
+- listWindows() - List all open windows
+- focusWindow(title) - Focus a window by title (partial match)
+- scrollMouse(amount) - Scroll mouse wheel (positive=up, negative=down)
+
+Guidelines:
+1. Always confirm dangerous actions (like closing windows with unsaved work)
+2. Use keyboard shortcuts when more efficient than mouse clicks
+3. Wait briefly between actions to let the UI update
+4. Report what you see/do at each step
+5. If something fails, try alternative approaches
+
+Common keyboard shortcuts:
+- Copy: control+c
+- Paste: control+v
+- Cut: control+x
+- Undo: control+z
+- Save: control+s
+- Close window: alt+F4
+- Switch windows: alt+Tab
+- Open Start menu: meta (Windows key)
+- Open Run dialog: meta+r
+
+When asked to open an application:
+1. Use meta+r to open Run dialog
+2. Type the application name
+3. Press Enter
+4. Wait for it to open
+5. Report what you see`,
+  tools: [
+    'moveMouse',
+    'clickMouse',
+    'doubleClick',
+    'typeText',
+    'pressKey',
+    'keyCombo',
+    'getActiveWindow',
+    'listWindows',
+    'focusWindow',
+    'scrollMouse',
+    'dragMouse',
+    'getMousePosition',
+  ],
+};
+
+export default computerAgent;

package/src/agents/executor.ts

@@ -0,0 +1,179 @@
+/**
+ * Tool Executor - Executes tool calls from agents
+ */
+
+import type { ToolCall } from './types.js';
+import type { ToolResult } from '../tools/index.js';
+
+// Import all tools
+import * as shell from '../tools/shell.js';
+import * as filesystem from '../tools/filesystem.js';
+import * as clipboard from '../tools/clipboard.js';
+import * as network from '../tools/network.js';
+import * as processTools from '../tools/process.js';
+import * as computer from '../tools/computer.js';
+import * as vision from '../tools/vision.js';
+
+/**
+ * Execute a tool call and return the result
+ */
+export async function executeTool(call: ToolCall): Promise<ToolResult> {
+  const { name, arguments: args } = call;
+
+  try {
+    switch (name) {
+      // Shell tools
+      case 'run_command':
+        return await shell.runCommand(
+          args.cmd as string,
+          args.timeout as number | undefined
+        );
+      case 'get_env':
+        return shell.getEnv(args.var as string);
+      case 'set_env':
+        return shell.setEnv(args.var as string, args.value as string);
+      case 'get_cwd':
+        return shell.getCwd();
+      case 'set_cwd':
+        return shell.setCwd(args.path as string);
+
+      // Filesystem tools
+      case 'read_file':
+        return await filesystem.readFile(args.path as string);
+      case 'write_file':
+        return await filesystem.writeFile(args.path as string, args.content as string);
+      case 'list_dir':
+        return await filesystem.listDir(args.path as string, args.recursive as boolean);
+      case 'copy_file':
+        return await filesystem.copyFile(args.src as string, args.dst as string);
+      case 'move_path':
+        return await filesystem.movePath(args.src as string, args.dst as string);
+      case 'delete_path':
+        return await filesystem.deletePath(args.path as string, args.force as boolean);
+      case 'file_info':
+        return await filesystem.fileInfo(args.path as string);
+      case 'find_files':
+        return await filesystem.findFiles(
+          args.directory as string,
+          args.pattern as string,
+          args.maxResults as number | undefined
+        );
+
+      // Clipboard tools
+      case 'get_clipboard':
+        return await clipboard.getClipboard();
+      case 'set_clipboard':
+        return await clipboard.setClipboard(args.text as string);
+
+      // Network tools
+      case 'check_port':
+        return await network.checkPort(args.port as number);
+      case 'find_available_port':
+        return await network.findAvailablePort(args.start as number, args.end as number);
+      case 'check_connection':
+        return await network.checkConnection(
+          args.host as string,
+          args.port as number,
+          args.timeout as number | undefined
+        );
+      case 'get_local_ip':
+        return network.getLocalIp();
+      case 'list_interfaces':
+        return network.listInterfaces();
+      case 'fetch_url':
+        return await network.fetchUrl(args.url as string);
+
+      // Process tools
+      case 'list_processes':
+        return await processTools.listProcesses();
+      case 'process_info':
+        return await processTools.processInfo(args.pid as number);
+      case 'kill_process':
+        return await processTools.killProcess(args.pid as number, args.force as boolean);
+      case 'find_process':
+        return await processTools.findProcess(args.name as string);
+      case 'system_info':
+        return processTools.systemInfo();
+
+      // Computer control tools
+      case 'moveMouse':
+        return await computer.moveMouse(args.x as number, args.y as number);
+      case 'clickMouse':
+        return await computer.clickMouse(args.button as 'left' | 'right' | 'middle');
+      case 'doubleClick':
+        return await computer.doubleClick();
+      case 'typeText':
+        return await computer.typeText(args.text as string);
+      case 'pressKey':
+        return await computer.pressKey(args.key as string);
+      case 'keyCombo':
+        return await computer.keyCombo(args.keys as string[]);
+      case 'getActiveWindow':
+        return await computer.getActiveWindow();
+      case 'listWindows':
+        return await computer.listWindows();
+      case 'focusWindow':
+        return await computer.focusWindow(args.title as string);
+      case 'scrollMouse':
+        return await computer.scrollMouse(args.amount as number);
+      case 'dragMouse':
+        return await computer.dragMouse(
+          args.startX as number,
+          args.startY as number,
+          args.endX as number,
+          args.endY as number
+        );
+      case 'getMousePosition':
+        return await computer.getMousePosition();
+
+      // Vision tools
+      case 'takeScreenshot':
+        const screenshotResult = await vision.takeScreenshot();
+        return {
+          success: screenshotResult.success,
+          output: screenshotResult.screenshot || '',
+          error: screenshotResult.error,
+        };
+      case 'describeCurrentScreen':
+        const visionResult = await vision.describeCurrentScreen();
+        return {
+          success: visionResult.success,
+          output: visionResult.description || '',
+          error: visionResult.error,
+        };
+
+      default:
+        return { success: false, output: '', error: `Unknown tool: ${name}` };
+    }
+  } catch (error: any) {
+    return { success: false, output: '', error: `Tool error: ${error.message}` };
+  }
+}
+
+/**
+ * Execute multiple tool calls
+ */
+export async function executeTools(calls: ToolCall[]): Promise<Map<string, ToolResult>> {
+  const results = new Map<string, ToolResult>();
+
+  for (const call of calls) {
+    const result = await executeTool(call);
+    results.set(call.id, result);
+  }
+
+  return results;
+}
+
+/**
+ * Format tool results for display
+ */
+export function formatToolResult(call: ToolCall, result: ToolResult): string {
+  const status = result.success ? '✓' : '✗';
+  const header = `[${status} ${call.name}]`;
+
+  if (result.success) {
+    return `${header}\n${result.output}`;
+  } else {
+    return `${header}\nError: ${result.error}`;
+  }
+}

package/src/agents/filer.ts

@@ -0,0 +1,56 @@
+/**
+ * Filer Agent - File operations
+ */
+
+import type { Agent } from './types.js';
+import { filesystemTools } from '../tools/filesystem.js';
+import { clipboardTools } from '../tools/clipboard.js';
+
+export const filerAgent: Agent = {
+  name: 'filer',
+  description: 'File operations - read, write, search, organize',
+  systemPrompt: `You are the Filer agent for C-napse. You help users manage files and directories.
+
+Guidelines:
+- Always confirm before deleting files
+- Show file contents before modifications
+- Use safe operations by default
+- Warn about large operations
+
+Available tools:
+- read_file: Read file contents
+- write_file: Write content to file
+- list_dir: List directory contents
+- copy_file: Copy files
+- move_path: Move/rename files
+- delete_path: Delete files (requires force for directories)
+- file_info: Get file metadata
+- find_files: Search for files by pattern
+- get_clipboard: Get clipboard content
+- set_clipboard: Copy to clipboard
+
+When working with files:
+1. Check if path exists first
+2. Show current contents before editing
+3. Confirm destructive operations
+4. Report results clearly
+
+Common patterns:
+- Find all TypeScript files: find_files(".", "**/*.ts")
+- List project root: list_dir(".")
+- Read config: read_file("package.json")`,
+  tools: [...filesystemTools, ...clipboardTools],
+  canHandle: (intent: string) => {
+    const lower = intent.toLowerCase();
+    if (
+      lower.includes('file') ||
+      lower.includes('folder') ||
+      lower.includes('directory') ||
+      lower.includes('find') ||
+      lower.includes('search')
+    ) {
+      return 0.9;
+    }
+    return 0.2;
+  },
+};

package/src/agents/index.ts

@@ -0,0 +1,12 @@
+/**
+ * Agent system for C-napse
+ *
+ * Each agent is a specialized AI that handles specific types of tasks.
+ */
+
+export * from './types.js';
+export * from './router.js';
+export * from './shell.js';
+export * from './coder.js';
+export * from './filer.js';
+export * from './executor.js';

package/src/agents/router.ts

@@ -0,0 +1,160 @@
+/**
+ * Router Agent - Classifies user intent and dispatches to specialist agents
+ */
+
+import type { Agent } from './types.js';
+
+export type AgentType = 'CODER' | 'FILER' | 'SHELL' | 'MEMORY' | 'COMPUTER' | 'VISION' | 'GENERAL';
+
+export const routerAgent: Agent = {
+  name: 'router',
+  description: 'Classifies user intent and dispatches to the appropriate specialist agent',
+  systemPrompt: `You are a routing agent for C-napse. Your job is to analyze user requests and determine which specialist agent should handle them.
+
+Available agents:
+- CODER: Code generation, editing, debugging, refactoring
+- FILER: File operations (read, write, search, organize)
+- SHELL: Shell commands, system operations, process management
+- MEMORY: Context recall, summarization, search history
+- COMPUTER: Mouse, keyboard, window control, desktop automation
+- VISION: Screen capture, describe what's on screen
+- GENERAL: General conversation and questions
+
+Respond with ONLY the agent name, nothing else.
+
+Examples:
+User: "Write a Python script to sort files by date"
+CODER
+
+User: "Find all PDFs in my Documents folder"
+FILER
+
+User: "What's using port 8080?"
+SHELL
+
+User: "What did we talk about yesterday?"
+MEMORY
+
+User: "How does React work?"
+GENERAL
+
+User: "Click on the Start button"
+COMPUTER
+
+User: "Open notepad and type hello"
+COMPUTER
+
+User: "What's on my screen?"
+VISION
+
+User: "Take a screenshot"
+VISION`,
+  tools: [],
+  canHandle: () => 1.0,
+};
+
+/**
+ * Route query to appropriate agent using keyword matching
+ */
+export function routeByKeywords(query: string): AgentType {
+  const q = query.toLowerCase();
+
+  // Code-related keywords
+  if (
+    q.includes('code') ||
+    q.includes('write') ||
+    q.includes('function') ||
+    q.includes('script') ||
+    q.includes('debug') ||
+    q.includes('fix') ||
+    q.includes('implement') ||
+    q.includes('refactor') ||
+    q.includes('class') ||
+    q.includes('method') ||
+    q.includes('program')
+  ) {
+    return 'CODER';
+  }
+
+  // File-related keywords
+  if (
+    q.includes('file') ||
+    q.includes('folder') ||
+    q.includes('directory') ||
+    q.includes('find') ||
+    q.includes('search') ||
+    q.includes('list') ||
+    q.includes('copy') ||
+    q.includes('move') ||
+    q.includes('delete') ||
+    q.includes('rename') ||
+    q.includes('read')
+  ) {
+    return 'FILER';
+  }
+
+  // Shell-related keywords
+  if (
+    q.includes('run') ||
+    q.includes('execute') ||
+    q.includes('command') ||
+    q.includes('install') ||
+    q.includes('process') ||
+    q.includes('port') ||
+    q.includes('service') ||
+    q.includes('start') ||
+    q.includes('stop') ||
+    q.includes('restart') ||
+    q.includes('terminal') ||
+    q.includes('shell')
+  ) {
+    return 'SHELL';
+  }
+
+  // Memory-related keywords
+  if (
+    q.includes('remember') ||
+    q.includes('recall') ||
+    q.includes('history') ||
+    q.includes('yesterday') ||
+    q.includes('earlier') ||
+    q.includes('before') ||
+    q.includes('last time') ||
+    q.includes('previous')
+  ) {
+    return 'MEMORY';
+  }
+
+  // Computer control keywords
+  if (
+    q.includes('click') ||
+    q.includes('mouse') ||
+    q.includes('type') ||
+    q.includes('keyboard') ||
+    q.includes('window') ||
+    q.includes('open ') ||
+    q.includes('close ') ||
+    q.includes('minimize') ||
+    q.includes('maximize') ||
+    q.includes('press') ||
+    q.includes('scroll') ||
+    q.includes('drag')
+  ) {
+    return 'COMPUTER';
+  }
+
+  // Vision keywords
+  if (
+    q.includes('screen') ||
+    q.includes('screenshot') ||
+    q.includes('see') ||
+    q.includes('look') ||
+    q.includes('what') && q.includes('visible') ||
+    q.includes('describe') && q.includes('screen') ||
+    q.includes('capture')
+  ) {
+    return 'VISION';
+  }
+
+  return 'GENERAL';
+}

package/src/agents/shell.ts

@@ -0,0 +1,67 @@
+/**
+ * Shell Agent - Shell commands and system operations
+ */
+
+import type { Agent } from './types.js';
+import { shellTools } from '../tools/shell.js';
+import { processTools } from '../tools/process.js';
+import { networkTools } from '../tools/network.js';
+
+const os = process.platform;
+const shell = os === 'win32' ? 'PowerShell' : 'bash';
+
+export const shellAgent: Agent = {
+  name: 'shell',
+  description: 'Shell commands, system operations, process management',
+  systemPrompt: `You are the Shell agent for C-napse. You help users with shell commands and system operations.
+
+Current OS: ${os}
+Shell: ${shell}
+
+Guidelines:
+- Generate safe, non-destructive commands by default
+- Always explain what each command does
+- Use portable commands when possible
+- For complex tasks, break into steps
+- Ask for confirmation before destructive operations (rm -rf, format, etc.)
+
+Available tools:
+- run_command: Execute shell command
+- get_env: Get environment variable
+- set_env: Set environment variable
+- get_cwd: Get current directory
+- set_cwd: Change directory
+- list_processes: List running processes
+- process_info: Get process details
+- kill_process: Terminate process
+- find_process: Find process by name
+- system_info: Get system information
+- check_port: Check if port is in use
+- find_available_port: Find free port
+- check_connection: Test connectivity
+- get_local_ip: Get IP addresses
+- fetch_url: Fetch URL content
+
+NEVER run commands that could:
+- Delete system files
+- Modify boot configuration
+- Change user permissions without confirmation
+- Execute downloaded scripts without review
+
+When asked to run a command, use the run_command tool.
+Format your response with the command output clearly displayed.`,
+  tools: [...shellTools, ...processTools, ...networkTools],
+  canHandle: (intent: string) => {
+    const lower = intent.toLowerCase();
+    if (
+      lower.includes('run') ||
+      lower.includes('execute') ||
+      lower.includes('command') ||
+      lower.includes('process') ||
+      lower.includes('port')
+    ) {
+      return 0.9;
+    }
+    return 0.2;
+  },
+};

package/src/agents/types.ts

@@ -0,0 +1,80 @@
+/**
+ * Agent type definitions
+ */
+
+import type { ToolDefinition, ToolResult } from '../tools/index.js';
+
+export type MessageRole = 'system' | 'user' | 'assistant' | 'tool';
+
+export interface AgentMessage {
+  role: MessageRole;
+  content: string;
+  metadata?: Record<string, unknown>;
+}
+
+export interface ToolCall {
+  id: string;
+  name: string;
+  arguments: Record<string, unknown>;
+}
+
+export interface AgentContext {
+  messages: AgentMessage[];
+  tools: ToolDefinition[];
+  memory?: string;
+  cwd?: string;
+}
+
+export interface AgentResponse {
+  content: string;
+  toolCalls: ToolCall[];
+  tokensUsed: number;
+  shouldContinue: boolean;
+}
+
+export interface Agent {
+  name: string;
+  description: string;
+  systemPrompt: string;
+  tools: ToolDefinition[];
+  canHandle(intent: string): number;
+}
+
+// Helper functions
+export function createMessage(role: MessageRole, content: string): AgentMessage {
+  return { role, content };
+}
+
+export function systemMessage(content: string): AgentMessage {
+  return createMessage('system', content);
+}
+
+export function userMessage(content: string): AgentMessage {
+  return createMessage('user', content);
+}
+
+export function assistantMessage(content: string): AgentMessage {
+  return createMessage('assistant', content);
+}
+
+export function toolMessage(content: string): AgentMessage {
+  return createMessage('tool', content);
+}
+
+export function textResponse(content: string): AgentResponse {
+  return {
+    content,
+    toolCalls: [],
+    tokensUsed: 0,
+    shouldContinue: false,
+  };
+}
+
+export function toolCallResponse(content: string, calls: ToolCall[]): AgentResponse {
+  return {
+    content,
+    toolCalls: calls,
+    tokensUsed: 0,
+    shouldContinue: calls.length > 0,
+  };
+}