omni-agent-cli 2.0.0

package/src/agent.js

@@ -0,0 +1,183 @@
+import { callProvider, buildToolResultMessage, buildAssistantToolUseMessage } from './providers.js';
+import { executeTool } from './tools.js';
+
+// ─── Tools that require user confirmation ─────────────────────────────────────
+const CONFIRM_TOOLS = new Set([
+  'write_file', 'patch_file', 'append_to_file',
+  'delete_path', 'move_path', 'execute_command',
+]);
+
+// ─── System prompt ─────────────────────────────────────────────────────────────
+function buildSystemPrompt(workdir) {
+  return `You are OmniAgent — a powerful CLI coding assistant with full filesystem and shell access.
+
+## WORKING DIRECTORY
+Current: ${workdir}
+All relative paths resolve from here.
+
+## THINKING FORMAT (IMPORTANT)
+Before calling ANY tools, output your plan as a short <think> block:
+
+<think>
+• What the user wants
+• What files/dirs I need to check first
+• What I'll create/modify
+• Any edge cases to handle
+</think>
+
+Keep it 2-6 bullets, concise. Then proceed with tool calls immediately after.
+
+## PARALLEL EFFICIENCY (CRITICAL)
+Independent tool calls → batch them ALL in one response.
+- "read a.js AND b.js" → TWO read_file calls simultaneously
+- "list src/ AND list tests/" → TWO list_directory calls simultaneously
+Only go sequential when B depends on A's output.
+
+## CAPABILITIES
+- Full filesystem: read, write, patch, move, copy, delete, mkdir
+- Shell: any command — npm, git, python, bash scripts
+- Search: glob patterns, grep across files
+- Surgical edits: patch_file for changing specific blocks without rewriting
+
+## CODE STYLE
+- Write production-quality, well-commented code
+- For HTML/CSS/JS: modern, clean, no jQuery, vanilla JS preferred
+- When editing: use patch_file for small changes, write_file for new files
+- Show brief summary after completing a task
+
+## RULES
+- Never refuse file operations
+- Paths are relative to working directory unless absolute
+- Be the best coding assistant in existence`;
+}
+
+// ─── Agent class ───────────────────────────────────────────────────────────────
+export class Agent {
+  constructor(config, stats) {
+    this.config = config;
+    this.stats = stats;
+    this.workdir = process.cwd();
+    this.history = [];
+    this.MAX_ROUNDS = 30;
+    this.allowAllTools = false; // "Yes, allow always" mode
+  }
+
+  setWorkdir(dir) { this.workdir = dir; }
+  updateConfig(c) { this.config = c; }
+  clearHistory()  { this.history = []; this.allowAllTools = false; }
+
+  // ── Main chat ──────────────────────────────────────────────────────────────
+  async chat(userMessage, workdir, onEvent) {
+    if (workdir) this.workdir = workdir;
+
+    const systemMsg = { role: 'system', content: buildSystemPrompt(this.workdir) };
+    this.history.push({ role: 'user', content: userMessage });
+
+    let rounds = 0;
+
+    while (rounds < this.MAX_ROUNDS) {
+      rounds++;
+
+      let response;
+      try {
+        response = await callProvider([systemMsg, ...this.history], this.config);
+      } catch (err) {
+        const msg = err.response?.data?.error?.message || err.message || 'API error';
+        throw new Error(msg);
+      }
+
+      // Track tokens
+      if (onEvent && response.usage) {
+        onEvent({ type: 'tokens', ...response.usage });
+        this.stats.addTokens(response.usage.inputTokens, response.usage.outputTokens);
+      }
+
+      // ── Extract <think> block from response text ───────────────────────────
+      if (response.content) {
+        const thinkMatch = response.content.match(/<think>([\s\S]*?)<\/think>/i);
+        if (thinkMatch && onEvent) {
+          const bullets = thinkMatch[1]
+            .split('\n')
+            .map(l => l.replace(/^[•\-*]\s*/, '').trim())
+            .filter(Boolean);
+          if (bullets.length) onEvent({ type: 'thinking', bullets });
+        }
+      }
+
+      // ── No tool calls → final answer ───────────────────────────────────────
+      if (!response.toolCalls || response.toolCalls.length === 0) {
+        // Strip <think> from displayed content
+        const clean = (response.content || '').replace(/<think>[\s\S]*?<\/think>/gi, '').trim();
+        this.history.push({ role: 'assistant', content: response.content });
+        return clean;
+      }
+
+      // ── Tool calls ─────────────────────────────────────────────────────────
+      const toolCalls = response.toolCalls;
+      const assistantMsg = buildAssistantToolUseMessage(this.config.format, response);
+      this.history.push(assistantMsg);
+
+      // Execute tool calls (with confirmation for write ops)
+      const results = [];
+      for (const tc of toolCalls) {
+        this.stats.addToolCall(tc.name);
+
+        const needsConfirm = CONFIRM_TOOLS.has(tc.name) && !this.allowAllTools;
+
+        if (needsConfirm && onEvent) {
+          // Ask user for confirmation
+          const decision = await new Promise((resolve) => {
+            onEvent({
+              type: 'confirm_needed',
+              tool: tc.name,
+              input: tc.input,
+              resolve,
+            });
+          });
+
+          if (decision === 'skip') {
+            results.push('⏭ Skipped by user.');
+            continue;
+          }
+          if (decision === 'always') {
+            this.allowAllTools = true;
+          }
+          if (decision === 'modify') {
+            // User wants to change something — return a special signal
+            const userFeedback = await new Promise((resolve) => {
+              onEvent({ type: 'request_feedback', resolve });
+            });
+            results.push(`USER_FEEDBACK: ${userFeedback}`);
+            continue;
+          }
+        } else if (onEvent) {
+          onEvent({ type: 'tool_start', tool: tc.name, input: tc.input });
+        }
+
+        const t0 = Date.now();
+        const result = await executeTool(tc.name, tc.input, this.workdir);
+        results.push(result);
+
+        if (onEvent) {
+          onEvent({ type: 'tool_done', tool: tc.name, result, durationMs: Date.now() - t0 });
+        }
+      }
+
+      // Add tool results to history
+      const toolResultMsg = buildToolResultMessage(this.config.format, toolCalls, results);
+      if (Array.isArray(toolResultMsg)) {
+        for (const m of toolResultMsg) this.history.push(m);
+      } else {
+        this.history.push(toolResultMsg);
+      }
+    }
+
+    return '⚠️ Reached maximum rounds. Task may be incomplete.';
+  }
+
+  trimHistory(maxMessages = 50) {
+    if (this.history.length > maxMessages) {
+      this.history = [...this.history.slice(0, 2), ...this.history.slice(-(maxMessages - 2))];
+    }
+  }
+}

