otoro-cli 1.5.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 }

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/tools.js

@@ -1,173 +1,301 @@
 const fs = require('fs')
 const path = require('path')
-const { execSync } = require('child_process')
-const chalk = require('chalk')
+const { execSync, exec } = require('child_process')
+const os = require('os')
 
-function readFile(filePath) {
-  try {
-    const resolved = path.resolve(filePath)
-    const content = fs.readFileSync(resolved, 'utf8')
-    return { success: true, path: resolved, content, lines: content.split('\n').length }
-  } catch (e) {
-    return { success: false, error: e.message }
-  }
-}
+// ═══════════════════════════════════════════════════
+// OTORO TOOL SYSTEM — Claude Code-style agentic tools
+// ═══════════════════════════════════════════════════
 
-function writeFile(filePath, content) {
-  try {
-    const resolved = path.resolve(filePath)
-    const dir = path.dirname(resolved)
-    fs.mkdirSync(dir, { recursive: true })
-    fs.writeFileSync(resolved, content)
-    return { success: true, path: resolved, lines: content.split('\n').length }
-  } catch (e) {
-    return { success: false, error: e.message }
-  }
-}
+const TOOLS = {
+  // ─── File System ────────────────────────────────
+  read: {
+    name: 'read',
+    description: 'Read a file from the filesystem',
+    parameters: { file_path: 'string', offset: 'number?', limit: 'number?' },
+    execute({ file_path, offset, limit }) {
+      const abs = path.resolve(file_path)
+      if (!fs.existsSync(abs)) return { error: `File not found: ${abs}` }
+      const stat = fs.statSync(abs)
+      if (stat.isDirectory()) return { error: `${abs} is a directory, not a file` }
+      if (stat.size > 5 * 1024 * 1024) return { error: `File too large: ${(stat.size / 1024 / 1024).toFixed(1)}MB` }
+      const content = fs.readFileSync(abs, 'utf8')
+      const lines = content.split('\n')
+      const start = (offset || 1) - 1
+      const end = limit ? start + limit : lines.length
+      const numbered = lines.slice(start, end).map((l, i) => `${start + i + 1}\t${l}`).join('\n')
+      return { content: numbered, total_lines: lines.length, path: abs }
+    }
+  },
 
-function editFile(filePath, oldStr, newStr) {
-  try {
-    const resolved = path.resolve(filePath)
-    let content = fs.readFileSync(resolved, 'utf8')
-    if (!content.includes(oldStr)) {
-      return { success: false, error: 'Old string not found in file' }
+  write: {
+    name: 'write',
+    description: 'Write content to a file (creates or overwrites)',
+    parameters: { file_path: 'string', content: 'string' },
+    execute({ file_path, content }) {
+      const abs = path.resolve(file_path)
+      const dir = path.dirname(abs)
+      if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true })
+      fs.writeFileSync(abs, content, 'utf8')
+      return { success: true, path: abs, bytes: Buffer.byteLength(content) }
     }
-    content = content.replace(oldStr, newStr)
-    fs.writeFileSync(resolved, content)
-    return { success: true, path: resolved }
-  } catch (e) {
-    return { success: false, error: e.message }
-  }
-}
+  },
 
