otoro-cli 1.0.0

package/bin/otoro.js

@@ -0,0 +1,93 @@
+#!/usr/bin/env node
+const { program } = require('commander')
+const { startChat } = require('../lib/chat')
+const { runTask } = require('../lib/task')
+const { initConfig, getConfig } = 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('init')
+  .description('Initialize Otoro in this project')
+  .action(async () => {
+    await initConfig()
+    console.log(chalk.green('✓ Otoro initialized. Run `otoro` to start coding.'))
+  })
+
+program
+  .command('chat')
+  .alias('c')
+  .description('Start interactive chat')
+  .action(async () => {
+    await startChat()
+  })
+
+program
+  .command('ask <prompt...>')
+  .description('Ask Otoro a single question')
+  .action(async (prompt) => {
+    const { askOnce } = require('../lib/chat')
+    await askOnce(prompt.join(' '))
+  })
+
+program
+  .command('run <task...>')
+  .description('Run a coding task (write + execute + verify)')
+  .action(async (task) => {
+    await runTask(task.join(' '))
+  })
+
+program
+  .command('image <prompt...>')
+  .description('Generate an image')
+  .action(async (prompt) => {
+    const { generateImage } = require('../lib/image')
+    await generateImage(prompt.join(' '))
+  })
+
+program
+  .command('start')
+  .description('Start Otoro agent daemon — connects to server, waits for remote tasks')
+  .action(async () => {
+    const { startAgent } = require('../lib/agent')
+    await startAgent()
+  })
+
+program
+  .command('status')
+  .description('Check connected agents and server status')
+  .action(async () => {
+    const http = require('http')
+    const config = getConfig()
+    const url = `${config.gpu_url}/v1/agents`
+    http.get(url, { headers: { 'Authorization': `Bearer ${config.api_key}` } }, (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'))
+          } else {
+            for (const a of d.agents) {
+              console.log(chalk.green(`  ● ${a.hostname}`) + chalk.gray(` — ${a.cwd} (${a.platform})`))
+            }
+            console.log()
+          }
+        } catch { console.log(chalk.red('  Failed to fetch status')) }
+      })
+    }).on('error', (e) => console.log(chalk.red(`  Error: ${e.message}`)))
+  })
+
+// Default: start interactive chat
+if (process.argv.length <= 2) {
+  startChat()
+} else {
+  program.parse()
+}

package/lib/agent.js

