nex-code 0.3.4 → 0.3.7

package/cli/providers/anthropic.js

@@ -1,333 +0,0 @@
-/**
- * cli/providers/anthropic.js — Anthropic Claude Provider
- * Supports Claude Sonnet, Opus, Haiku via Anthropic Messages API with SSE streaming.
- */
-
-const axios = require('axios');
-const { BaseProvider } = require('./base');
-
-const ANTHROPIC_MODELS = {
-  'claude-sonnet': {
-    id: 'claude-sonnet-4-6',
-    name: 'Claude Sonnet 4.6',
-    maxTokens: 64000,
-    contextWindow: 200000,
-  },
-  'claude-opus': {
-    id: 'claude-opus-4-6',
-    name: 'Claude Opus 4.6',
-    maxTokens: 128000,
-    contextWindow: 200000,
-  },
-  'claude-haiku': {
-    id: 'claude-haiku-4-5-20251001',
-    name: 'Claude Haiku 4.5',
-    maxTokens: 64000,
-    contextWindow: 200000,
-  },
-  'claude-sonnet-4-5': {
-    id: 'claude-sonnet-4-5-20250929',
-    name: 'Claude Sonnet 4.5',
-    maxTokens: 64000,
-    contextWindow: 200000,
-  },
-  'claude-sonnet-4': {
-    id: 'claude-sonnet-4-20250514',
-    name: 'Claude Sonnet 4',
-    maxTokens: 64000,
-    contextWindow: 200000,
-  },
-};
-
-const ANTHROPIC_VERSION = '2023-06-01';
-
-class AnthropicProvider extends BaseProvider {
-  constructor(config = {}) {
-    super({
-      name: 'anthropic',
-      baseUrl: config.baseUrl || 'https://api.anthropic.com/v1',
-      models: config.models || ANTHROPIC_MODELS,
-      defaultModel: config.defaultModel || 'claude-sonnet',
-      ...config,
-    });
-    this.timeout = config.timeout || 180000;
-    this.temperature = config.temperature ?? 0.2;
-    this.apiVersion = config.apiVersion || ANTHROPIC_VERSION;
-  }
-
-  isConfigured() {
-    return !!this.getApiKey();
-  }
-
-  getApiKey() {
-    return process.env.ANTHROPIC_API_KEY || null;
-  }
-
-  _getHeaders() {
-    const key = this.getApiKey();
-    if (!key) throw new Error('ANTHROPIC_API_KEY not set');
-    return {
-      'x-api-key': key,
-      'anthropic-version': this.apiVersion,
-      'Content-Type': 'application/json',
-    };
-  }
-
-  /**
-   * Convert normalized messages to Anthropic format.
-   * Anthropic uses separate system parameter and different tool_use/tool_result blocks.
-   */
-  formatMessages(messages) {
-    let system = '';
-    const formatted = [];
-
-    for (const msg of messages) {
-      if (msg.role === 'system') {
-        system += (system ? '\n\n' : '') + msg.content;
-        continue;
-      }
-
-      if (msg.role === 'assistant') {
-        const content = [];
-        if (msg.content) {
-          content.push({ type: 'text', text: msg.content });
-        }
-        if (msg.tool_calls) {
-          for (const tc of msg.tool_calls) {
-            content.push({
-              type: 'tool_use',
-              id: tc.id || `toolu-${Date.now()}`,
-              name: tc.function.name,
-              input:
-                typeof tc.function.arguments === 'string'
-                  ? JSON.parse(tc.function.arguments || '{}')
-                  : tc.function.arguments || {},
-            });
-          }
-        }
-        formatted.push({ role: 'assistant', content: content.length > 0 ? content : [{ type: 'text', text: '' }] });
-        continue;
-      }
-
-      if (msg.role === 'tool') {
-        // Anthropic tool results are sent as user messages with tool_result content blocks
-        // Merge consecutive tool results into one user message
-        const last = formatted[formatted.length - 1];
-        const toolResult = {
-          type: 'tool_result',
-          tool_use_id: msg.tool_call_id,
-          content: typeof msg.content === 'string' ? msg.content : JSON.stringify(msg.content),
-        };
-
-        if (last && last.role === 'user' && Array.isArray(last.content) && last.content[0]?.type === 'tool_result') {
-          last.content.push(toolResult);
-        } else {
-          formatted.push({ role: 'user', content: [toolResult] });
-        }
-        continue;
-      }
-
-      // user messages
-      formatted.push({ role: 'user', content: msg.content });
-    }
-
-    return { messages: formatted, system };
-  }
-
-  /**
-   * Convert OpenAI/Ollama tool format to Anthropic tool format
-   */
-  formatTools(tools) {
-    if (!tools || tools.length === 0) return [];
-    return tools.map((t) => ({
-      name: t.function.name,
-      description: t.function.description || '',
-      input_schema: t.function.parameters || { type: 'object', properties: {} },
-    }));
-  }
-
-  _resolveModelId(model) {
-    const info = this.getModel(model);
-    return info?.id || model;
-  }
-
-  async chat(messages, tools, options = {}) {
-    const model = options.model || this.defaultModel;
-    const modelId = this._resolveModelId(model);
-    const modelInfo = this.getModel(model);
-    const maxTokens = options.maxTokens || modelInfo?.maxTokens || 8192;
-    const { messages: formatted, system } = this.formatMessages(messages);
-
-    const body = {
-      model: modelId,
-      messages: formatted,
-      max_tokens: maxTokens,
-      temperature: options.temperature ?? this.temperature,
-    };
-
-    if (system) body.system = system;
-    const formattedTools = this.formatTools(tools);
-    if (formattedTools.length > 0) body.tools = formattedTools;
-
-    const response = await axios.post(`${this.baseUrl}/messages`, body, {
-      timeout: options.timeout || this.timeout,
-      headers: this._getHeaders(),
-    });
-
-    return this.normalizeResponse(response.data);
-  }
-
-  async stream(messages, tools, options = {}) {
-    const model = options.model || this.defaultModel;
-    const modelId = this._resolveModelId(model);
-    const modelInfo = this.getModel(model);
-    const maxTokens = options.maxTokens || modelInfo?.maxTokens || 8192;
-    const onToken = options.onToken || (() => {});
-    const { messages: formatted, system } = this.formatMessages(messages);
-
-    const body = {
-      model: modelId,
-      messages: formatted,
-      max_tokens: maxTokens,
-      temperature: options.temperature ?? this.temperature,
-      stream: true,
-    };
-
-    if (system) body.system = system;
-    const formattedTools = this.formatTools(tools);
-    if (formattedTools.length > 0) body.tools = formattedTools;
-
-    let response;
-    try {
-      response = await axios.post(`${this.baseUrl}/messages`, body, {
-        timeout: options.timeout || this.timeout,
-        headers: this._getHeaders(),
-        responseType: 'stream',
-        signal: options.signal,
-      });
-    } catch (err) {
-      if (err.name === 'CanceledError' || err.name === 'AbortError' || err.code === 'ERR_CANCELED') throw err;
-      const msg = err.response?.data?.error?.message || err.message;
-      throw new Error(`API Error: ${msg}`);
-    }
-
-    return new Promise((resolve, reject) => {
-      let content = '';
-      const toolUses = []; // { id, name, inputJson }
-      let currentToolIndex = -1;
-      let buffer = '';
-
-      // Abort listener: destroy stream on signal
-      if (options.signal) {
-        options.signal.addEventListener('abort', () => {
-          response.data.destroy();
-          reject(new DOMException('The operation was aborted', 'AbortError'));
-        }, { once: true });
-      }
-
-      response.data.on('data', (chunk) => {
-        buffer += chunk.toString();
-        const lines = buffer.split('\n');
-        buffer = lines.pop() || '';
-
-        for (const line of lines) {
-          const trimmed = line.trim();
-
-          if (trimmed.startsWith('data: ')) {
-            const data = trimmed.slice(6);
-            let parsed;
-            try {
-              parsed = JSON.parse(data);
-            } catch {
-              continue;
-            }
-
-            switch (parsed.type) {
-              case 'content_block_start': {
-                const block = parsed.content_block;
-                if (block?.type === 'tool_use') {
-                  currentToolIndex = toolUses.length;
-                  toolUses.push({ id: block.id, name: block.name, inputJson: '' });
-                }
-                break;
-              }
-
-              case 'content_block_delta': {
-                const delta = parsed.delta;
-                if (delta?.type === 'text_delta' && delta.text) {
-                  onToken(delta.text);
-                  content += delta.text;
-                }
-                if (delta?.type === 'input_json_delta' && delta.partial_json !== undefined) {
-                  if (currentToolIndex >= 0) {
-                    toolUses[currentToolIndex].inputJson += delta.partial_json;
-                  }
-                }
-                break;
-              }
-
-              case 'content_block_stop':
-                currentToolIndex = -1;
-                break;
-
-              case 'message_stop':
-                resolve({ content, tool_calls: this._buildToolCalls(toolUses) });
-                return;
-            }
-          }
-        }
-      });
-
-      response.data.on('error', (err) => {
-        if (options.signal?.aborted) return; // Ignore errors after abort
-        reject(new Error(`Stream error: ${err.message}`));
-      });
-
-      response.data.on('end', () => {
-        resolve({ content, tool_calls: this._buildToolCalls(toolUses) });
-      });
-    });
-  }
-
-  normalizeResponse(data) {
-    let content = '';
-    const toolCalls = [];
-
-    for (const block of data.content || []) {
-      if (block.type === 'text') {
-        content += block.text;
-      } else if (block.type === 'tool_use') {
-        toolCalls.push({
-          id: block.id,
-          function: {
-            name: block.name,
-            arguments: block.input,
-          },
-        });
-      }
-    }
-
-    return { content, tool_calls: toolCalls };
-  }
-
-  _buildToolCalls(toolUses) {
-    return toolUses
-      .filter((tu) => tu.name)
-      .map((tu) => {
-        let args = {};
-        if (tu.inputJson) {
-          try {
-            args = JSON.parse(tu.inputJson);
-          } catch {
-            args = tu.inputJson;
-          }
-        }
-        return {
-          id: tu.id || `anthropic-${Date.now()}`,
-          function: { name: tu.name, arguments: args },
-        };
-      });
-  }
-}
-
-module.exports = { AnthropicProvider, ANTHROPIC_MODELS };