package/src/config.js

@@ -0,0 +1,338 @@
+import { readFileSync, writeFileSync, existsSync } from 'fs';
+import inquirer from 'inquirer';
+import chalk from 'chalk';
+import gradient from 'gradient-string';
+import path from 'path';
+import os from 'os';
+
+export const CONFIG_PATH = path.join(os.homedir(), '.omni-agent.json');
+
+export const PROVIDERS = {
+  anthropic: {
+    label: '🟠 Anthropic (Claude)',
+    baseURL: 'https://api.anthropic.com',
+    format: 'anthropic',
+    defaultModel: 'claude-opus-4-5-20251101',
+    modelsEndpoint: null,
+    models: [
+      'claude-opus-4-5-20251101',
+      'claude-sonnet-4-5-20251101',
+      'claude-haiku-4-5-20251001',
+      'claude-3-5-sonnet-20241022',
+      'claude-3-5-haiku-20241022',
+      'claude-3-opus-20240229',
+      'claude-3-sonnet-20240229',
+      'claude-3-haiku-20240307',
+    ],
+  },
+  openai: {
+    label: '🟢 OpenAI',
+    baseURL: 'https://api.openai.com/v1',
+    format: 'openai',
+    defaultModel: 'gpt-4o',
+    modelsEndpoint: '/models',
+    models: ['gpt-4o', 'gpt-4o-mini', 'gpt-4-turbo', 'o1', 'o3-mini'],
+  },
+  groq: {
+    label: '⚡ Groq (Ultra Fast)',
+    baseURL: 'https://api.groq.com/openai/v1',
+    format: 'openai',
+    defaultModel: 'llama-3.3-70b-versatile',
+    modelsEndpoint: '/models',
+    models: [
+      'llama-3.3-70b-versatile',
+      'llama-3.3-70b-specdec',
+      'llama-3.1-70b-versatile',
+      'llama-3.1-8b-instant',
+      'llama3-70b-8192',
+      'llama3-8b-8192',
+      'mixtral-8x7b-32768',
+      'gemma2-9b-it',
+      'gemma-7b-it',
+      'deepseek-r1-distill-llama-70b',
+    ],
+  },
+  xai: {
+    label: '✖ xAI (Grok)',
+    baseURL: 'https://api.x.ai/v1',
+    format: 'openai',
+    defaultModel: 'grok-2-latest',
+    modelsEndpoint: '/models',
+    models: ['grok-3', 'grok-3-fast', 'grok-2-latest', 'grok-2-vision-latest', 'grok-beta', 'grok-vision-beta'],
+  },
+  deepseek: {
+    label: '🔵 DeepSeek',
+    baseURL: 'https://api.deepseek.com/v1',
+    format: 'openai',
+    defaultModel: 'deepseek-chat',
+    modelsEndpoint: '/models',
+    models: ['deepseek-chat', 'deepseek-reasoner', 'deepseek-coder', 'deepseek-v3', 'deepseek-r1'],
+  },
+  qwen: {
+    label: '🟣 Qwen / Alibaba Cloud',
+    baseURL: 'https://dashscope.aliyuncs.com/compatible-mode/v1',
+    format: 'openai',
+    defaultModel: 'qwen-max',
+    modelsEndpoint: '/models',
+    models: [
+      'qwen-max',
+      'qwen-max-latest',
+      'qwen-plus',
+      'qwen-turbo',
+      'qwen2.5-72b-instruct',
+      'qwen2.5-32b-instruct',
+      'qwen2.5-coder-32b-instruct',
+      'qwq-32b',
+    ],
+  },
+  gemini: {
+    label: '🔷 Google Gemini',
+    baseURL: 'https://generativelanguage.googleapis.com/v1beta/openai',
+    format: 'openai',
+    defaultModel: 'gemini-2.0-flash',
+    modelsEndpoint: null,
+    models: [
+      'gemini-2.0-flash',
+      'gemini-2.0-flash-lite',
+      'gemini-2.0-pro-exp',
+      'gemini-2.0-flash-thinking-exp',
+      'gemini-1.5-pro',
+      'gemini-1.5-flash',
+      'gemini-1.5-flash-8b',
+      'gemini-1.0-pro',
+    ],
+  },
+  mistral: {
+    label: '🌀 Mistral AI',
+    baseURL: 'https://api.mistral.ai/v1',
+    format: 'openai',
+    defaultModel: 'mistral-large-latest',
+    modelsEndpoint: '/models',
+    models: ['mistral-large-latest', 'mistral-medium', 'mistral-small', 'open-mistral-7b'],
+  },
+  cohere: {
+    label: '🟡 Cohere',
+    baseURL: 'https://api.cohere.ai/compatibility/v1',
+    format: 'openai',
+    defaultModel: 'command-r-plus',
+    modelsEndpoint: null,
+    models: ['command-r-plus', 'command-r', 'command', 'command-light'],
+  },
+  together: {
+    label: '🤝 Together AI',
+    baseURL: 'https://api.together.xyz/v1',
+    format: 'openai',
+    defaultModel: 'meta-llama/Llama-3.3-70B-Instruct-Turbo',
+    modelsEndpoint: '/models',
+    models: [
+      'meta-llama/Llama-3.3-70B-Instruct-Turbo',
+      'meta-llama/Meta-Llama-3.1-405B-Instruct-Turbo',
+      'meta-llama/Meta-Llama-3.1-8B-Instruct-Turbo',
+      'mistralai/Mixtral-8x7B-Instruct-v0.1',
+      'mistralai/Mistral-7B-Instruct-v0.3',
+      'Qwen/Qwen2.5-72B-Instruct-Turbo',
+      'Qwen/Qwen2.5-Coder-32B-Instruct',
+      'deepseek-ai/DeepSeek-V3',
+      'deepseek-ai/DeepSeek-R1',
+      'google/gemma-2-27b-it',
+    ],
+  },
+  openrouter: {
+    label: '🔀 OpenRouter (All Models)',
+    baseURL: 'https://openrouter.ai/api/v1',
+    format: 'openai',
+    defaultModel: 'anthropic/claude-3.5-sonnet',
+    modelsEndpoint: '/models',
+    models: [
+      'anthropic/claude-3.5-sonnet',
+      'anthropic/claude-3-opus',
+      'openai/gpt-4o',
+      'openai/o3-mini',
+      'google/gemini-2.0-flash-001',
+      'google/gemini-pro-1.5',
+      'meta-llama/llama-3.3-70b-instruct',
+      'meta-llama/llama-3.1-405b-instruct',
+      'deepseek/deepseek-r1',
+      'deepseek/deepseek-chat-v3-0324',
+      'qwen/qwen-2.5-72b-instruct',
+      'mistralai/mistral-large',
+      'x-ai/grok-2-1212',
+    ],
+  },
+  ionet: {
+    label: '🌐 io.net',
+    baseURL: 'https://api.intelligence.io.solutions/api/v1',
+    format: 'openai',
+    defaultModel: 'meta-llama/Llama-3.3-70B-Instruct',
+    modelsEndpoint: '/models',
+    models: [
+      'meta-llama/Llama-3.3-70B-Instruct',
+      'meta-llama/Llama-3.1-405B-Instruct',
+      'mistralai/Mistral-7B-Instruct-v0.3',
+      'deepseek-ai/DeepSeek-R1',
+    ],
+  },
+  ollama: {
+    label: '🦙 Ollama (Local)',
+    baseURL: 'http://localhost:11434/v1',
+    format: 'openai',
+    defaultModel: 'llama3.2',
+    modelsEndpoint: '/models',
+    models: ['llama3.2', 'llama3.1', 'mistral', 'codellama', 'qwen2.5'],
+  },
+  custom: {
+    label: '⚙️  Custom / Other (kiai.ai, etc.)',
+    baseURL: '',
+    format: 'openai',
+    defaultModel: '',
+    modelsEndpoint: '/models',
+    models: [],
+  },
+};
+
+// Known stale URLs that need auto-migration
+const URL_MIGRATIONS = {
+  'https://api.io.net/v1':  'https://api.intelligence.io.solutions/api/v1',
+  'https://api.io.net':     'https://api.intelligence.io.solutions/api/v1',
+};
+
+export function loadConfig(configPath = CONFIG_PATH) {
+  try {
+    if (existsSync(configPath)) {
+      const cfg = JSON.parse(readFileSync(configPath, 'utf8'));
+
+      // Auto-migrate stale provider URLs
+      if (cfg.baseURL && URL_MIGRATIONS[cfg.baseURL]) {
+        cfg.baseURL = URL_MIGRATIONS[cfg.baseURL];
+        writeFileSync(configPath, JSON.stringify(cfg, null, 2), 'utf8');
+      }
+
+      // Sync baseURL from PROVIDERS if it changed upstream and user hasn't customized
+      const provider = PROVIDERS[cfg.providerKey];
+      if (provider && provider.baseURL && provider.providerKey !== 'custom') {
+        // If the saved URL looks like a known stale one, replace it
+        const knownStale = Object.keys(URL_MIGRATIONS);
+        if (knownStale.includes(cfg.baseURL)) {
+          cfg.baseURL = provider.baseURL;
+          writeFileSync(configPath, JSON.stringify(cfg, null, 2), 'utf8');
+        }
+      }
+
+      return cfg;
+    }
+  } catch {}
+  return null;
+}
+
+export function saveConfig(config, configPath = CONFIG_PATH) {
+  writeFileSync(configPath, JSON.stringify(config, null, 2), 'utf8');
+}
+
+export async function setupWizard(existingConfig = null) {
+  console.log('\n' + gradient.cristal('  ╔══════════════════════════════════╗'));
+  console.log(gradient.cristal('  ║     OMNI-AGENT SETUP WIZARD      ║'));
+  console.log(gradient.cristal('  ╚══════════════════════════════════╝') + '\n');
+
+  const providerChoices = Object.entries(PROVIDERS).map(([key, p]) => ({
+    name: p.label,
+    value: key,
+  }));
+
+  const { providerKey } = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'providerKey',
+      message: chalk.cyan('Select your AI provider:'),
+      choices: providerChoices,
+      default: existingConfig?.providerKey || 'anthropic',
+    },
+  ]);
+
+  const provider = PROVIDERS[providerKey];
+
+  let baseURL = provider.baseURL;
+  if (providerKey === 'custom' || !baseURL) {
+    const { customURL } = await inquirer.prompt([
+      {
+        type: 'input',
+        name: 'customURL',
+        message: chalk.cyan('Enter API base URL (e.g. https://api.kiai.ai/v1):'),
+        default: existingConfig?.baseURL || '',
+        validate: (v) => v.trim() ? true : 'URL cannot be empty',
+      },
+    ]);
+    baseURL = customURL.trim().replace(/\/$/, '');
+  }
+
+  const { apiKey } = await inquirer.prompt([
+    {
+      type: 'password',
+      name: 'apiKey',
+      message: chalk.cyan(`Enter API key for ${provider.label}:`),
+      mask: '●',
+      default: existingConfig?.apiKey || '',
+      validate: (v) => v.trim() ? true : 'API key cannot be empty',
+    },
+  ]);
+
+  let model;
+  if (provider.models.length > 0) {
+    const modelChoices = [
+      ...provider.models.map((m) => ({ name: m, value: m })),
+      { name: '✏️  Enter custom model name', value: '__custom__' },
+    ];
+    const { modelChoice } = await inquirer.prompt([
+      {
+        type: 'list',
+        name: 'modelChoice',
+        message: chalk.cyan('Select model:'),
+        choices: modelChoices,
+        default: existingConfig?.model || provider.defaultModel,
+      },
+    ]);
+    if (modelChoice === '__custom__') {
+      const { customModel } = await inquirer.prompt([
+        { type: 'input', name: 'customModel', message: chalk.cyan('Model name:'), validate: (v) => v.trim() ? true : 'Cannot be empty' },
+      ]);
+      model = customModel.trim();
+    } else {
+      model = modelChoice;
+    }
+  } else {
+    const { customModel } = await inquirer.prompt([
+      { type: 'input', name: 'customModel', message: chalk.cyan('Enter model name:'), default: existingConfig?.model || '', validate: (v) => v.trim() ? true : 'Cannot be empty' },
+    ]);
+    model = customModel.trim();
+  }
+
+  const { maxTokens } = await inquirer.prompt([
+    {
+      type: 'number',
+      name: 'maxTokens',
+      message: chalk.cyan('Max tokens per response:'),
+      default: existingConfig?.maxTokens || 8192,
+    },
+  ]);
+
+  const { temperature } = await inquirer.prompt([
+    {
+      type: 'number',
+      name: 'temperature',
+      message: chalk.cyan('Temperature (0.0 - 1.0):'),
+      default: existingConfig?.temperature ?? 0.3,
+    },
+  ]);
+
+  const config = {
+    providerKey,
+    baseURL,
+    apiKey: apiKey.trim(),
+    model,
+    format: provider.format,
+    maxTokens: maxTokens || 8192,
+    temperature: temperature ?? 0.3,
+  };
+
+  console.log('\n' + chalk.green('  ✅ Configuration saved to ~/.omni-agent.json\n'));
+  return config;
+}