@@ -0,0 +1,250 @@
+const WebSocket = require('ws')
+const os = require('os')
+const path = require('path')
+const chalk = require('chalk')
+const { getConfig } = require('./config')
+const { readFile, writeFile, editFile, listFiles, runCommand, searchCode } = require('./tools')
+const { chatCompletion } = require('./api')
+
+class OtoroAgent {
+  constructor() {
+    this.config = getConfig()
+    this.agentId = `${os.hostname()}-${process.pid}`
+    this.ws = null
+    this.reconnectDelay = 3000
+    this.running = false
+  }
+
+  async start() {
+    this.running = true
+    console.log(chalk.cyan.bold('\n  🐙 Otoro Agent — Daemon Mode\n'))
+    console.log(chalk.gray(`  Agent ID: ${this.agentId}`))
+    console.log(chalk.gray(`  Hostname: ${os.hostname()}`))
+    console.log(chalk.gray(`  CWD: ${process.cwd()}`))
+    console.log(chalk.gray(`  Server: ${this.config.gpu_url}\n`))
+    console.log(chalk.green('  Agent running. You can now send tasks from otoroagi.com or your phone.'))
+    console.log(chalk.gray('  Press Ctrl+C to stop.\n'))
+
+    this.connect()
+
+    // Keep process alive
+    process.on('SIGINT', () => {
+      console.log(chalk.yellow('\n  Shutting down agent...'))
+      this.running = false
+      if (this.ws) this.ws.close()
+      process.exit(0)
+    })
+  }
+
+  connect() {
+    const wsUrl = this.config.gpu_url.replace('http://', 'ws://').replace('https://', 'wss://') + '/v1/agent/ws'
+    console.log(chalk.gray(`  Connecting to ${wsUrl}...`))
+
+    this.ws = new WebSocket(wsUrl)
+
+    this.ws.on('open', () => {
+      console.log(chalk.green('  ✓ Connected to Otoro server'))
+      // Send auth + agent info
+      this.ws.send(JSON.stringify({
+        api_key: this.config.api_key,
+        agent_id: this.agentId,
+        user_id: this.config.user_id || '',
+        hostname: os.hostname(),
+        cwd: process.cwd(),
+        platform: `${os.platform()} ${os.arch()}`,
+        project: path.basename(process.cwd()),
+      }))
+
+      // Start heartbeat
+      this.heartbeatInterval = setInterval(() => {
+        if (this.ws.readyState === WebSocket.OPEN) {
+          this.ws.send(JSON.stringify({ type: 'heartbeat' }))
+        }
+      }, 30000)
+    })
+
+    this.ws.on('message', async (data) => {
+      try {
+        const msg = JSON.parse(data.toString())
+        if (msg.type === 'task') {
+          await this.handleTask(msg)
+        } else if (msg.type === 'pong') {
+          // heartbeat response
+        }
+      } catch (e) {
+        console.error(chalk.red(`  Error processing message: ${e.message}`))
+      }
+    })
+
+    this.ws.on('close', () => {
+      console.log(chalk.yellow('  Disconnected from server'))
+      clearInterval(this.heartbeatInterval)
+      if (this.running) {
+        console.log(chalk.gray(`  Reconnecting in ${this.reconnectDelay / 1000}s...`))
+        setTimeout(() => this.connect(), this.reconnectDelay)
+      }
+    })
+
+    this.ws.on('error', (err) => {
+      console.log(chalk.red(`  Connection error: ${err.message}`))
+    })
+  }
+
+  async handleTask(task) {
+    const { task_id, task_type, payload } = task
+    console.log(chalk.cyan(`\n  📥 Task received: [${task_id}] ${task_type}`))
+
+    let result = {}
+
+    try {
+      switch (task_type) {
+        case 'chat':
+        case 'code':
+          result = await this.handleChatTask(payload)
+          break
+        case 'read':
+          result = readFile(payload.path)
+          break
+        case 'write':
+          result = writeFile(payload.path, payload.content)
+          console.log(chalk.green(`  ✓ Written: ${payload.path}`))
+          break
+        case 'edit':
+          result = editFile(payload.path, payload.old, payload.new)
+          console.log(chalk.green(`  ✓ Edited: ${payload.path}`))
+          break
+        case 'run_command':
+          console.log(chalk.yellow(`  ⚡ Running: ${payload.cmd}`))
+          result = runCommand(payload.cmd, payload.timeout || 30000)
+          break
+        case 'list_files':
+          result = listFiles(payload.dir || '.', payload.pattern || '')
+          break
+        case 'search':
+          result = searchCode(payload.pattern, payload.dir || '.')
+          break
+        case 'full_task':
+          result = await this.handleFullTask(payload)
+          break
+        default:
+          result = { error: `Unknown task type: ${task_type}` }
+      }
+    } catch (e) {
+      result = { error: e.message }
+    }
+
+    // Send result back to server
+    this.ws.send(JSON.stringify({
+      type: 'task_result',
+      result: { task_id, ...result },
+    }))
+    console.log(chalk.green(`  ✓ Task [${task_id}] completed`))
+  }
+
+  async handleChatTask(payload) {
+    const { message, context } = payload
+
+    // Gather project context
+    const files = listFiles('.', '')
+    const projectContext = `Project: ${path.basename(process.cwd())}
+Working directory: ${process.cwd()}
+Files (${files.total}): ${files.files?.slice(0, 30).join(', ')}`
+
+    const messages = [
+      { role: 'system', content: `You are Otoro running as a local agent on the user's machine.
+You have FULL access to their project files. Working directory: ${process.cwd()}
+
+Available tools (use XML tags in your response):
+- <tool:read path="file"/> — read a file
+- <tool:write path="file">content</tool:write> — write/create a file
+- <tool:edit path="file" old="old text" new="new text"/> — edit a file
+- <tool:run cmd="command"/> — run a shell command
+- <tool:search pattern="regex"/> — search code
+
+Project context:
+${projectContext}
+
+Be direct. Execute tasks immediately. Don't ask for permission — just do it.` },
+      ...(context || []),
+      { role: 'user', content: message },
+    ]
+
+    const result = await chatCompletion(messages, { max_tokens: 8192 })
+    const response = result.choices?.[0]?.message?.content || ''
+
+    // Process tool calls in the response
+    const toolResults = await this.processTools(response)
+
+    return {
+      response,
+      tool_results: toolResults,
+    }
+  }
+
+  async handleFullTask(payload) {
+    // Multi-step AGI task — AI plans, executes, verifies
+    const { task, max_iterations = 5 } = payload
+    const steps = []
+    let context = []
+
+    for (let i = 0; i < max_iterations; i++) {
+      const stepMsg = i === 0 ? task : 'Continue with the next step. If done, say "TASK COMPLETE".'
+      const result = await this.handleChatTask({ message: stepMsg, context })
+
+      steps.push({ step: i + 1, response: result.response, tools: result.tool_results })
+      context.push({ role: 'user', content: stepMsg })
+      context.push({ role: 'assistant', content: result.response })
+
+      if (result.response.includes('TASK COMPLETE')) break
+    }
+
+    return { steps, total_steps: steps.length }
+  }
+
+  async processTools(response) {
+    const results = []
+
+    // Process <tool:read>
+    for (const match of response.matchAll(/<tool:read\s+path="([^"]+)"\s*\/>/g)) {
+      const r = readFile(match[1])
+      results.push({ type: 'read', path: match[1], ...r })
+      if (r.success) console.log(chalk.gray(`  📄 Read: ${match[1]}`))
+    }
+
+    // Process <tool:write>
+    for (const match of response.matchAll(/<tool:write\s+path="([^"]+)">([\s\S]*?)<\/tool:write>/g)) {
+      const r = writeFile(match[1], match[2].trim())
+      results.push({ type: 'write', path: match[1], ...r })
+      if (r.success) console.log(chalk.green(`  ✏️  Written: ${match[1]}`))
+    }
+
+    // Process <tool:edit>
+    for (const match of response.matchAll(/<tool:edit\s+path="([^"]+)"\s+old="([^"]*?)"\s+new="([^"]*?)"\s*\/>/g)) {
+      const r = editFile(match[1], match[2], match[3])
+      results.push({ type: 'edit', path: match[1], ...r })
+      if (r.success) console.log(chalk.green(`  ✏️  Edited: ${match[1]}`))
+    }
+
+    // Process <tool:run>
+    for (const match of response.matchAll(/<tool:run\s+cmd="([^"]+)"\s*\/>/g)) {
+      console.log(chalk.yellow(`  ⚡ ${match[1]}`))
+      const r = runCommand(match[1])
+      results.push({ type: 'run', cmd: match[1], ...r })
+    }
+
+    // Process <tool:search>
+    for (const match of response.matchAll(/<tool:search\s+pattern="([^"]+)"\s*\/>/g)) {
+      const r = searchCode(match[1])
+      results.push({ type: 'search', pattern: match[1], ...r })
+    }
+
+    return results
+  }
+}
+
+async function startAgent() {
+  const agent = new OtoroAgent()
+  await agent.start()
+}
+
+module.exports = { startAgent }