package/cli/providers/base.js

@@ -1,116 +0,0 @@
-/**
- * cli/providers/base.js — Abstract Provider Interface
- * All providers extend this base class.
- */
-
-class BaseProvider {
-  /**
-   * @param {object} config
-   * @param {string} config.name - Provider name (e.g. 'ollama', 'openai')
-   * @param {string} [config.baseUrl] - API base URL
-   * @param {object} [config.models] - Available models { id: { name, maxTokens, contextWindow } }
-   */
-  constructor(config = {}) {
-    if (new.target === BaseProvider) {
-      throw new Error('BaseProvider is abstract — use a concrete provider');
-    }
-    this.name = config.name || 'unknown';
-    this.baseUrl = config.baseUrl || '';
-    this.models = config.models || {};
-    this.defaultModel = config.defaultModel || null;
-  }
-
-  /**
-   * Check if the provider is configured (API key set, etc.)
-   * @returns {boolean}
-   */
-  isConfigured() {
-    throw new Error(`${this.name}: isConfigured() not implemented`);
-  }
-
-  /**
-   * Get the API key for this provider
-   * @returns {string|null}
-   */
-  getApiKey() {
-    return null;
-  }
-
-  /**
-   * Get available models for this provider
-   * @returns {object} { modelId: { id, name, maxTokens, contextWindow } }
-   */
-  getModels() {
-    return this.models;
-  }
-
-  /**
-   * Get model names
-   * @returns {string[]}
-   */
-  getModelNames() {
-    return Object.keys(this.models);
-  }
-
-  /**
-   * Get model info by id
-   * @param {string} modelId
-   * @returns {object|null}
-   */
-  getModel(modelId) {
-    return this.models[modelId] || null;
-  }
-
-  /**
-   * Non-streaming chat call.
-   * @param {Array} messages - Normalized messages [{ role, content, tool_calls?, tool_call_id? }]
-   * @param {Array} tools - Tool definitions (OpenAI/Ollama format)
-   * @param {object} [options] - { model, temperature, maxTokens }
-   * @returns {Promise<{content: string, tool_calls: Array}>}
-   */
-  async chat(messages, tools, options = {}) {
-    throw new Error(`${this.name}: chat() not implemented`);
-  }
-
-  /**
-   * Streaming chat call.
-   * @param {Array} messages - Normalized messages
-   * @param {Array} tools - Tool definitions
-   * @param {object} [options] - { model, temperature, maxTokens, onToken: (text) => void }
-   * @returns {Promise<{content: string, tool_calls: Array}>}
-   */
-  async stream(messages, tools, options = {}) {
-    throw new Error(`${this.name}: stream() not implemented`);
-  }
-
-  /**
-   * Convert normalized messages to provider-specific format.
-   * Override in subclasses if the provider uses a different format.
-   * @param {Array} messages
-   * @returns {object} { messages, system? } - provider-specific format
-   */
-  formatMessages(messages) {
-    return { messages };
-  }
-
-  /**
-   * Convert tool definitions to provider-specific format.
-   * Override if provider uses a different tool format.
-   * @param {Array} tools - OpenAI/Ollama format tools
-   * @returns {Array}
-   */
-  formatTools(tools) {
-    return tools;
-  }
-
-  /**
-   * Normalize provider response to standard format.
-   * @param {object} raw - Raw provider response
-   * @returns {{content: string, tool_calls: Array}}
-   */
-  normalizeResponse(raw) {
-    throw new Error(`${this.name}: normalizeResponse() not implemented`);
-  }
-}
-
-module.exports = { BaseProvider };

