omni-agent-cli 2.0.0

package/src/providers.js

@@ -0,0 +1,232 @@
+import axios from 'axios';
+import { TOOL_DEFINITIONS } from './tools.js';
+
+// ─── Providers that DON'T support parallel_tool_calls param ──────────────────
+const NO_PARALLEL = new Set([
+  'groq', 'together', 'ionet', 'qwen', 'mistral',
+  'cohere', 'ollama', 'custom', 'deepseek',
+]);
+
+// ─── Providers that DON'T support tools/function-calling at all ───────────────
+const NO_TOOLS = new Set([
+  // add provider keys here if needed
+]);
+
+// ─── Providers that use max_completion_tokens instead of max_tokens ───────────
+const MAX_COMPLETION_TOKENS = new Set(['openai']);
+
+// ─── Models that don't support temperature ────────────────────────────────────
+const NO_TEMPERATURE_MODELS = ['o1', 'o1-mini', 'o1-preview', 'o3', 'o3-mini', 'o4-mini'];
+
+function toOpenAITools(tools) {
+  return tools.map((t) => ({
+    type: 'function',
+    function: { name: t.name, description: t.description, parameters: t.parameters },
+  }));
+}
+
+function toAnthropicTools(tools) {
+  return tools.map((t) => ({
+    name: t.name,
+    description: t.description,
+    input_schema: t.parameters,
+  }));
+}
+
+// ─── Parse detailed error from provider response ──────────────────────────────
+function parseProviderError(err, providerKey) {
+  if (!err.response) {
+    return `Network error: ${err.message}`;
+  }
+  const status = err.response.status;
+  const data   = err.response.data;
+
+  const detail =
+    data?.error?.message ||
+    data?.error?.msg ||
+    data?.message ||
+    data?.detail ||
+    (typeof data === 'string' ? data.slice(0, 200) : null) ||
+    err.message;
+
+  if (status === 400) return `Bad request (400): ${detail}\n  → Check model name, API key format, or tool support for "${providerKey}"`;
+  if (status === 401) return `Unauthorized (401): Invalid API key for "${providerKey}"`;
+  if (status === 403) return `Forbidden (403): ${detail}`;
+  if (status === 404) return `Not found (404): Model or endpoint not found — ${detail}`;
+  if (status === 422) return `Invalid params (422): ${detail}`;
+  if (status === 429) return `Rate limited (429): Too many requests — wait and retry`;
+  if (status === 500) return `Server error (500): Provider side issue — ${detail}`;
+  return `HTTP ${status}: ${detail}`;
+}
+
+// ─── OpenAI-compatible call ───────────────────────────────────────────────────
+async function callOpenAI(messages, config) {
+  const key = config.providerKey || 'custom';
+
+  const headers = {
+    'Content-Type': 'application/json',
+    Authorization: `Bearer ${config.apiKey}`,
+  };
+  if (key === 'openrouter') {
+    headers['HTTP-Referer'] = 'https://github.com/omni-agent';
+    headers['X-Title'] = 'OmniAgent';
+  }
+
+  const noTools = NO_TOOLS.has(key);
+  const noTemp  = NO_TEMPERATURE_MODELS.some(m => config.model?.startsWith(m));
+  const maxKey  = MAX_COMPLETION_TOKENS.has(key) ? 'max_completion_tokens' : 'max_tokens';
+
+  const body = {
+    model: config.model,
+    messages,
+    [maxKey]: config.maxTokens || 8192,
+  };
+
+  // Temperature — skip for reasoning models
+  if (!noTemp) body.temperature = config.temperature ?? 0.3;
+
+  // Tools
+  if (!noTools) {
+    body.tools = toOpenAITools(TOOL_DEFINITIONS);
+    body.tool_choice = 'auto';
+    // Only add parallel_tool_calls for providers that support it
+    if (!NO_PARALLEL.has(key)) {
+      body.parallel_tool_calls = true;
+    }
+  }
+
+  let response;
+  try {
+    response = await axios.post(`${config.baseURL}/chat/completions`, body, {
+      headers,
+      timeout: 120000,
+    });
+  } catch (err) {
+    throw new Error(parseProviderError(err, key));
+  }
+
+  const msg   = response.data.choices?.[0]?.message || {};
+  const usage = response.data.usage || {};
+
+  // Parse tool_calls safely
+  const toolCalls = [];
+  for (const tc of msg.tool_calls || []) {
+    try {
+      toolCalls.push({
+        id:    tc.id || `call_${Date.now()}_${Math.random().toString(36).slice(2)}`,
+        name:  tc.function.name,
+        input: JSON.parse(tc.function.arguments),
+      });
+    } catch {
+      // skip malformed tool call
+    }
+  }
+
+  return {
+    content:   msg.content || '',
+    toolCalls,
+    usage: {
+      inputTokens:  usage.prompt_tokens || 0,
+      outputTokens: usage.completion_tokens || 0,
+    },
+    stopReason: response.data.choices?.[0]?.finish_reason || 'stop',
+  };
+}
+
+// ─── Anthropic call ───────────────────────────────────────────────────────────
+async function callAnthropic(messages, config) {
+  let system = '';
+  const filtered = messages.filter((m) => {
+    if (m.role === 'system') { system = m.content; return false; }
+    return true;
+  });
+
+  const headers = {
+    'Content-Type': 'application/json',
+    'x-api-key': config.apiKey,
+    'anthropic-version': '2023-06-01',
+  };
+
+  const body = {
+    model:      config.model,
+    system,
+    messages:   filtered,
+    tools:      toAnthropicTools(TOOL_DEFINITIONS),
+    max_tokens: config.maxTokens || 8192,
+    temperature: config.temperature ?? 0.3,
+  };
+
+  let response;
+  try {
+    response = await axios.post(`${config.baseURL}/v1/messages`, body, {
+      headers,
+      timeout: 120000,
+    });
+  } catch (err) {
+    throw new Error(parseProviderError(err, 'anthropic'));
+  }
+
+  const data = response.data;
+  let textContent = '';
+  const toolCalls = [];
+
+  for (const block of data.content || []) {
+    if (block.type === 'text')     textContent += block.text;
+    if (block.type === 'tool_use') toolCalls.push({ id: block.id, name: block.name, input: block.input });
+  }
+
+  return {
+    content:   textContent,
+    toolCalls,
+    usage: {
+      inputTokens:  data.usage?.input_tokens  || 0,
+      outputTokens: data.usage?.output_tokens || 0,
+    },
+    stopReason: data.stop_reason,
+  };
+}
+
+// ─── Build messages ────────────────────────────────────────────────────────────
+export function buildToolResultMessage(format, toolCalls, results) {
+  if (format === 'anthropic') {
+    return {
+      role: 'user',
+      content: toolCalls.map((tc, i) => ({
+        type: 'tool_result',
+        tool_use_id: tc.id,
+        content: String(results[i] ?? ''),
+      })),
+    };
+  }
+  // OpenAI: tool messages WITHOUT name field (some providers reject it)
+  return toolCalls.map((tc, i) => ({
+    role:         'tool',
+    tool_call_id: tc.id,
+    content:      String(results[i] ?? ''),
+  }));
+}
+
+export function buildAssistantToolUseMessage(format, response) {
+  if (format === 'anthropic') {
+    const content = [];
+    if (response.content) content.push({ type: 'text', text: response.content });
+    for (const tc of response.toolCalls) {
+      content.push({ type: 'tool_use', id: tc.id, name: tc.name, input: tc.input });
+    }
+    return { role: 'assistant', content };
+  }
+  return {
+    role:       'assistant',
+    content:    response.content || null,
+    tool_calls: response.toolCalls.map((tc) => ({
+      id:       tc.id,
+      type:     'function',
+      function: { name: tc.name, arguments: JSON.stringify(tc.input) },
+    })),
+  };
+}
+
+export async function callProvider(messages, config) {
+  if (config.format === 'anthropic') return callAnthropic(messages, config);
+  return callOpenAI(messages, config);
+}