package/lib/api.js

@@ -0,0 +1,64 @@
+const https = require('https')
+const http = require('http')
+const { getConfig } = require('./config')
+
+async function chatCompletion(messages, options = {}) {
+  const config = getConfig()
+  const url = new URL(`${config.gpu_url}/v1/chat/completions`)
+  const body = JSON.stringify({
+    model: options.model || config.model || 'qwen-coder',
+    messages,
+    max_tokens: options.max_tokens || 8192,
+    temperature: options.temperature || 0.3,
+    stream: false,
+  })
+  return makeRequest(url, body, config.api_key)
+}
+
+async function executeCode(code, language = 'python') {
+  const config = getConfig()
+  const url = new URL(`${config.gpu_url}/v1/agent/execute`)
+  const body = JSON.stringify({ code, language })
+  return makeRequest(url, body, config.api_key)
+}
+
+async function searchWeb(query) {
+  const config = getConfig()
+  const url = new URL(`${config.gpu_url}/v1/agent/search`)
+  const body = JSON.stringify({ query, max_results: 5 })
+  return makeRequest(url, body, config.api_key)
+}
+
+async function cveCheck(code, language = '') {
+  const config = getConfig()
+  const url = new URL(`${config.gpu_url}/v1/security/cve-check`)
+  const body = JSON.stringify({ code, language })
+  return makeRequest(url, body, config.api_key)
+}
+
+function makeRequest(url, body, apiKey) {
+  return new Promise((resolve, reject) => {
+    const mod = url.protocol === 'https:' ? https : http
+    const req = mod.request(url, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Authorization': `Bearer ${apiKey}`,
+      },
+      timeout: 180000,
+    }, (res) => {
+      let data = ''
+      res.on('data', chunk => data += chunk)
+      res.on('end', () => {
+        try { resolve(JSON.parse(data)) }
+        catch { reject(new Error(`Non-JSON response: ${data.slice(0, 200)}`)) }
+      })
+    })
+    req.on('error', reject)
+    req.on('timeout', () => { req.destroy(); reject(new Error('Request timed out')) })
+    req.write(body)
+    req.end()
+  })
+}
+
+module.exports = { chatCompletion, executeCode, searchWeb, cveCheck }