-function listFiles(dir = '.', pattern = '') {
-  try {
-    const resolved = path.resolve(dir)
-    const files = []
-    function walk(d, depth = 0) {
-      if (depth > 4) return
-      const entries = fs.readdirSync(d, { withFileTypes: true })
-      for (const e of entries) {
-        if (e.name.startsWith('.') || e.name === 'node_modules' || e.name === '__pycache__') continue
-        const full = path.join(d, e.name)
-        const rel = path.relative(resolved, full)
-        if (e.isDirectory()) {
-          files.push(rel + '/')
-          walk(full, depth + 1)
-        } else {
-          if (!pattern || rel.includes(pattern) || e.name.match(pattern)) files.push(rel)
-        }
-      }
+  edit: {
+    name: 'edit',
+    description: 'Replace exact string in a file',
+    parameters: { file_path: 'string', old_string: 'string', new_string: 'string' },
+    execute({ file_path, old_string, new_string }) {
+      const abs = path.resolve(file_path)
+      if (!fs.existsSync(abs)) return { error: `File not found: ${abs}` }
+      let content = fs.readFileSync(abs, 'utf8')
+      const count = content.split(old_string).length - 1
+      if (count === 0) return { error: `String not found in ${abs}` }
+      if (count > 1) return { error: `String found ${count} times — be more specific` }
+      content = content.replace(old_string, new_string)
+      fs.writeFileSync(abs, content, 'utf8')
+      return { success: true, path: abs, replacements: 1 }
     }
-    walk(resolved)
-    return { success: true, files: files.slice(0, 200), total: files.length }
-  } catch (e) {
-    return { success: false, error: e.message }
-  }
-}
+  },
 
-function runCommand(cmd, timeout = 15000) {
-  try {
-    const output = execSync(cmd, { encoding: 'utf8', timeout, maxBuffer: 1024 * 1024 })
-    return { success: true, output: output.slice(0, 8000) }
-  } catch (e) {
-    return { success: false, output: (e.stdout || '').slice(0, 4000), error: (e.stderr || e.message).slice(0, 2000) }
-  }
-}
+  // ─── Search ─────────────────────────────────────
+  glob: {
+    name: 'glob',
+    description: 'Find files matching a glob pattern',
+    parameters: { pattern: 'string', directory: 'string?' },
+    execute({ pattern, directory }) {
+      const dir = directory || process.cwd()
+      try {
+        // Use find for glob-like matching
+        const cmd = `find ${JSON.stringify(dir)} -name ${JSON.stringify(pattern)} -type f 2>/dev/null | head -50`
+        const result = execSync(cmd, { encoding: 'utf8', timeout: 10000 }).trim()
+        const files = result ? result.split('\n') : []
+        return { files, count: files.length }
+      } catch {
+        return { files: [], count: 0 }
+      }
+    }
+  },
 
-function searchCode(pattern, dir = '.') {
-  try {
-    const output = execSync(`grep -rn "${pattern}" "${dir}" --include="*.{js,ts,tsx,py,go,rs,java,c,cpp,h,css,html,json,yaml,yml,md,sh}" 2>/dev/null | head -30`, {
-      encoding: 'utf8', timeout: 10000
-    })
-    return { success: true, results: output.trim() }
-  } catch (e) {
-    return { success: true, results: '' }
-  }
-}
+  grep: {
+    name: 'grep',
+    description: 'Search file contents for a pattern (regex supported)',
+    parameters: { pattern: 'string', directory: 'string?', glob: 'string?' },
+    execute({ pattern, directory, glob: fileGlob }) {
+      const dir = directory || process.cwd()
+      try {
+        let cmd = `grep -rn --include="${fileGlob || '*'}" ${JSON.stringify(pattern)} ${JSON.stringify(dir)} 2>/dev/null | head -30`
+        const result = execSync(cmd, { encoding: 'utf8', timeout: 10000 }).trim()
+        const matches = result ? result.split('\n').map(line => {
+          const [fileLine, ...rest] = line.split(':')
+          const parts = fileLine.match(/^(.+):(\d+)$/)
+          return parts ? { file: parts[1], line: parseInt(parts[2]), content: rest.join(':').trim() } : { raw: line }
+        }) : []
+        return { matches, count: matches.length }
+      } catch {
+        return { matches: [], count: 0 }
+      }
+    }
+  },
 
-// Process AI response — extract and apply file operations
-function processToolCalls(response) {
-  const actions = []
+  // ─── Shell ──────────────────────────────────────
+  bash: {
+    name: 'bash',
+    description: 'Execute a bash command',
+    parameters: { command: 'string', timeout: 'number?' },
+    execute({ command, timeout }) {
+      const timeoutMs = Math.min((timeout || 30) * 1000, 120000)
+      try {
+        const result = execSync(command, {
+          encoding: 'utf8',
+          timeout: timeoutMs,
+          maxBuffer: 1024 * 1024,
+          cwd: process.cwd(),
+          env: { ...process.env, TERM: 'dumb' },
+        })
+        return { stdout: result.slice(0, 10000), exit_code: 0 }
+      } catch (e) {
+        return {
+          stdout: (e.stdout || '').slice(0, 5000),
+          stderr: (e.stderr || '').slice(0, 5000),
+          exit_code: e.status || 1,
+        }
+      }
+    }
+  },
 
-  // Extract file writes: ```filename.ext\n...content...\n```
-  const fileBlocks = response.matchAll(/```(\S+\.\w+)\n([\s\S]*?)```/g)
-  for (const match of fileBlocks) {
-    const [, filename, content] = match
-    if (filename && !['python', 'javascript', 'typescript', 'bash', 'json', 'html', 'css', 'sql', 'rust', 'go', 'java', 'c', 'cpp'].includes(filename)) {
-      actions.push({ type: 'write', path: filename, content })
+  // ─── Git ────────────────────────────────────────
+  git_status: {
+    name: 'git_status',
+    description: 'Get git status, diff, and recent log',
+    parameters: {},
+    execute() {
+      try {
+        const status = execSync('git status --short 2>/dev/null', { encoding: 'utf8', timeout: 5000 }).trim()
+        const branch = execSync('git branch --show-current 2>/dev/null', { encoding: 'utf8', timeout: 5000 }).trim()
+        const log = execSync('git log --oneline -5 2>/dev/null', { encoding: 'utf8', timeout: 5000 }).trim()
+        return { branch, status: status || '(clean)', recent_commits: log }
+      } catch {
+        return { error: 'Not a git repository' }
+      }
     }
-  }
+  },
 
-  return actions
-}
+  // ─── Project Context ────────────────────────────
+  project_context: {
+    name: 'project_context',
+    description: 'Scan project structure and detect type',
+    parameters: { directory: 'string?' },
+    execute({ directory }) {
+      const dir = directory || process.cwd()
+      const files = []
+      try {
+        const ls = execSync(`find ${JSON.stringify(dir)} -maxdepth 3 -type f -not -path "*/node_modules/*" -not -path "*/.git/*" -not -path "*/__pycache__/*" -not -path "*/dist/*" -not -path "*/.next/*" 2>/dev/null | head -100`, { encoding: 'utf8', timeout: 10000 })
+        files.push(...ls.trim().split('\n').filter(Boolean))
+      } catch {}
 
-// Platform-aware app launching
-function openApp(appName) {
-  const platform = process.platform
-  try {
-    let cmd
-    if (platform === 'darwin') {
-      cmd = `open -a "${appName}"`
-    } else if (platform === 'win32') {
-      cmd = `start "" "${appName}"`
-    } else {
-      // Linux — try common approaches
-      cmd = `${appName.toLowerCase()} &`
+      // Detect project type
+      const has = (f) => files.some(p => p.endsWith(f))
+      let type = 'unknown'
+      if (has('package.json')) type = has('next.config.js') || has('next.config.ts') ? 'nextjs' : has('tsconfig.json') ? 'typescript' : 'nodejs'
+      else if (has('requirements.txt') || has('setup.py') || has('pyproject.toml')) type = 'python'
+      else if (has('Cargo.toml')) type = 'rust'
+      else if (has('go.mod')) type = 'go'
+      else if (has('Gemfile')) type = 'ruby'
+
+      // Read key files
+      const readme = files.find(f => f.toLowerCase().includes('readme'))
+      const pkg = files.find(f => f.endsWith('package.json') && !f.includes('node_modules'))
+
+      return {
+        type,
+        directory: dir,
+        file_count: files.length,
+        files: files.map(f => path.relative(dir, f)).slice(0, 60),
+        package_json: pkg ? JSON.parse(fs.readFileSync(pkg, 'utf8').slice(0, 2000)) : null,
+      }
     }
-    execSync(cmd, { timeout: 5000, stdio: 'ignore' })
-    return { success: true, app: appName, platform }
-  } catch (e) {
-    return { success: false, error: e.message, platform }
-  }
-}
+  },
 
-function openUrl(url) {
-  const platform = process.platform
-  try {
-    let cmd
-    if (platform === 'darwin') cmd = `open "${url}"`
-    else if (platform === 'win32') cmd = `start "" "${url}"`
-    else cmd = `xdg-open "${url}"`
-    execSync(cmd, { timeout: 5000, stdio: 'ignore' })
-    return { success: true, url }
-  } catch (e) {
-    return { success: false, error: e.message }
-  }
+  // ─── Web Search ─────────────────────────────────
+  web_search: {
+    name: 'web_search',
+    description: 'Search the web for information',
+    parameters: { query: 'string' },
+    async execute({ query }) {
+      const { getConfig } = require('./config')
+      const config = getConfig()
+      const http = require('http')
+      return new Promise((resolve) => {
+        const body = JSON.stringify({ query, max_results: 5 })
+        const url = new URL(`${config.gpu_url}/v1/agent/search`)
+        const req = http.request(url, {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json', 'Authorization': `Bearer ${config.api_key}` },
+          timeout: 10000,
+        }, (res) => {
+          let data = ''
+          res.on('data', c => data += c)
+          res.on('end', () => {
+            try { resolve(JSON.parse(data)) } catch { resolve({ error: 'Bad response' }) }
+          })
+        })
+        req.on('error', () => resolve({ error: 'Search unavailable' }))
+        req.write(body)
+        req.end()
+      })
+    }
+  },
 }
 
-function getSystemInfo() {
-  const os = require('os')
-  return {
-    platform: process.platform,
-    arch: process.arch,
-    hostname: os.hostname(),
-    user: os.userInfo().username,
-    home: os.homedir(),
-    cwd: process.cwd(),
-    node: process.version,
-    cpus: os.cpus().length,
-    memory: Math.round(os.totalmem() / 1024 / 1024 / 1024) + 'GB',
-    freeMemory: Math.round(os.freemem() / 1024 / 1024 / 1024) + 'GB',
-  }
+// ─── Tool definitions for the model ───────────────
+function getToolDefinitions() {
+  return [
+    {
+      type: 'function',
+      function: {
+        name: 'read',
+        description: 'Read a file. Returns numbered lines.',
+        parameters: { type: 'object', properties: { file_path: { type: 'string' }, offset: { type: 'integer' }, limit: { type: 'integer' } }, required: ['file_path'] }
+      }
+    },
+    {
+      type: 'function',
+      function: {
+        name: 'write',
+        description: 'Write/create a file.',
+        parameters: { type: 'object', properties: { file_path: { type: 'string' }, content: { type: 'string' } }, required: ['file_path', 'content'] }
+      }
+    },
+    {
+      type: 'function',
+      function: {
+        name: 'edit',
+        description: 'Replace an exact string in a file. old_string must be unique.',
+        parameters: { type: 'object', properties: { file_path: { type: 'string' }, old_string: { type: 'string' }, new_string: { type: 'string' } }, required: ['file_path', 'old_string', 'new_string'] }
+      }
+    },
+    {
+      type: 'function',
+      function: {
+        name: 'glob',
+        description: 'Find files by name pattern (e.g. "*.tsx", "*.py").',
+        parameters: { type: 'object', properties: { pattern: { type: 'string' }, directory: { type: 'string' } }, required: ['pattern'] }
+      }
+    },
+    {
+      type: 'function',
+      function: {
+        name: 'grep',
+        description: 'Search file contents for a regex pattern.',
+        parameters: { type: 'object', properties: { pattern: { type: 'string' }, directory: { type: 'string' }, glob: { type: 'string' } }, required: ['pattern'] }
+      }
+    },
+    {
+      type: 'function',
+      function: {
+        name: 'bash',
+        description: 'Run a shell command. Use for: npm, git, python, build, test, etc.',
+        parameters: { type: 'object', properties: { command: { type: 'string' }, timeout: { type: 'integer' } }, required: ['command'] }
+      }
+    },
+    {
+      type: 'function',
+      function: {
+        name: 'git_status',
+        description: 'Get git branch, status, and recent commits.',
+        parameters: { type: 'object', properties: {} }
+      }
+    },
+    {
+      type: 'function',
+      function: {
+        name: 'project_context',
+        description: 'Scan project structure: file list, type detection, package.json.',
+        parameters: { type: 'object', properties: { directory: { type: 'string' } } }
+      }
+    },
+    {
+      type: 'function',
+      function: {
+        name: 'web_search',
+        description: 'Search the web for current information.',
+        parameters: { type: 'object', properties: { query: { type: 'string' } }, required: ['query'] }
+      }
+    },
+  ]
 }
 
-function takeScreenshot() {
-  const platform = process.platform
-  const tmpFile = path.join(require('os').tmpdir(), `otoro-screenshot-${Date.now()}.png`)
+// ─── Execute a tool call ──────────────────────────
+async function executeTool(name, args) {
+  const tool = TOOLS[name]
+  if (!tool) return { error: `Unknown tool: ${name}` }
   try {
-    let cmd
-    if (platform === 'darwin') cmd = `screencapture -x "${tmpFile}"`
-    else if (platform === 'win32') cmd = `powershell -command "Add-Type -AssemblyName System.Windows.Forms; [System.Windows.Forms.Screen]::PrimaryScreen | ForEach-Object { $bitmap = New-Object System.Drawing.Bitmap($_.Bounds.Width, $_.Bounds.Height); $graphics = [System.Drawing.Graphics]::FromImage($bitmap); $graphics.CopyFromScreen($_.Bounds.Location, [System.Drawing.Point]::Empty, $_.Bounds.Size); $bitmap.Save('${tmpFile}'); }"`
-    else cmd = `import -window root "${tmpFile}" 2>/dev/null || gnome-screenshot -f "${tmpFile}" 2>/dev/null || scrot "${tmpFile}" 2>/dev/null`
-    execSync(cmd, { timeout: 10000 })
-    if (fs.existsSync(tmpFile)) {
-      return { success: true, path: tmpFile, size: fs.statSync(tmpFile).size }
-    }
-    return { success: false, error: 'Screenshot file not created' }
+    const result = await tool.execute(args)
+    return result
   } catch (e) {
-    return { success: false, error: e.message }
+    return { error: e.message }
   }
 }
 
-module.exports = { readFile, writeFile, editFile, listFiles, runCommand, searchCode, processToolCalls, openApp, openUrl, getSystemInfo, takeScreenshot }
+module.exports = { TOOLS, getToolDefinitions, executeTool }

package/package.json

@@ -1,18 +1,14 @@
 {
   "name": "otoro-cli",
-  "version": "1.5.0",
-  "description": "Otoro AGI — AI coding assistant for your terminal. Code, generate images, execute tasks, and control your projects remotely.",
+  "version": "2.0.0",
+  "description": "Otoro AGI — AI coding assistant for your terminal. Like Claude Code, but open.",
   "main": "index.js",
   "bin": {
     "otoro": "./bin/otoro.js"
   },
-  "keywords": ["ai", "coding", "assistant", "cli", "otoro", "agi", "code-generation", "developer-tools"],
+  "keywords": ["ai", "coding", "assistant", "cli", "otoro", "agi", "code-generation", "developer-tools", "claude-code"],
   "author": "Otoro Team",
   "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/otoroagi/cli"
-  },
   "homepage": "https://otoroagi.com",
   "dependencies": {
     "chalk": "^4.1.2",