otoro-cli 1.4.0 → 2.0.0

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.4.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",