package/lib/chat.js

@@ -0,0 +1,217 @@
+const readline = require('readline')
+const chalk = require('chalk')
+const ora = require('ora')
+const path = require('path')
+const fs = require('fs')
+const { chatCompletion, executeCode, cveCheck } = require('./api')
+const { readFile, writeFile, editFile, listFiles, runCommand, searchCode } = require('./tools')
+
+const SYSTEM_PROMPT = `You are Otoro — an expert AI coding assistant running in the user's terminal.
+
+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()}`))
+
+  // 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'))
+
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    prompt: chalk.green('  ❯ '),
+  })
+
+  rl.prompt()
+
+  rl.on('line', async (input) => {
+    const line = input.trim()
+    if (!line) { rl.prompt(); return }
+
+    if (line === '/help') {
+      console.log(chalk.cyan(`
+  Commands:
+    /help          Show this help
+    /files         List project files
+    /read <file>   Read a file
+    /run <cmd>     Run a shell command
+    /clear         Clear conversation
+    /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`))
+      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}`))
+      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}`))
+      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\`\`\``
+        }
+      }
+    }
+
+    history.push({ role: 'user', content: contextMsg })
+
+    const spinner = ora({ text: chalk.gray('Thinking...'), color: 'cyan' }).start()
+
+    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()
+
+      history.push({ role: 'assistant', content: response })
+
+      // Process tool calls in response
+      await processResponse(response)
+
+    } catch (e) {
+      spinner.fail(chalk.red(`Error: ${e.message}`))
+    }
+
+    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}`))
+  }
+}
+
+module.exports = { startChat, askOnce }

package/lib/config.js

@@ -0,0 +1,54 @@
+const fs = require('fs')
+const path = require('path')
+const os = require('os')
+const chalk = require('chalk')
+const readline = require('readline')
+
+const CONFIG_DIR = path.join(os.homedir(), '.otoro')
+const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json')
+const PROJECT_FILE = '.otoro.json'
+
+const DEFAULT_CONFIG = {
+  api_url: 'https://otoroagi.com/api/otoro',
+  gpu_url: 'http://100.124.135.21:8000',
+  api_key: 'otoro-secret',
+  model: 'qwen-coder',
+  theme: 'dark',
+}
+
+function getConfig() {
+  try {
+    if (fs.existsSync(CONFIG_FILE)) {
+      return { ...DEFAULT_CONFIG, ...JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf8')) }
+    }
+  } catch {}
+  return DEFAULT_CONFIG
+}
+
+function saveConfig(config) {
+  fs.mkdirSync(CONFIG_DIR, { recursive: true })
+  fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2))
+}
+
+async function initConfig() {
+  const config = getConfig()
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout })
+  const ask = (q) => new Promise(r => rl.question(q, r))
+
+  console.log(chalk.cyan.bold('\n  🐙 Otoro AGI Setup\n'))
+
+  const url = await ask(chalk.gray(`  GPU URL [${config.gpu_url}]: `))
+  if (url.trim()) config.gpu_url = url.trim()
+
+  const key = await ask(chalk.gray(`  API Key [${config.api_key}]: `))
+  if (key.trim()) config.api_key = key.trim()
+
+  rl.close()
+  saveConfig(config)
+
+  // Create project config
+  const projectConfig = { name: path.basename(process.cwd()), created: new Date().toISOString() }
+  fs.writeFileSync(PROJECT_FILE, JSON.stringify(projectConfig, null, 2))
+}
+
+module.exports = { getConfig, saveConfig, initConfig }

package/lib/image.js

@@ -0,0 +1,50 @@
+const chalk = require('chalk')
+const ora = require('ora')
+const fs = require('fs')
+const http = require('http')
+const { getConfig } = require('./config')
+
+async function generateImage(prompt) {
+  const config = getConfig()
+  console.log(chalk.cyan.bold('\n  🐙 Otoro AGI — Image Generator\n'))
+  console.log(chalk.gray(`  Prompt: ${prompt}\n`))
+
+  const spinner = ora({ text: chalk.gray('Generating image with FLUX.1-dev...'), color: 'cyan' }).start()
+
+  try {
+    const url = new URL(`${config.gpu_url}/v1/images/generations`)
+    const body = JSON.stringify({ prompt, size: '1024x1024', quality: 'standard' })
+
+    const result = await new Promise((resolve, reject) => {
+      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 { resolve(JSON.parse(data)) } catch { reject(new Error('Bad response')) } })
+      })
+      req.on('error', reject)
+      req.write(body)
+      req.end()
+    })
+
+    const filename = result.data?.[0]?.filename
+    const elapsed = result.elapsed_seconds
+    spinner.succeed(chalk.green(`Generated in ${elapsed}s`))
+
+    if (filename) {
+      // Save locally
+      const localPath = `./${filename}`
+      const b64 = result.data[0].b64_json
+      fs.writeFileSync(localPath, Buffer.from(b64, 'base64'))
+      console.log(chalk.green(`  ✓ Saved to ${localPath}`))
+      console.log(chalk.gray(`  URL: https://otoroagi.com/api/otoro/images/${filename}\n`))
+    }
+  } catch (e) {
+    spinner.fail(chalk.red(`Error: ${e.message}`))
+  }
+}
+
+module.exports = { generateImage }

