otoro-cli 1.4.0 → 2.0.0

package/bin/otoro.js

@@ -1,153 +1,121 @@
 #!/usr/bin/env node
-const { program } = require('commander')
-const { initConfig, login, logout, isLoggedIn, requireAuth } = require('../lib/config')
-const chalk = require('chalk')
-const pkg = require('../package.json')
 
-program
-  .name('otoro')
-  .description('Otoro AGI — AI coding assistant')
-  .version(pkg.version)
-
-program
-  .command('login')
-  .description('Sign in with your Otoro account')
-  .action(async () => {
-    await login()
-  })
+const { Command } = require('commander')
+const { interactiveChat } = require('../lib/chat')
+const { agentLoop } = require('../lib/agent-loop')
+const { getConfig, login } = require('../lib/config')
+const chalk = require('chalk')
 
-program
-  .command('logout')
-  .description('Sign out and clear credentials')
-  .action(async () => {
-    await logout()
-  })
+const program = new Command()
 
 program
-  .command('init')
-  .description('Initialize Otoro in this project')
-  .action(async () => {
-    await initConfig()
-    console.log(chalk.green('  Run `otoro` to start coding.\n'))
-  })
+  .name('otoro')
+  .description('Otoro AGI — AI coding assistant for your terminal')
+  .version('2.0.0')
 
+// Default — interactive chat (like Claude Code)
 program
-  .command('chat')
-  .alias('c')
-  .description('Start interactive chat')
   .action(async () => {
-    requireAuth()
-    const { startChat } = require('../lib/chat')
-    await startChat()
+    await interactiveChat()
   })
 
+// Ask — one-shot question with agentic tools
 program