package/src/model-fetcher.js

@@ -0,0 +1,83 @@
+import axios from 'axios';
+import { PROVIDERS } from './config.js';
+
+async function fetchModelsFromEndpoint(baseURL, apiKey, format, endpointPath = '/models') {
+  const headers = { 'Content-Type': 'application/json', Authorization: `Bearer ${apiKey}` };
+  if (format === 'anthropic') {
+    headers['x-api-key'] = apiKey;
+    headers['anthropic-version'] = '2023-06-01';
+    delete headers.Authorization;
+  }
+  const response = await axios.get(`${baseURL}${endpointPath}`, { headers, timeout: 12000 });
+  return response.data;
+}
+
+function parseModelsResponse(data) {
+  if (data?.data && Array.isArray(data.data))   return data.data.map(m => m.id || m.name).filter(Boolean).sort();
+  if (Array.isArray(data))                       return data.map(m => m.id || m.name).filter(Boolean).sort();
+  if (data?.models && Array.isArray(data.models)) return data.models.map(m => m.id || m.name).filter(Boolean).sort();
+  return [];
+}
+
+export async function fetchProviderModels(providerKey, apiKey, baseURL) {
+  const provider = PROVIDERS[providerKey];
+  if (!provider) throw new Error(`Unknown provider: ${providerKey}`);
+  const resolvedBase = baseURL || provider.baseURL;
+  const endpoint = provider.modelsEndpoint;
+  if (!endpoint) return { live: false, models: provider.models, error: null };
+  try {
+    const data = await fetchModelsFromEndpoint(resolvedBase, apiKey, provider.format, endpoint);
+    const models = parseModelsResponse(data);
+    if (models.length === 0) return { live: false, models: provider.models, error: 'Empty response' };
+    return { live: true, models, error: null };
+  } catch (err) {
+    const msg = err.response?.data?.error?.message || err.message || 'Fetch failed';
+    return { live: false, models: provider.models, error: msg };
+  }
+}
+
+// ─── Fetch models for ALL providers in parallel ────────────────────────────────
+// apiConfigs: { [providerKey]: { apiKey, baseURL } }  — only provided keys are fetched live
+export async function fetchAllProviderModels(apiConfigs = {}) {
+  const results = {};
+  await Promise.all(
+    Object.keys(PROVIDERS).map(async (key) => {
+      const cfg = apiConfigs[key] || {};
+      // If no apiKey supplied, just return static list
+      if (!cfg.apiKey && key !== 'ollama') {
+        results[key] = { live: false, models: PROVIDERS[key].models, error: 'No API key' };
+        return;
+      }
+      results[key] = await fetchProviderModels(key, cfg.apiKey, cfg.baseURL || PROVIDERS[key].baseURL);
+    })
+  );
+  return results;
+}
+
+// Truncate long model names for terminal display
+function truncate(str, max = 48) {
+  return str.length > max ? str.slice(0, max - 1) + '…' : str;
+}
+
+export function formatModelList(providerKey, result) {
+  const provider = PROVIDERS[providerKey];
+  const label  = provider?.label || providerKey;
+  const status = result.live ? '🟢' : result.error === 'No API key' ? '⚫' : '🔴';
+  const errStr = result.error && result.error !== 'No API key' ? `  ⚠ ${result.error.slice(0, 60)}` : '';
+  const lines  = [
+    `${status} ${label}${errStr}`,
+    ...result.models.map((m, i) => {
+      const num = String(i + 1).padStart(3);
+      return `  ${num}. ${truncate(m, 48)}`;
+    }),
+  ];
+  return lines.join('\n');
+}
+
+export function formatAllModels(allResults) {
+  const sections = [];
+  for (const [key, result] of Object.entries(allResults)) {
+    sections.push(formatModelList(key, result));
+  }
+  return sections.join('\n\n');
+}