package/lib/task.js

@@ -0,0 +1,61 @@
+const chalk = require('chalk')
+const ora = require('ora')
+const { chatCompletion, executeCode, cveCheck } = require('./api')
+
+async function runTask(task) {
+  console.log(chalk.cyan.bold('\n  🐙 Otoro AGI — Task Runner\n'))
+  console.log(chalk.gray(`  Task: ${task}\n`))
+
+  const spinner = ora({ text: chalk.gray('Writing code...'), color: 'cyan' }).start()
+
+  try {
+    const messages = [
+      { role: 'system', content: 'You are Otoro, an expert coding assistant. Write complete, runnable code. Wrap code in ```python or ```javascript code blocks. Include test cases.' },
+      { role: 'user', content: task },
+    ]
+    const result = await chatCompletion(messages, { max_tokens: 4096 })
+    const response = result.choices?.[0]?.message?.content || ''
+    spinner.succeed(chalk.green('Code generated'))
+
+    console.log(chalk.gray('\n  ' + response.slice(0, 2000).split('\n').join('\n  ') + '\n'))
+
+    // Extract code blocks
+    const blocks = [...response.matchAll(/```(\w*)\n([\s\S]*?)```/g)]
+    if (blocks.length === 0) { console.log(chalk.yellow('  No code blocks found.')); return }
+
+    for (const [, lang, code] of blocks) {
+      const language = (lang || 'python').toLowerCase()
+      if (!['python', 'javascript', 'bash'].includes(language)) continue
+
+      console.log(chalk.cyan(`  ⚡ Executing ${language}...`))
+      const execResult = await executeCode(code, language)
+
+      if (execResult.success) {
+        console.log(chalk.green('  ✓ Success'))
+        if (execResult.stdout) console.log(chalk.gray(`  ${execResult.stdout.split('\n').join('\n  ')}`))
+      } else {
+        console.log(chalk.red(`  ✗ Failed (exit ${execResult.exit_code})`))
+        if (execResult.stderr) console.log(chalk.red(`  ${execResult.stderr.slice(0, 500)}`))
+      }
+
+      // CVE check
+      console.log(chalk.gray('  🔒 Checking for CVE vulnerabilities...'))
+      const cveResult = await cveCheck(code, language)
+      const high = cveResult.high_severity || []
+      const med = cveResult.medium_severity || []
+      if (high.length > 0) {
+        console.log(chalk.red(`  ⚠ ${high.length} high severity CVEs found!`))
+        for (const cve of high) console.log(chalk.red(`    [${cve.score}] ${cve.cve_id}: ${cve.description?.slice(0, 80)}`))
+      } else if (med.length > 0) {
+        console.log(chalk.yellow(`  ⚠ ${med.length} medium severity CVEs`))
+      } else {
+        console.log(chalk.green('  ✓ No known vulnerabilities'))
+      }
+    }
+  } catch (e) {
+    spinner.fail(chalk.red(`Error: ${e.message}`))
+  }
+  console.log()
+}
+
+module.exports = { runTask }