-  .command('ask <prompt...>')
-  .description('Ask Otoro a single question')
-  .action(async (prompt) => {
-    requireAuth()
-    const { askOnce } = require('../lib/chat')
-    await askOnce(prompt.join(' '))
+  .command('ask <question...>')
+  .description('Ask Otoro a question (uses tools)')
+  .action(async (words) => {
+    const question = words.join(' ')
+    const { response } = await agentLoop(question)
+    if (response) console.log('\n' + response + '\n')
   })
 
+// Run — full agentic task
 program
   .command('run <task...>')
-  .description('Run a coding task (write + execute + verify)')
-  .action(async (task) => {
-    requireAuth()
-    const { runTask } = require('../lib/task')
-    await runTask(task.join(' '))
+  .description('Run a task (Otoro uses tools autonomously)')
+  .action(async (words) => {
+    const task = words.join(' ')
+    console.log(chalk.cyan('\n  🐙 Running task: ') + chalk.white(task) + '\n')
+    const { response, iterations } = await agentLoop(task)
+    if (response) console.log('\n' + response)
+    console.log(chalk.gray(`\n  Completed in ${iterations} steps\n`))
   })
 
+// Login
 program
-  .command('image <prompt...>')
-  .description('Generate an image')
-  .action(async (prompt) => {
-    requireAuth()
-    const { generateImage } = require('../lib/image')
-    await generateImage(prompt.join(' '))
-  })
-
-program
-  .command('computer <task...>')
-  .alias('use')
-  .description('Computer Use — Otoro sees your screen and controls mouse/keyboard')
-  .action(async (task) => {
-    requireAuth()
-    const { runComputerTask } = require('../lib/computer')
-    await runComputerTask(task.join(' '))
+  .command('login')
+  .description('Login to Otoro')
+  .action(async () => {
+    await login()
   })
 
+// Init — scan project
 program
-  .command('screen')
-  .description('Take a screenshot and describe what Otoro sees')
+  .command('init')
+  .description('Initialize Otoro in current project')
   .action(async () => {
-    requireAuth()
-    const { analyzeScreen } = require('../lib/screen')
-    const chalk = require('chalk')
-    const ora = require('ora')
-    const spinner = ora({ text: chalk.gray('Looking at screen...'), color: 'cyan' }).start()
-    const result = await analyzeScreen()
-    if (result.success) {
-      spinner.succeed(chalk.green('Screen analyzed'))
-      console.log(chalk.cyan('\n  What Otoro sees:\n'))
-      console.log('  ' + result.description.split('\n').join('\n  ') + '\n')
-    } else {
-      spinner.fail(chalk.red(result.error))
-    }
+    const { executeTool } = require('../lib/tools')
+    const result = await executeTool('project_context', {})
+    console.log(chalk.cyan('\n  🐙 Otoro initialized'))
+    console.log(chalk.gray(`  Project type: ${result.type}`))
+    console.log(chalk.gray(`  Files: ${result.file_count}`))
+    console.log(chalk.gray(`  Directory: ${result.directory}`))
+    console.log(chalk.gray('\n  Run `otoro` to start coding\n'))
   })
 
+// Status
 program
-  .command('start')
-  .description('Start Otoro agent daemon — connects to server for remote tasks')
+  .command('status')
+  .description('Show project and agent status')
   .action(async () => {
-    requireAuth()
-    const { startAgent } = require('../lib/agent')
-    await startAgent()
+    const { executeTool } = require('../lib/tools')
+    const git = await executeTool('git_status', {})
+    const proj = await executeTool('project_context', {})
+    console.log(chalk.cyan('\n  🐙 Otoro Status'))
+    console.log(chalk.gray(`  Project: ${proj.type} (${proj.file_count} files)`))
+    if (!git.error) {
+      console.log(chalk.gray(`  Branch: ${git.branch}`))
+      console.log(chalk.gray(`  Git: ${git.status}`))
+    }
+    console.log('')
   })
 
+// Image gen
 program
-  .command('status')
-  .description('Check connected agents and server status')
-  .action(async () => {
-    requireAuth()
-    const config = require('../lib/config').getConfig()
+  .command('image <prompt...>')
+  .description('Generate an image')
+  .action(async (words) => {
+    const prompt = words.join(' ')
+    const config = getConfig()
     const http = require('http')
-    const url = `${config.gpu_url}/v1/agents`
-    http.get(url, { headers: { 'Authorization': `Bearer ${config.api_key}` } }, (res) => {
+    const fs = require('fs')
+
+    console.log(chalk.cyan('\n  🎨 Generating image...'))
+    const body = JSON.stringify({ prompt, size: '1024x1024' })
+    const url = new URL(`${config.gpu_url}/v1/images/generations`)
+    const req = http.request(url, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json', 'Authorization': `Bearer ${config.api_key}` },
+      timeout: 120000,
+    }, (res) => {
       let data = ''
       res.on('data', c => data += c)
       res.on('end', () => {
         try {
-          const d = JSON.parse(data)
-          console.log(chalk.cyan.bold('\n  🐙 Connected Agents:\n'))
-          if (d.agents?.length === 0) {
-            console.log(chalk.gray('  No agents connected. Run `otoro start` on your machine.\n'))
+          const result = JSON.parse(data)
+          if (result.data?.[0]?.b64_json) {
+            const filename = result.data[0].filename || `otoro-${Date.now()}.png`
+            fs.writeFileSync(filename, Buffer.from(result.data[0].b64_json, 'base64'))
+            console.log(chalk.green(`  Saved: ${filename}\n`))
           } else {
-            for (const a of d.agents) {
-              console.log(chalk.green(`  ● ${a.hostname}`) + chalk.gray(` — ${a.cwd} (${a.platform})`))
-            }
-            console.log()
+            console.log(chalk.red('  Failed to generate image\n'))
           }
-        } catch { console.log(chalk.red('  Failed to fetch status')) }
+        } catch { console.log(chalk.red('  Error parsing response\n')) }
       })
-    }).on('error', (e) => console.log(chalk.red(`  Error: ${e.message}`)))
+    })
+    req.on('error', (e) => console.log(chalk.red(`  Error: ${e.message}\n`)))
+    req.write(body)
+    req.end()
   })
 
-// Default: no args → check login then start chat
-if (process.argv.length <= 2) {
-  if (!isLoggedIn()) {
-    console.log(chalk.cyan.bold('\n  🐙 Otoro AGI\n'))
-    console.log(chalk.yellow('  Not logged in. Run:\n'))
-    console.log(chalk.white('    otoro login     — Sign in with your Otoro account'))
-    console.log(chalk.white('    otoro init      — Initialize a project'))
-    console.log(chalk.white('    otoro           — Start coding\n'))
-    console.log(chalk.gray('  Don\'t have an account? Sign up at https://otoroagi.com\n'))
-  } else {
-    requireAuth()
-    const { startChat } = require('../lib/chat')
-    startChat()
-  }
-} else {
-  program.parse()
-}
+program.parse()

package/lib/agent-loop.js

@@ -0,0 +1,230 @@
+const chalk = require('chalk')
+const http = require('http')
+const { getConfig } = require('./config')
+const { getToolDefinitions, executeTool } = require('./tools')
+
+// ═══════════════════════════════════════════════════
+// OTORO AGENTIC LOOP — Claude Code-style tool use
+// ═══════════════════════════════════════════════════
+
+const MAX_ITERATIONS = 25
+const SYSTEM_PROMPT = `You are Otoro, an expert AI coding assistant running in the user's terminal.
+You have access to tools that let you read files, write files, edit files, search code, run commands, and more.
+
+IMPORTANT RULES:
+- Read files before editing them. Never guess file contents.
+- Use glob/grep to find files before reading them.
+- Run tests after making changes to verify they work.
+- Be concise in your responses. Show what you did, not what you plan to do.
+- When you're done with a task, stop calling tools and respond to the user.
+- Never ask the user to do something you can do with tools.
+- Use bash for git, npm, pip, build commands, etc.
+- Always use the edit tool for small changes (not write).
+- Use project_context to understand the project before making changes.
+
+Current directory: ${process.cwd()}
+Platform: ${process.platform}
+`
+
+async function callModel(messages, tools) {
+  const config = getConfig()
+  const body = JSON.stringify({
+    model: 'otoro-1',
+    messages,
+    tools,
+    max_tokens: 8192,
+    temperature: 0.2,
+  })
+
+  return new Promise((resolve, reject) => {
+    const url = new URL(`${config.gpu_url}/v1/chat/completions`)
+    const req = http.request(url, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Authorization': `Bearer ${config.api_key}`,
+      },
+      timeout: 180000,
+    }, (res) => {
+      let data = ''
+      res.on('data', c => data += c)
+      res.on('end', () => {
+        try {
+          const result = JSON.parse(data)
+          if (result.error) reject(new Error(result.error.message || JSON.stringify(result.error)))
+          else resolve(result)
+        } catch (e) {
+          reject(new Error('Invalid response from model'))
+        }
+      })
+    })
+    req.on('error', reject)
+    req.on('timeout', () => { req.destroy(); reject(new Error('Request timed out')) })
+    req.write(body)
+    req.end()
+  })
+}
+
+function formatToolResult(name, result) {
+  const str = typeof result === 'string' ? result : JSON.stringify(result, null, 2)
+  // Truncate very large results
+  if (str.length > 15000) {
+    return str.slice(0, 14000) + '\n\n... (truncated, ' + str.length + ' chars total)'
+  }
+  return str
+}
+
+function printToolCall(name, args) {
+  const icons = {
+    read: '📖', write: '✏️ ', edit: '🔧', glob: '🔍', grep: '🔎',
+    bash: '💻', git_status: '📊', project_context: '📁', web_search: '🌐',
+  }
+  const icon = icons[name] || '🔧'
+
+  switch (name) {
+    case 'read':
+      console.log(chalk.cyan(`  ${icon} Read ${chalk.white(args.file_path)}`))
+      break
+    case 'write':
+      console.log(chalk.green(`  ${icon} Write ${chalk.white(args.file_path)} (${args.content?.length || 0} chars)`))
+      break
+    case 'edit':
+      console.log(chalk.yellow(`  ${icon} Edit ${chalk.white(args.file_path)}`))
+      break
+    case 'glob':
+      console.log(chalk.blue(`  ${icon} Glob ${chalk.white(args.pattern)} ${args.directory ? 'in ' + args.directory : ''}`))
+      break
+    case 'grep':
+      console.log(chalk.blue(`  ${icon} Grep ${chalk.white(args.pattern)} ${args.glob ? '(' + args.glob + ')' : ''}`))
+      break
+    case 'bash':
+      const cmd = args.command.length > 80 ? args.command.slice(0, 77) + '...' : args.command
+      console.log(chalk.magenta(`  ${icon} ${chalk.white(cmd)}`))
+      break
+    case 'git_status':
+      console.log(chalk.cyan(`  ${icon} Git status`))
+      break
+    case 'project_context':
+      console.log(chalk.cyan(`  ${icon} Scanning project`))
+      break
+    case 'web_search':
+      console.log(chalk.blue(`  ${icon} Search: ${chalk.white(args.query)}`))
+      break
+    default:
+      console.log(chalk.gray(`  ${icon} ${name}`))
+  }
+}
+
+async function agentLoop(userMessage, conversationHistory = []) {
+  const tools = getToolDefinitions()
+  const messages = [
+    { role: 'system', content: SYSTEM_PROMPT },
+    ...conversationHistory,
+    { role: 'user', content: userMessage },
+  ]
+
+  let iteration = 0
+  let finalResponse = ''
+
+  while (iteration < MAX_ITERATIONS) {
+    iteration++
+
+    try {
+      const result = await callModel(messages, tools)
+      const choice = result.choices?.[0]
+
+      if (!choice) {
+        console.log(chalk.red('  No response from model'))
+        break
+      }
+
+      const message = choice.message
+
+      // Check for tool calls
+      if (message.tool_calls && message.tool_calls.length > 0) {
+        // Add assistant message with tool calls to history
+        messages.push({
+          role: 'assistant',
+          content: message.content || null,
+          tool_calls: message.tool_calls,
+        })
+
+        // Print any text content the model included
+        if (message.content) {
+          console.log(chalk.white(message.content))
+        }
+
+        // Execute each tool call
+        for (const tc of message.tool_calls) {
+          const toolName = tc.function.name
+          let toolArgs = {}
+          try {
+            toolArgs = JSON.parse(tc.function.arguments || '{}')
+          } catch {
+            toolArgs = {}
+          }
+
+          // Print tool call
+          printToolCall(toolName, toolArgs)
+
+          // Execute
+          const toolResult = await executeTool(toolName, toolArgs)
+          const formatted = formatToolResult(toolName, toolResult)
+
+          // Print errors
+          if (toolResult.error) {
+            console.log(chalk.red(`    Error: ${toolResult.error}`))
+          }
+
+          // Add tool result to messages
+          messages.push({
+            role: 'tool',
+            tool_call_id: tc.id,
+            content: formatted,
+          })
+        }
+
+        // Continue the loop — model will see tool results and decide what to do next
+        continue
+      }
+
+      // No tool calls — model is done, this is the final response
+      finalResponse = message.content || ''
+      break
+
+    } catch (err) {
+      console.log(chalk.red(`  Error: ${err.message}`))
+      // If model doesn't support tool_calls, fall back to plain response
+      if (err.message.includes('tool') || err.message.includes('function')) {
+        // Retry without tools
+        try {
+          const result = await callModel(messages.map(m => {
+            const { tool_calls, ...rest } = m
+            return rest
+          }).filter(m => m.role !== 'tool'), null)
+          finalResponse = result.choices?.[0]?.message?.content || ''
+        } catch {
+          finalResponse = 'Sorry, I encountered an error. Please try again.'
+        }
+      }
+      break
+    }
+  }
+
+  if (iteration >= MAX_ITERATIONS) {
+    console.log(chalk.yellow(`\n  Reached max iterations (${MAX_ITERATIONS})`))
+  }
+
+  // Add final response to conversation history
+  if (finalResponse) {
+    messages.push({ role: 'assistant', content: finalResponse })
+  }
+
+  return {
+    response: finalResponse,
+    iterations: iteration,
+    messages, // Return full history for multi-turn
+  }
+}
+
+module.exports = { agentLoop }