package/cli/providers/gemini.js

@@ -1,239 +0,0 @@
-/**
- * cli/providers/gemini.js — Google Gemini Provider
- * Supports Gemini 3.x Preview, 2.5 Pro/Flash/Lite, 2.0 Flash (deprecated) via
- * Google's OpenAI-compatible endpoint with SSE streaming.
- */
-
-const axios = require('axios');
-const { BaseProvider } = require('./base');
-
-const GEMINI_MODELS = {
-  // Preview — Gemini 3.x (latest)
-  'gemini-3.1-pro-preview': { id: 'gemini-3.1-pro-preview', name: 'Gemini 3.1 Pro Preview', maxTokens: 65536, contextWindow: 1048576 },
-  'gemini-3-flash-preview': { id: 'gemini-3-flash-preview', name: 'Gemini 3 Flash Preview', maxTokens: 65536, contextWindow: 1048576 },
-  // Stable — Gemini 2.5 (GA)
-  'gemini-2.5-pro': { id: 'gemini-2.5-pro', name: 'Gemini 2.5 Pro', maxTokens: 65536, contextWindow: 1048576 },
-  'gemini-2.5-flash': { id: 'gemini-2.5-flash', name: 'Gemini 2.5 Flash', maxTokens: 65536, contextWindow: 1048576 },
-  'gemini-2.5-flash-lite': { id: 'gemini-2.5-flash-lite', name: 'Gemini 2.5 Flash Lite', maxTokens: 65536, contextWindow: 1048576 },
-  // Deprecated — retiring June 1, 2026
-  'gemini-2.0-flash': { id: 'gemini-2.0-flash', name: 'Gemini 2.0 Flash', maxTokens: 8192, contextWindow: 1048576 },
-  'gemini-2.0-flash-lite': { id: 'gemini-2.0-flash-lite', name: 'Gemini 2.0 Flash Lite', maxTokens: 8192, contextWindow: 1048576 },
-};
-
-class GeminiProvider extends BaseProvider {
-  constructor(config = {}) {
-    super({
-      name: 'gemini',
-      baseUrl: config.baseUrl || 'https://generativelanguage.googleapis.com/v1beta/openai',
-      models: config.models || GEMINI_MODELS,
-      defaultModel: config.defaultModel || 'gemini-2.5-flash',
-      ...config,
-    });
-    this.timeout = config.timeout || 180000;
-    this.temperature = config.temperature ?? 0.2;
-  }
-
-  isConfigured() {
-    return !!this.getApiKey();
-  }
-
-  getApiKey() {
-    return process.env.GEMINI_API_KEY || process.env.GOOGLE_API_KEY || null;
-  }
-
-  _getHeaders() {
-    const key = this.getApiKey();
-    if (!key) throw new Error('GEMINI_API_KEY not set');
-    return {
-      Authorization: `Bearer ${key}`,
-      'Content-Type': 'application/json',
-    };
-  }
-
-  formatMessages(messages) {
-    return {
-      messages: messages.map((msg) => {
-        if (msg.role === 'assistant' && msg.tool_calls) {
-          return {
-            role: 'assistant',
-            content: msg.content || null,
-            tool_calls: msg.tool_calls.map((tc) => ({
-              id: tc.id || `call-${Date.now()}`,
-              type: 'function',
-              function: {
-                name: tc.function.name,
-                arguments:
-                  typeof tc.function.arguments === 'string'
-                    ? tc.function.arguments
-                    : JSON.stringify(tc.function.arguments),
-              },
-            })),
-          };
-        }
-        if (msg.role === 'tool') {
-          return {
-            role: 'tool',
-            content: typeof msg.content === 'string' ? msg.content : JSON.stringify(msg.content),
-            tool_call_id: msg.tool_call_id,
-          };
-        }
-        return { role: msg.role, content: msg.content };
-      }),
-    };
-  }
-
-  async chat(messages, tools, options = {}) {
-    const model = options.model || this.defaultModel;
-    const modelInfo = this.getModel(model);
-    const maxTokens = options.maxTokens || modelInfo?.maxTokens || 8192;
-    const { messages: formatted } = this.formatMessages(messages);
-
-    const body = {
-      model,
-      messages: formatted,
-      max_tokens: maxTokens,
-      temperature: options.temperature ?? this.temperature,
-    };
-
-    if (tools && tools.length > 0) {
-      body.tools = tools;
-    }
-
-    const response = await axios.post(`${this.baseUrl}/chat/completions`, body, {
-      timeout: options.timeout || this.timeout,
-      headers: this._getHeaders(),
-    });
-
-    return this.normalizeResponse(response.data);
-  }
-
-  async stream(messages, tools, options = {}) {
-    const model = options.model || this.defaultModel;
-    const modelInfo = this.getModel(model);
-    const maxTokens = options.maxTokens || modelInfo?.maxTokens || 8192;
-    const onToken = options.onToken || (() => {});
-    const { messages: formatted } = this.formatMessages(messages);
-
-    const body = {
-      model,
-      messages: formatted,
-      max_tokens: maxTokens,
-      temperature: options.temperature ?? this.temperature,
-      stream: true,
-    };
-
-    if (tools && tools.length > 0) {
-      body.tools = tools;
-    }
-
-    let response;
-    try {
-      response = await axios.post(`${this.baseUrl}/chat/completions`, body, {
-        timeout: options.timeout || this.timeout,
-        headers: this._getHeaders(),
-        responseType: 'stream',
-        signal: options.signal,
-      });
-    } catch (err) {
-      if (err.name === 'CanceledError' || err.name === 'AbortError' || err.code === 'ERR_CANCELED') throw err;
-      const msg = err.response?.data?.error?.message || err.message;
-      throw new Error(`API Error: ${msg}`);
-    }
-
-    return new Promise((resolve, reject) => {
-      let content = '';
-      const toolCallsMap = {}; // index -> { id, name, arguments }
-      let buffer = '';
-
-      // Abort listener: destroy stream on signal
-      if (options.signal) {
-        options.signal.addEventListener('abort', () => {
-          response.data.destroy();
-          reject(new DOMException('The operation was aborted', 'AbortError'));
-        }, { once: true });
-      }
-
-      response.data.on('data', (chunk) => {
-        buffer += chunk.toString();
-        const lines = buffer.split('\n');
-        buffer = lines.pop() || '';
-
-        for (const line of lines) {
-          const trimmed = line.trim();
-          if (!trimmed || !trimmed.startsWith('data: ')) continue;
-          const data = trimmed.slice(6);
-          if (data === '[DONE]') {
-            resolve({ content, tool_calls: this._buildToolCalls(toolCallsMap) });
-            return;
-          }
-
-          let parsed;
-          try {
-            parsed = JSON.parse(data);
-          } catch {
-            continue;
-          }
-
-          const delta = parsed.choices?.[0]?.delta;
-          if (!delta) continue;
-
-          if (delta.content) {
-            onToken(delta.content);
-            content += delta.content;
-          }
-
-          if (delta.tool_calls) {
-            for (const tc of delta.tool_calls) {
-              const idx = tc.index ?? 0;
-              if (!toolCallsMap[idx]) {
-                toolCallsMap[idx] = { id: tc.id || '', name: '', arguments: '' };
-              }
-              if (tc.id) toolCallsMap[idx].id = tc.id;
-              if (tc.function?.name) toolCallsMap[idx].name += tc.function.name;
-              if (tc.function?.arguments) toolCallsMap[idx].arguments += tc.function.arguments;
-            }
-          }
-        }
-      });
-
-      response.data.on('error', (err) => {
-        if (options.signal?.aborted) return; // Ignore errors after abort
-        reject(new Error(`Stream error: ${err.message}`));
-      });
-
-      response.data.on('end', () => {
-        resolve({ content, tool_calls: this._buildToolCalls(toolCallsMap) });
-      });
-    });
-  }
-
-  normalizeResponse(data) {
-    const choice = data.choices?.[0]?.message || {};
-    const toolCalls = (choice.tool_calls || []).map((tc) => ({
-      id: tc.id,
-      function: {
-        name: tc.function.name,
-        arguments: tc.function.arguments,
-      },
-    }));
-
-    return {
-      content: choice.content || '',
-      tool_calls: toolCalls,
-    };
-  }
-
-  _buildToolCalls(toolCallsMap) {
-    return Object.values(toolCallsMap)
-      .filter((tc) => tc.name)
-      .map((tc) => ({
-        id: tc.id || `gemini-${Date.now()}`,
-        function: {
-          name: tc.name,
-          arguments: tc.arguments,
-        },
-      }));
-  }
-}
-
-module.exports = { GeminiProvider, GEMINI_MODELS };