otoro-cli 1.4.0 → 2.0.0

package/lib/chat.js

@@ -1,217 +1,133 @@
 const readline = require('readline')
 const chalk = require('chalk')
-const ora = require('ora')
+const { agentLoop } = require('./agent-loop')
+const { getConfig } = require('./config')
 const path = require('path')
-const fs = require('fs')
-const { chatCompletion, executeCode, cveCheck } = require('./api')
-const { readFile, writeFile, editFile, listFiles, runCommand, searchCode } = require('./tools')
+const os = require('os')
 
-const SYSTEM_PROMPT = `You are Otoro — an expert AI coding assistant running in the user's terminal.
+async function interactiveChat() {
+  const config = getConfig()
 
-You have access to the user's project files. The current working directory is: ${process.cwd()}
-
-TOOLS — You can use these by including special tags in your response:
-
-1. READ FILE: <tool:read path="filename"/>
-2. WRITE FILE: <tool:write path="filename">content here</tool:write>
-3. EDIT FILE: <tool:edit path="filename" old="old text" new="new text"/>
-4. RUN COMMAND: <tool:run cmd="command here"/>
-5. SEARCH CODE: <tool:search pattern="regex" dir="."/>
-6. LIST FILES: <tool:ls dir="." pattern=""/>
-
-RULES:
-- Always read files before editing them
-- Show the user what you're doing
-- Write clean, working code
-- Be direct and concise — no fluff
-- When writing files, use <tool:write> tags
-- When you need to see a file, use <tool:read>
-- NEVER guess file contents — always read first
-- Speak English only`
-
-const history = []
-
-async function startChat() {
-  console.log(chalk.cyan.bold('\n  🐙 Otoro AGI'))
-  console.log(chalk.gray(`  Working in: ${process.cwd()}`))
+  if (!config.api_key) {
+    console.log(chalk.red('\n  Not logged in. Run: otoro login\n'))
+    process.exit(1)
+  }
 
-  // Auto-detect project
-  const files = listFiles('.', '')
-  const projectFiles = files.files ? files.files.slice(0, 30) : []
-  console.log(chalk.gray(`  Found ${files.total || 0} files\n`))
-  console.log(chalk.gray('  Type your request. Use /help for commands. Ctrl+C to exit.\n'))
+  console.log('')
+  console.log(chalk.bold('  🐙 Otoro AGI'))
+  console.log(chalk.gray(`  ${process.cwd()}`))
+  console.log(chalk.gray(`  Model: otoro-1 | Tools: read, write, edit, glob, grep, bash, git`))
+  console.log(chalk.gray(`  Type /help for commands, Ctrl+C to exit`))
+  console.log('')
 
   const rl = readline.createInterface({
     input: process.stdin,
     output: process.stdout,
-    prompt: chalk.green('  ❯ '),
+    prompt: chalk.cyan('  ❯ '),
   })
 
+  let conversationHistory = []
+  let compactMode = false
+
   rl.prompt()
 
-  rl.on('line', async (input) => {
-    const line = input.trim()
-    if (!line) { rl.prompt(); return }
+  rl.on('line', async (line) => {
+    const input = line.trim()
+    if (!input) { rl.prompt(); return }
 
-    if (line === '/help') {
-      console.log(chalk.cyan(`
+    // Commands
+    if (input === '/help') {
+      console.log(chalk.gray(`
   Commands:
     /help          Show this help
-    /files         List project files
-    /read <file>   Read a file
-    /run <cmd>     Run a shell command
-    /clear         Clear conversation
+    /clear         Clear conversation history
+    /compact       Toggle compact mode
+    /context       Scan project structure
+    /status        Git status
     /exit          Exit Otoro
-`))
+      `))
       rl.prompt(); return
     }
-    if (line === '/exit' || line === '/quit') { process.exit(0) }
-    if (line === '/clear') { history.length = 0; console.log(chalk.gray('  Conversation cleared.')); rl.prompt(); return }
-    if (line === '/files') {
-      const r = listFiles('.')
-      console.log(chalk.gray(`\n  ${r.files.slice(0, 40).join('\n  ')}\n  ... ${r.total} total\n`))
+    if (input === '/exit' || input === '/quit') { process.exit(0) }
+    if (input === '/clear') {
+      conversationHistory = []
+      console.log(chalk.gray('  Conversation cleared'))
       rl.prompt(); return
     }
-    if (line.startsWith('/read ')) {
-      const f = readFile(line.slice(6).trim())
-      if (f.success) console.log(chalk.gray(`\n${f.content}\n`))
-      else console.log(chalk.red(`  Error: ${f.error}`))
+    if (input === '/compact') {
+      compactMode = !compactMode
+      console.log(chalk.gray(`  Compact mode: ${compactMode ? 'on' : 'off'}`))
       rl.prompt(); return
     }
-    if (line.startsWith('/run ')) {
-      const r = runCommand(line.slice(5).trim())
-      console.log(r.success ? chalk.gray(`\n${r.output}`) : chalk.red(`\n${r.error}`))
+    if (input === '/context') {
+      const { executeTool } = require('./tools')
+      const result = await executeTool('project_context', {})
+      console.log(chalk.cyan(`\n  Project: ${result.type}`))
+      console.log(chalk.gray(`  Files: ${result.file_count}`))
+      if (result.package_json?.name) console.log(chalk.gray(`  Name: ${result.package_json.name}`))
+      console.log('')
       rl.prompt(); return
     }
-
-    // Include file context if user mentions a file
-    let contextMsg = line
-    const fileRefs = line.match(/[\w./\-]+\.\w{1,5}/g) || []
-    for (const ref of fileRefs.slice(0, 3)) {
-      if (fs.existsSync(ref)) {
-        const content = readFile(ref)
-        if (content.success && content.content.length < 10000) {
-          contextMsg += `\n\n[File: ${ref}]\n\`\`\`\n${content.content}\n\`\`\``
-        }
+    if (input === '/status') {
+      const { executeTool } = require('./tools')
+      const result = await executeTool('git_status', {})
+      if (result.error) console.log(chalk.red(`  ${result.error}`))
+      else {
+        console.log(chalk.cyan(`\n  Branch: ${result.branch}`))
+        console.log(chalk.gray(`  ${result.status}`))
+        console.log(chalk.gray(`  ${result.recent_commits}`))
       }
+      console.log('')
+      rl.prompt(); return
     }
 
-    history.push({ role: 'user', content: contextMsg })
-
-    const spinner = ora({ text: chalk.gray('Thinking...'), color: 'cyan' }).start()
+    // Pause readline while processing
+    rl.pause()
+    console.log('')
 
     try {
-      const messages = [{ role: 'system', content: SYSTEM_PROMPT }, ...history.slice(-20)]
-      const result = await chatCompletion(messages)
-      const response = result.choices?.[0]?.message?.content || 'No response'
-      spinner.stop()
+      const { response, iterations, messages } = await agentLoop(input, conversationHistory)
 
-      history.push({ role: 'assistant', content: response })
+      // Update conversation history (keep last 20 messages to manage context)
+      conversationHistory = messages.slice(1) // Remove system prompt
+      if (conversationHistory.length > 40) {
+        conversationHistory = conversationHistory.slice(-30)
+      }
 
-      // Process tool calls in response
-      await processResponse(response)
+      // Print response
+      if (response) {
+        console.log('')
+        // Format markdown-style output
+        const lines = response.split('\n')
+        for (const line of lines) {
+          if (line.startsWith('```')) {
+            console.log(chalk.gray(`  ${line}`))
+          } else if (line.startsWith('#')) {
+            console.log(chalk.bold.white(`  ${line}`))
+          } else if (line.startsWith('- ') || line.startsWith('* ')) {
+            console.log(chalk.white(`  ${line}`))
+          } else {
+            console.log(chalk.white(`  ${line}`))
+          }
+        }
 
-    } catch (e) {
-      spinner.fail(chalk.red(`Error: ${e.message}`))
+        if (iterations > 1) {
+          console.log(chalk.gray(`\n  (${iterations} steps)`))
+        }
+      }
+    } catch (err) {
+      console.log(chalk.red(`  Error: ${err.message}`))
     }
 
+    console.log('')
+    rl.resume()
     rl.prompt()
   })
-}
 
-async function processResponse(response) {
-  // Handle tool calls embedded in response
-  let display = response
-
-  // Process <tool:read> tags
-  const reads = response.matchAll(/<tool:read\s+path="([^"]+)"\s*\/>/g)
-  for (const match of reads) {
-    const result = readFile(match[1])
-    if (result.success) {
-      console.log(chalk.gray(`  📄 Read: ${match[1]} (${result.lines} lines)`))
-      history.push({ role: 'user', content: `[File ${match[1]}]:\n\`\`\`\n${result.content.slice(0, 8000)}\n\`\`\`` })
-    }
-    display = display.replace(match[0], '')
-  }
-
-  // Process <tool:write> tags
-  const writes = response.matchAll(/<tool:write\s+path="([^"]+)">([\s\S]*?)<\/tool:write>/g)
-  for (const match of writes) {
-    const [, filePath, content] = match
-    console.log(chalk.yellow(`  ✏️  Write: ${filePath}`))
-    const result = writeFile(filePath, content.trim())
-    if (result.success) console.log(chalk.green(`  ✓ Written ${result.lines} lines to ${filePath}`))
-    else console.log(chalk.red(`  ✗ ${result.error}`))
-    display = display.replace(match[0], `[Written to ${filePath}]`)
-  }
-
-  // Process <tool:edit> tags
-  const edits = response.matchAll(/<tool:edit\s+path="([^"]+)"\s+old="([^"]*?)"\s+new="([^"]*?)"\s*\/>/g)
-  for (const match of edits) {
-    const [, filePath, oldStr, newStr] = match
-    console.log(chalk.yellow(`  ✏️  Edit: ${filePath}`))
-    const result = editFile(filePath, oldStr, newStr)
-    if (result.success) console.log(chalk.green(`  ✓ Edited ${filePath}`))
-    else console.log(chalk.red(`  ✗ ${result.error}`))
-    display = display.replace(match[0], `[Edited ${filePath}]`)
-  }
-
-  // Process <tool:run> tags
-  const runs = response.matchAll(/<tool:run\s+cmd="([^"]+)"\s*\/>/g)
-  for (const match of runs) {
-    console.log(chalk.yellow(`  ⚡ Run: ${match[1]}`))
-    const result = runCommand(match[1])
-    if (result.success) {
-      console.log(chalk.gray(`  ${result.output.slice(0, 500)}`))
-    } else {
-      console.log(chalk.red(`  ${result.error}`))
-    }
-    display = display.replace(match[0], '')
-  }
-
-  // Process <tool:search> tags
-  const searches = response.matchAll(/<tool:search\s+pattern="([^"]+)"(?:\s+dir="([^"]*)")?\s*\/>/g)
-  for (const match of searches) {
-    const result = searchCode(match[1], match[2] || '.')
-    if (result.results) console.log(chalk.gray(`  🔍 ${result.results.slice(0, 500)}`))
-    display = display.replace(match[0], '')
-  }
-
-  // Process <tool:ls> tags
-  const lsMatches = response.matchAll(/<tool:ls(?:\s+dir="([^"]*)")?(?:\s+pattern="([^"]*)")?\s*\/>/g)
-  for (const match of lsMatches) {
-    const result = listFiles(match[1] || '.', match[2] || '')
-    console.log(chalk.gray(`  📁 ${result.files?.slice(0, 20).join(', ')}`))
-    display = display.replace(match[0], '')
-  }
-
-  // Clean remaining tags and display
-  display = display.replace(/<tool:[^>]*>/g, '').replace(/<\/tool:\w+>/g, '').trim()
-  if (display) {
-    // Format code blocks nicely
-    display = display.replace(/```(\w*)\n([\s\S]*?)```/g, (_, lang, code) => {
-      return chalk.gray(`  ┌─ ${lang || 'code'} ─`) + '\n' +
-        code.split('\n').map(l => chalk.white(`  │ ${l}`)).join('\n') + '\n' +
-        chalk.gray('  └───')
-    })
-    console.log('\n' + display.split('\n').map(l => `  ${l}`).join('\n') + '\n')
-  }
-}
-
-async function askOnce(prompt) {
-  const spinner = ora({ text: chalk.gray('Thinking...'), color: 'cyan' }).start()
-  try {
-    const messages = [
-      { role: 'system', content: SYSTEM_PROMPT },
-      { role: 'user', content: prompt },
-    ]
-    const result = await chatCompletion(messages)
-    const response = result.choices?.[0]?.message?.content || 'No response'
-    spinner.stop()
-    await processResponse(response)
-  } catch (e) {
-    spinner.fail(chalk.red(`Error: ${e.message}`))
-  }
+  rl.on('close', () => {
+    console.log(chalk.gray('\n  Goodbye! 🐙\n'))
+    process.exit(0)
+  })
 }
 
-module.exports = { startChat, askOnce }
+module.exports = { interactiveChat }

package/lib/screen_agent.py

@@ -0,0 +1,102 @@
+#!/usr/bin/env python3
+"""
+Otoro Screen Agent — Python companion for reliable cross-platform computer use.
+Installed alongside the Node.js CLI. Uses pyautogui for mouse/keyboard.
+
+Usage: python screen_agent.py <action> [args...]
+  screenshot              — capture screen, save to /tmp/otoro-screen.png
+  click <x> <y>           — click at coordinates
+  rightclick <x> <y>      — right-click
+  doubleclick <x> <y>     — double-click
+  move <x> <y>            — move mouse
+  type <text>             — type text
+  hotkey <key1> <key2>    — press key combo (e.g. hotkey ctrl s)
+  locate <image_path>     — find image on screen, return coordinates
+  scroll <amount>         — scroll up (positive) or down (negative)
+  info                    — get screen resolution and mouse position
+"""
+import sys
+import json
+
+def main():
+    try:
+        import pyautogui
+        pyautogui.FAILSAFE = True
+        pyautogui.PAUSE = 0.1
+    except ImportError:
+        print(json.dumps({"error": "pyautogui not installed. Run: pip install pyautogui"}))
+        sys.exit(1)
+
+    if len(sys.argv) < 2:
+        print(json.dumps({"error": "No action specified"}))
+        sys.exit(1)
+
+    action = sys.argv[1]
+
+    try:
+        if action == "screenshot":
+            path = "/tmp/otoro-screen.png"
+            img = pyautogui.screenshot()
+            img.save(path)
+            print(json.dumps({"success": True, "path": path,
+                              "size": [img.width, img.height]}))
+
+        elif action == "click":
+            x, y = int(sys.argv[2]), int(sys.argv[3])
+            pyautogui.click(x, y)
+            print(json.dumps({"success": True, "x": x, "y": y}))
+
+        elif action == "rightclick":
+            x, y = int(sys.argv[2]), int(sys.argv[3])
+            pyautogui.rightClick(x, y)
+            print(json.dumps({"success": True, "x": x, "y": y}))
+
+        elif action == "doubleclick":
+            x, y = int(sys.argv[2]), int(sys.argv[3])
+            pyautogui.doubleClick(x, y)
+            print(json.dumps({"success": True, "x": x, "y": y}))
+
+        elif action == "move":
+            x, y = int(sys.argv[2]), int(sys.argv[3])
+            pyautogui.moveTo(x, y)
+            print(json.dumps({"success": True, "x": x, "y": y}))
+
+        elif action == "type":
+            text = " ".join(sys.argv[2:])
+            pyautogui.typewrite(text, interval=0.02)
+            print(json.dumps({"success": True, "typed": len(text)}))
+
+        elif action == "hotkey":
+            keys = sys.argv[2:]
+            pyautogui.hotkey(*keys)
+            print(json.dumps({"success": True, "keys": keys}))
+
+        elif action == "scroll":
+            amount = int(sys.argv[2])
+            pyautogui.scroll(amount)
+            print(json.dumps({"success": True, "scrolled": amount}))
+
+        elif action == "info":
+            size = pyautogui.size()
+            pos = pyautogui.position()
+            print(json.dumps({"screen": [size.width, size.height],
+                              "mouse": [pos.x, pos.y]}))
+
+        elif action == "locate":
+            path = sys.argv[2]
+            loc = pyautogui.locateOnScreen(path, confidence=0.8)
+            if loc:
+                center = pyautogui.center(loc)
+                print(json.dumps({"found": True, "x": center.x, "y": center.y,
+                                  "region": [loc.left, loc.top, loc.width, loc.height]}))
+            else:
+                print(json.dumps({"found": False}))
+
+        else:
+            print(json.dumps({"error": f"Unknown action: {action}"}))
+
+    except Exception as e:
+        print(json.dumps({"error": str(e)}))
+
+if __name__ == "__main__":
+    main()