package/src/stats.js

@@ -0,0 +1,65 @@
+export class SessionStats {
+  constructor() {
+    this.startTime = Date.now();
+    this.messages = { user: 0, assistant: 0 };
+    this.tokens = { input: 0, output: 0 };
+    this.toolCalls = {};
+    this.apiRequests = 0;
+    this.errors = 0;
+  }
+
+  addMessage(role) {
+    this.messages[role] = (this.messages[role] || 0) + 1;
+  }
+
+  addTokens(input, output) {
+    this.tokens.input += input;
+    this.tokens.output += output;
+    this.apiRequests++;
+  }
+
+  addToolCall(toolName) {
+    this.toolCalls[toolName] = (this.toolCalls[toolName] || 0) + 1;
+  }
+
+  addError() {
+    this.errors++;
+  }
+
+  getStats() {
+    const elapsed = Date.now() - this.startTime;
+    const mins = Math.floor(elapsed / 60000);
+    const secs = Math.floor((elapsed % 60000) / 1000);
+    const totalMessages = this.messages.user + this.messages.assistant;
+    const totalTokens = this.tokens.input + this.tokens.output;
+
+    // Cost estimation (rough, per 1M tokens)
+    const INPUT_COST = 3.0;  // $3 per 1M input tokens (rough average)
+    const OUTPUT_COST = 15.0; // $15 per 1M output tokens (rough average)
+    const estimatedCost = (
+      (this.tokens.input / 1_000_000) * INPUT_COST +
+      (this.tokens.output / 1_000_000) * OUTPUT_COST
+    );
+
+    const toolCallsList = Object.entries(this.toolCalls).sort((a, b) => b[1] - a[1]);
+    const totalToolCalls = toolCallsList.reduce((acc, [, v]) => acc + v, 0);
+
+    return {
+      duration: `${mins}m ${secs}s`,
+      durationMs: elapsed,
+      messages: this.messages,
+      totalMessages,
+      tokens: this.tokens,
+      totalTokens,
+      apiRequests: this.apiRequests,
+      toolCalls: this.toolCalls,
+      totalToolCalls,
+      toolCallsList,
+      errors: this.errors,
+      estimatedCost: estimatedCost.toFixed(4),
+      tokensPerRequest: this.apiRequests > 0
+        ? Math.round(totalTokens / this.apiRequests)
+        : 0,
+    };
+  }
+}