package/lib/tools.js

@@ -0,0 +1,105 @@
+const fs = require('fs')
+const path = require('path')
+const { execSync } = require('child_process')
+const chalk = require('chalk')
+
+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 }
+  }
+}
+
+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 }
+  }
+}
+
+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' }
+    }
+    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)
+        }
+      }
+    }
+    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) }
+  }
+}
+
+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: '' }
+  }
+}
+
+// Process AI response — extract and apply file operations
+function processToolCalls(response) {
+  const actions = []
+
+  // 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 })
+    }
+  }
+
+  return actions
+}
+
+module.exports = { readFile, writeFile, editFile, listFiles, runCommand, searchCode, processToolCalls }

package/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "otoro-cli",
+  "version": "1.0.0",
+  "description": "Otoro AGI — AI coding assistant for your terminal. Code, generate images, execute tasks, and control your projects remotely.",
+  "main": "index.js",
+  "bin": {
+    "otoro": "./bin/otoro.js"
+  },
+  "keywords": ["ai", "coding", "assistant", "cli", "otoro", "agi", "code-generation", "developer-tools"],
+  "author": "Otoro Team",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/otoroagi/cli"
+  },
+  "homepage": "https://otoroagi.com",
+  "dependencies": {
+    "chalk": "^4.1.2",
+    "commander": "^11.0.0",
+    "ora": "^5.4.1",
+    "ws": "^8.18.0"
+  }
+}