package/src/tools.js

@@ -0,0 +1,366 @@
+import {
+  readFileSync, writeFileSync, appendFileSync,
+  unlinkSync, mkdirSync, readdirSync, statSync,
+  copyFileSync, renameSync, existsSync,
+} from 'fs';
+import { execSync } from 'child_process';
+import path from 'path';
+import { glob } from 'glob';
+
+// ─── Tool Definitions (OpenAI format, converted for Anthropic by provider) ───
+
+export const TOOL_DEFINITIONS = [
+  {
+    name: 'list_directory',
+    description: 'List files and directories in a given path. Shows name, type, size, and modification time.',
+    parameters: {
+      type: 'object',
+      properties: {
+        path: { type: 'string', description: 'Directory path to list. Use "." for current working directory.' },
+        show_hidden: { type: 'boolean', description: 'Show hidden files (starting with dot). Default false.' },
+      },
+      required: ['path'],
+    },
+  },
+  {
+    name: 'read_file',
+    description: 'Read the contents of a file. Returns the full text content.',
+    parameters: {
+      type: 'object',
+      properties: {
+        path: { type: 'string', description: 'Absolute or relative path to the file.' },
+        encoding: { type: 'string', description: 'File encoding, default utf8. Use "base64" for binary files.' },
+      },
+      required: ['path'],
+    },
+  },
+  {
+    name: 'write_file',
+    description: 'Write content to a file. Creates the file if it does not exist, overwrites if it does.',
+    parameters: {
+      type: 'object',
+      properties: {
+        path: { type: 'string', description: 'Path to the file to write.' },
+        content: { type: 'string', description: 'Content to write to the file.' },
+        create_dirs: { type: 'boolean', description: 'Automatically create parent directories if missing. Default true.' },
+      },
+      required: ['path', 'content'],
+    },
+  },
+  {
+    name: 'append_to_file',
+    description: 'Append text to an existing file (or create it if missing).',
+    parameters: {
+      type: 'object',
+      properties: {
+        path: { type: 'string', description: 'Path to the file.' },
+        content: { type: 'string', description: 'Content to append.' },
+      },
+      required: ['path', 'content'],
+    },
+  },
+  {
+    name: 'patch_file',
+    description: 'Replace a specific string/block of text in a file with new content. Useful for editing specific parts without rewriting the whole file.',
+    parameters: {
+      type: 'object',
+      properties: {
+        path: { type: 'string', description: 'Path to the file.' },
+        old_text: { type: 'string', description: 'The exact text to find and replace. Must match exactly.' },
+        new_text: { type: 'string', description: 'The replacement text.' },
+      },
+      required: ['path', 'old_text', 'new_text'],
+    },
+  },
+  {
+    name: 'delete_path',
+    description: 'Delete a file or directory (directories are deleted recursively).',
+    parameters: {
+      type: 'object',
+      properties: {
+        path: { type: 'string', description: 'Path to file or directory to delete.' },
+      },
+      required: ['path'],
+    },
+  },
+  {
+    name: 'copy_path',
+    description: 'Copy a file or directory to a new location.',
+    parameters: {
+      type: 'object',
+      properties: {
+        source: { type: 'string', description: 'Source file path.' },
+        destination: { type: 'string', description: 'Destination path.' },
+      },
+      required: ['source', 'destination'],
+    },
+  },
+  {
+    name: 'move_path',
+    description: 'Move or rename a file or directory.',
+    parameters: {
+      type: 'object',
+      properties: {
+        source: { type: 'string', description: 'Source path.' },
+        destination: { type: 'string', description: 'Destination path.' },
+      },
+      required: ['source', 'destination'],
+    },
+  },
+  {
+    name: 'create_directory',
+    description: 'Create a directory and all necessary parent directories.',
+    parameters: {
+      type: 'object',
+      properties: {
+        path: { type: 'string', description: 'Path of directory to create.' },
+      },
+      required: ['path'],
+    },
+  },
+  {
+    name: 'get_file_info',
+    description: 'Get detailed metadata about a file or directory (size, permissions, dates, type).',
+    parameters: {
+      type: 'object',
+      properties: {
+        path: { type: 'string', description: 'Path to the file or directory.' },
+      },
+      required: ['path'],
+    },
+  },
+  {
+    name: 'find_files',
+    description: 'Find files matching a glob pattern recursively.',
+    parameters: {
+      type: 'object',
+      properties: {
+        pattern: { type: 'string', description: 'Glob pattern e.g. "**/*.js", "src/**/*.ts", "*.json"' },
+        cwd: { type: 'string', description: 'Directory to search in. Defaults to working directory.' },
+        ignore: { type: 'array', items: { type: 'string' }, description: 'Patterns to ignore, e.g. ["node_modules/**", ".git/**"]' },
+      },
+      required: ['pattern'],
+    },
+  },
+  {
+    name: 'search_in_files',
+    description: 'Search for text/regex in files. Returns matching file paths and lines.',
+    parameters: {
+      type: 'object',
+      properties: {
+        query: { type: 'string', description: 'Text or regex pattern to search for.' },
+        path: { type: 'string', description: 'Directory or file to search in.' },
+        file_pattern: { type: 'string', description: 'File extension filter e.g. "*.js". Default all files.' },
+        case_sensitive: { type: 'boolean', description: 'Case sensitive search. Default false.' },
+        max_results: { type: 'number', description: 'Max results to return. Default 50.' },
+      },
+      required: ['query', 'path'],
+    },
+  },
+  {
+    name: 'execute_command',
+    description: 'Execute a shell command in the working directory. Returns stdout and stderr.',
+    parameters: {
+      type: 'object',
+      properties: {
+        command: { type: 'string', description: 'Shell command to execute.' },
+        cwd: { type: 'string', description: 'Working directory for the command.' },
+        timeout: { type: 'number', description: 'Timeout in milliseconds. Default 30000 (30s).' },
+      },
+      required: ['command'],
+    },
+  },
+];
+
+// ─── Tool Executors ───────────────────────────────────────────────────────────
+
+function resolvePath(p, workdir) {
+  if (path.isAbsolute(p)) return p;
+  return path.resolve(workdir, p);
+}
+
+function formatSize(bytes) {
+  if (bytes < 1024) return `${bytes}B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)}KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
+}
+
+function deleteDirRecursive(p) {
+  if (existsSync(p)) {
+    const stat = statSync(p);
+    if (stat.isDirectory()) {
+      for (const entry of readdirSync(p)) {
+        deleteDirRecursive(path.join(p, entry));
+      }
+      import('fs').then(({ rmdirSync }) => rmdirSync(p));
+    } else {
+      unlinkSync(p);
+    }
+  }
+}
+
+export async function executeTool(name, input, workdir) {
+  const wd = workdir || process.cwd();
+
+  try {
+    switch (name) {
+      case 'list_directory': {
+        const dirPath = resolvePath(input.path, wd);
+        const entries = readdirSync(dirPath);
+        const results = [];
+        for (const entry of entries) {
+          if (!input.show_hidden && entry.startsWith('.')) continue;
+          try {
+            const fullPath = path.join(dirPath, entry);
+            const stat = statSync(fullPath);
+            results.push({
+              name: entry,
+              type: stat.isDirectory() ? 'dir' : 'file',
+              size: stat.isDirectory() ? '-' : formatSize(stat.size),
+              modified: stat.mtime.toISOString().slice(0, 16).replace('T', ' '),
+            });
+          } catch {}
+        }
+        results.sort((a, b) => {
+          if (a.type !== b.type) return a.type === 'dir' ? -1 : 1;
+          return a.name.localeCompare(b.name);
+        });
+        const lines = results.map((e) =>
+          `${e.type === 'dir' ? '📁' : '📄'} ${e.name.padEnd(40)} ${e.size.padStart(8)}  ${e.modified}`
+        );
+        return `Directory: ${dirPath}\n${'─'.repeat(72)}\n${lines.join('\n')}\n\nTotal: ${results.length} items`;
+      }
+
+      case 'read_file': {
+        const filePath = resolvePath(input.path, wd);
+        const encoding = input.encoding || 'utf8';
+        const content = readFileSync(filePath, encoding);
+        const size = statSync(filePath).size;
+        return `File: ${filePath} (${formatSize(size)})\n${'─'.repeat(60)}\n${content}`;
+      }
+
+      case 'write_file': {
+        const filePath = resolvePath(input.path, wd);
+        if (input.create_dirs !== false) {
+          mkdirSync(path.dirname(filePath), { recursive: true });
+        }
+        writeFileSync(filePath, input.content, 'utf8');
+        return `✅ Written ${formatSize(Buffer.byteLength(input.content))} to: ${filePath}`;
+      }
+
+      case 'append_to_file': {
+        const filePath = resolvePath(input.path, wd);
+        appendFileSync(filePath, input.content, 'utf8');
+        return `✅ Appended ${Buffer.byteLength(input.content)} bytes to: ${filePath}`;
+      }
+
+      case 'patch_file': {
+        const filePath = resolvePath(input.path, wd);
+        let content = readFileSync(filePath, 'utf8');
+        if (!content.includes(input.old_text)) {
+          return `❌ Text not found in file. Make sure old_text matches exactly (check whitespace/newlines).`;
+        }
+        content = content.replace(input.old_text, input.new_text);
+        writeFileSync(filePath, content, 'utf8');
+        return `✅ Patched: ${filePath}`;
+      }
+
+      case 'delete_path': {
+        const targetPath = resolvePath(input.path, wd);
+        if (!existsSync(targetPath)) return `⚠️ Path does not exist: ${targetPath}`;
+        const stat = statSync(targetPath);
+        if (stat.isDirectory()) {
+          execSync(`rm -rf "${targetPath}"`);
+        } else {
+          unlinkSync(targetPath);
+        }
+        return `✅ Deleted: ${targetPath}`;
+      }
+
+      case 'copy_path': {
+        const src = resolvePath(input.source, wd);
+        const dst = resolvePath(input.destination, wd);
+        mkdirSync(path.dirname(dst), { recursive: true });
+        copyFileSync(src, dst);
+        return `✅ Copied: ${src} → ${dst}`;
+      }
+
+      case 'move_path': {
+        const src = resolvePath(input.source, wd);
+        const dst = resolvePath(input.destination, wd);
+        mkdirSync(path.dirname(dst), { recursive: true });
+        renameSync(src, dst);
+        return `✅ Moved: ${src} → ${dst}`;
+      }
+
+      case 'create_directory': {
+        const dirPath = resolvePath(input.path, wd);
+        mkdirSync(dirPath, { recursive: true });
+        return `✅ Created directory: ${dirPath}`;
+      }
+
+      case 'get_file_info': {
+        const filePath = resolvePath(input.path, wd);
+        if (!existsSync(filePath)) return `❌ Path does not exist: ${filePath}`;
+        const stat = statSync(filePath);
+        return JSON.stringify({
+          path: filePath,
+          type: stat.isDirectory() ? 'directory' : 'file',
+          size: stat.size,
+          sizeHuman: formatSize(stat.size),
+          created: stat.birthtime.toISOString(),
+          modified: stat.mtime.toISOString(),
+          accessed: stat.atime.toISOString(),
+          permissions: (stat.mode & 0o777).toString(8),
+          isSymlink: stat.isSymbolicLink(),
+        }, null, 2);
+      }
+
+      case 'find_files': {
+        const searchCwd = input.cwd ? resolvePath(input.cwd, wd) : wd;
+        const ignore = input.ignore || ['node_modules/**', '.git/**', 'dist/**', 'build/**'];
+        const files = await glob(input.pattern, { cwd: searchCwd, ignore, dot: false });
+        if (files.length === 0) return `No files found matching: ${input.pattern}`;
+        return `Found ${files.length} file(s):\n${files.sort().map((f) => `  ${f}`).join('\n')}`;
+      }
+
+      case 'search_in_files': {
+        const searchPath = resolvePath(input.path, wd);
+        const flags = input.case_sensitive ? '' : '-i';
+        const filePattern = input.file_pattern ? `--include="${input.file_pattern}"` : '';
+        const maxR = input.max_results || 50;
+        const cmd = `grep -rn ${flags} ${filePattern} "${input.query}" "${searchPath}" 2>/dev/null | head -${maxR}`;
+        try {
+          const output = execSync(cmd, { encoding: 'utf8', timeout: 10000 });
+          const lines = output.trim().split('\n').filter(Boolean);
+          return lines.length > 0
+            ? `Found ${lines.length} match(es):\n${lines.join('\n')}`
+            : `No matches found for: ${input.query}`;
+        } catch {
+          return `No matches found for: ${input.query}`;
+        }
+      }
+
+      case 'execute_command': {
+        const cmdWd = input.cwd ? resolvePath(input.cwd, wd) : wd;
+        const timeout = input.timeout || 30000;
+        try {
+          const output = execSync(input.command, {
+            cwd: cmdWd,
+            encoding: 'utf8',
+            timeout,
+            maxBuffer: 10 * 1024 * 1024,
+          });
+          return output || '(command completed with no output)';
+        } catch (err) {
+          return `Exit code ${err.status || 1}:\nSTDOUT: ${err.stdout || ''}\nSTDERR: ${err.stderr || err.message}`;
+        }
+      }
+
+      default:
+        return `❌ Unknown tool: ${name}`;
+    }
+  } catch (err) {
+    return `❌ Tool error: ${err.message}`;
+  }
+}