nex-code 0.3.0

package/cli/providers/local.js

@@ -0,0 +1,249 @@
+/**
+ * cli/providers/local.js — Local Ollama Server Provider
+ * Connects to localhost:11434 (default Ollama install). No auth required.
+ * Auto-detects available models via /api/tags.
+ */
+
+const axios = require('axios');
+const { BaseProvider } = require('./base');
+
+const DEFAULT_LOCAL_URL = 'http://localhost:11434';
+
+class LocalProvider extends BaseProvider {
+  constructor(config = {}) {
+    super({
+      name: 'local',
+      baseUrl: config.baseUrl || process.env.OLLAMA_HOST || process.env.OLLAMA_LOCAL_URL || DEFAULT_LOCAL_URL,
+      models: config.models || {},
+      defaultModel: config.defaultModel || null,
+      ...config,
+    });
+    this.timeout = config.timeout || 300000;
+    this.temperature = config.temperature ?? 0.2;
+    this._modelsLoaded = false;
+  }
+
+  isConfigured() {
+    return true; // No API key needed
+  }
+
+  /**
+   * Fetch available models from local Ollama server.
+   * Caches result after first call.
+   */
+  async loadModels() {
+    if (this._modelsLoaded) return this.models;
+
+    try {
+      const response = await axios.get(`${this.baseUrl}/api/tags`, { timeout: 5000 });
+      const tags = response.data?.models || [];
+
+      this.models = {};
+      for (const m of tags) {
+        const name = m.name || m.model;
+        if (!name) continue;
+        const id = name.replace(/:latest$/, '');
+
+        // Try to get actual context window from model metadata
+        let contextWindow = 32768; // Conservative fallback
+        try {
+          const showResp = await axios.post(
+            `${this.baseUrl}/api/show`,
+            { name },
+            { timeout: 5000 }
+          );
+          const params = showResp.data?.model_info || showResp.data?.details || {};
+          // Ollama exposes context length in model_info
+          contextWindow = params['general.context_length']
+            || params['llama.context_length']
+            || this._parseContextFromModelfile(showResp.data?.modelfile)
+            || 32768;
+        } catch {
+          // /api/show failed — use fallback
+        }
+
+        this.models[id] = {
+          id,
+          name: m.name,
+          maxTokens: Math.min(8192, Math.floor(contextWindow * 0.1)),
+          contextWindow,
+        };
+      }
+
+      if (!this.defaultModel && Object.keys(this.models).length > 0) {
+        this.defaultModel = Object.keys(this.models)[0];
+      }
+
+      this._modelsLoaded = true;
+    } catch {
+      // Server not running or unreachable
+      this.models = {};
+      this._modelsLoaded = false;
+    }
+
+    return this.models;
+  }
+
+  getModels() {
+    return this.models;
+  }
+
+  getModelNames() {
+    return Object.keys(this.models);
+  }
+
+  async chat(messages, tools, options = {}) {
+    if (!this._modelsLoaded) await this.loadModels();
+
+    const model = options.model || this.defaultModel;
+    if (!model) throw new Error('No local model available. Is Ollama running?');
+
+    const response = await axios.post(
+      `${this.baseUrl}/api/chat`,
+      {
+        model,
+        messages,
+        tools: tools && tools.length > 0 ? tools : undefined,
+        stream: false,
+        options: {
+          temperature: options.temperature ?? this.temperature,
+          num_predict: options.maxTokens || 8192,
+        },
+      },
+      { timeout: options.timeout || this.timeout }
+    );
+
+    return this.normalizeResponse(response.data);
+  }
+
+  async stream(messages, tools, options = {}) {
+    if (!this._modelsLoaded) await this.loadModels();
+
+    const model = options.model || this.defaultModel;
+    if (!model) throw new Error('No local model available. Is Ollama running?');
+    const onToken = options.onToken || (() => {});
+
+    let response;
+    try {
+      response = await axios.post(
+        `${this.baseUrl}/api/chat`,
+        {
+          model,
+          messages,
+          tools: tools && tools.length > 0 ? tools : undefined,
+          stream: true,
+          options: {
+            temperature: options.temperature ?? this.temperature,
+            num_predict: options.maxTokens || 8192,
+          },
+        },
+        {
+          timeout: options.timeout || this.timeout,
+          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 || err.message;
+      throw new Error(`API Error: ${msg}`);
+    }
+
+    return new Promise((resolve, reject) => {
+      let content = '';
+      let toolCalls = [];
+      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) {
+          if (!line.trim()) continue;
+          let parsed;
+          try {
+            parsed = JSON.parse(line);
+          } catch {
+            continue;
+          }
+
+          if (parsed.message?.content) {
+            onToken(parsed.message.content);
+            content += parsed.message.content;
+          }
+
+          if (parsed.message?.tool_calls) {
+            toolCalls = toolCalls.concat(parsed.message.tool_calls);
+          }
+
+          if (parsed.done) {
+            resolve({ content, tool_calls: this._normalizeToolCalls(toolCalls) });
+            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', () => {
+        if (buffer.trim()) {
+          try {
+            const parsed = JSON.parse(buffer);
+            if (parsed.message?.content) {
+              onToken(parsed.message.content);
+              content += parsed.message.content;
+            }
+            if (parsed.message?.tool_calls) {
+              toolCalls = toolCalls.concat(parsed.message.tool_calls);
+            }
+          } catch {
+            /* ignore */
+          }
+        }
+        resolve({ content, tool_calls: this._normalizeToolCalls(toolCalls) });
+      });
+    });
+  }
+
+  normalizeResponse(data) {
+    const msg = data.message || {};
+    return {
+      content: msg.content || '',
+      tool_calls: this._normalizeToolCalls(msg.tool_calls || []),
+    };
+  }
+
+  /**
+   * Parse num_ctx from Ollama modelfile string.
+   * Modelfiles contain lines like: PARAMETER num_ctx 131072
+   */
+  _parseContextFromModelfile(modelfile) {
+    if (!modelfile) return null;
+    const match = modelfile.match(/PARAMETER\s+num_ctx\s+(\d+)/i);
+    return match ? parseInt(match[1], 10) : null;
+  }
+
+  _normalizeToolCalls(toolCalls) {
+    return toolCalls.map((tc, i) => ({
+      id: tc.id || `local-${Date.now()}-${i}`,
+      function: {
+        name: tc.function?.name || tc.name || 'unknown',
+        arguments: tc.function?.arguments || tc.arguments || {},
+      },
+    }));
+  }
+}
+
+module.exports = { LocalProvider, DEFAULT_LOCAL_URL };

package/cli/providers/ollama.js

@@ -0,0 +1,214 @@
+/**
+ * cli/providers/ollama.js — Ollama Cloud Provider
+ * Connects to https://ollama.com API with Bearer auth and NDJSON streaming.
+ */
+
+const axios = require('axios');
+const { BaseProvider } = require('./base');
+
+const OLLAMA_MODELS = {
+  // Primary: Best coding model for agentic workflows
+  'qwen3-coder': { id: 'qwen3-coder', name: 'Qwen3 Coder', maxTokens: 16384, contextWindow: 131072 },
+  'qwen3-coder-next': { id: 'qwen3-coder-next', name: 'Qwen3 Coder Next', maxTokens: 16384, contextWindow: 131072 },
+  // Reasoning specialists
+  'deepseek-r1': { id: 'deepseek-r1', name: 'DeepSeek R1', maxTokens: 16384, contextWindow: 131072 },
+  'deepseek-r1:14b': { id: 'deepseek-r1:14b', name: 'DeepSeek R1 14B', maxTokens: 8192, contextWindow: 128000 },
+  // Agent-focused models
+  'devstral': { id: 'devstral', name: 'Devstral', maxTokens: 16384, contextWindow: 131072 },
+  'minimax-m2.5': { id: 'minimax-m2.5', name: 'MiniMax M2.5', maxTokens: 16384, contextWindow: 131072 },
+  'glm-4.7': { id: 'glm-4.7', name: 'GLM 4.7', maxTokens: 16384, contextWindow: 128000 },
+  // General purpose / large context fallback
+  'kimi-k2.5': { id: 'kimi-k2.5', name: 'Kimi K2.5', maxTokens: 16384, contextWindow: 256000 },
+  'llama4': { id: 'llama4', name: 'Llama 4 Scout', maxTokens: 16384, contextWindow: 131072 },
+  'qwen3:30b-a3b': { id: 'qwen3:30b-a3b', name: 'Qwen3 30B A3B', maxTokens: 16384, contextWindow: 131072 },
+};
+
+class OllamaProvider extends BaseProvider {
+  constructor(config = {}) {
+    super({
+      name: 'ollama',
+      baseUrl: config.baseUrl || 'https://ollama.com',
+      models: config.models || OLLAMA_MODELS,
+      defaultModel: config.defaultModel || 'qwen3-coder',
+      ...config,
+    });
+    this.timeout = config.timeout || 180000;
+    this.temperature = config.temperature ?? 0.2;
+    this._discovered = false;
+  }
+
+  /**
+   * Discover available models from the Ollama API.
+   * Merges discovered models with the hardcoded fallback list.
+   * Cached after first call.
+   */
+  async discoverModels() {
+    if (this._discovered) return;
+    this._discovered = true;
+    try {
+      const resp = await axios.get(`${this.baseUrl}/api/tags`, {
+        timeout: 5000, headers: this._getHeaders(),
+      });
+      const tags = resp.data?.models || [];
+      for (const m of tags) {
+        const id = (m.name || m.model || '').replace(/:latest$/, '');
+        if (!id || this.models[id]) continue;
+        this.models[id] = { id, name: m.name || id, maxTokens: 16384, contextWindow: 131072 };
+      }
+    } catch { /* API unavailable — use hardcoded list */ }
+  }
+
+  isConfigured() {
+    return !!this.getApiKey();
+  }
+
+  getApiKey() {
+    return process.env.OLLAMA_API_KEY || null;
+  }
+
+  _getHeaders() {
+    const key = this.getApiKey();
+    if (!key) throw new Error('OLLAMA_API_KEY not set');
+    return { Authorization: `Bearer ${key}` };
+  }
+
+  async chat(messages, tools, options = {}) {
+    await this.discoverModels();
+    const model = options.model || this.defaultModel;
+    const modelInfo = this.getModel(model);
+    const maxTokens = options.maxTokens || modelInfo?.maxTokens || 16384;
+
+    const response = await axios.post(
+      `${this.baseUrl}/api/chat`,
+      {
+        model,
+        messages,
+        tools: tools && tools.length > 0 ? tools : undefined,
+        stream: false,
+        options: { temperature: options.temperature ?? this.temperature, num_predict: maxTokens },
+      },
+      { timeout: options.timeout || this.timeout, headers: this._getHeaders() }
+    );
+
+    return this.normalizeResponse(response.data);
+  }
+
+  async stream(messages, tools, options = {}) {
+    await this.discoverModels();
+    const model = options.model || this.defaultModel;
+    const modelInfo = this.getModel(model);
+    const maxTokens = options.maxTokens || modelInfo?.maxTokens || 16384;
+    const onToken = options.onToken || (() => {});
+
+    let response;
+    try {
+      response = await axios.post(
+        `${this.baseUrl}/api/chat`,
+        {
+          model,
+          messages,
+          tools: tools && tools.length > 0 ? tools : undefined,
+          stream: true,
+          options: { temperature: options.temperature ?? this.temperature, num_predict: maxTokens },
+        },
+        {
+          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 || err.message;
+      throw new Error(`API Error: ${msg}`);
+    }
+
+    return new Promise((resolve, reject) => {
+      let content = '';
+      let toolCalls = [];
+      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) {
+          if (!line.trim()) continue;
+          let parsed;
+          try {
+            parsed = JSON.parse(line);
+          } catch {
+            continue;
+          }
+
+          if (parsed.message?.content) {
+            onToken(parsed.message.content);
+            content += parsed.message.content;
+          }
+
+          if (parsed.message?.tool_calls) {
+            toolCalls = toolCalls.concat(parsed.message.tool_calls);
+          }
+
+          if (parsed.done) {
+            resolve({ content, tool_calls: this._normalizeToolCalls(toolCalls) });
+            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', () => {
+        if (buffer.trim()) {
+          try {
+            const parsed = JSON.parse(buffer);
+            if (parsed.message?.content) {
+              onToken(parsed.message.content);
+              content += parsed.message.content;
+            }
+            if (parsed.message?.tool_calls) {
+              toolCalls = toolCalls.concat(parsed.message.tool_calls);
+            }
+          } catch {
+            /* ignore */
+          }
+        }
+        resolve({ content, tool_calls: this._normalizeToolCalls(toolCalls) });
+      });
+    });
+  }
+
+  normalizeResponse(data) {
+    const msg = data.message || {};
+    return {
+      content: msg.content || '',
+      tool_calls: this._normalizeToolCalls(msg.tool_calls || []),
+    };
+  }
+
+  _normalizeToolCalls(toolCalls) {
+    return toolCalls.map((tc, i) => ({
+      id: tc.id || `ollama-${Date.now()}-${i}`,
+      function: {
+        name: tc.function?.name || tc.name || 'unknown',
+        arguments: tc.function?.arguments || tc.arguments || {},
+      },
+    }));
+  }
+}
+
+module.exports = { OllamaProvider, OLLAMA_MODELS };

package/cli/providers/openai.js

@@ -0,0 +1,237 @@
+/**
+ * cli/providers/openai.js — OpenAI-compatible Provider
+ * Supports GPT-4o, o1, o3, GPT-4o-mini via OpenAI API with SSE streaming.
+ */
+
+const axios = require('axios');
+const { BaseProvider } = require('./base');
+
+const OPENAI_MODELS = {
+  'gpt-4o': { id: 'gpt-4o', name: 'GPT-4o', maxTokens: 16384, contextWindow: 128000 },
+  'gpt-4o-mini': { id: 'gpt-4o-mini', name: 'GPT-4o Mini', maxTokens: 16384, contextWindow: 128000 },
+  'gpt-4.1': { id: 'gpt-4.1', name: 'GPT-4.1', maxTokens: 32768, contextWindow: 128000 },
+  'gpt-4.1-mini': { id: 'gpt-4.1-mini', name: 'GPT-4.1 Mini', maxTokens: 32768, contextWindow: 128000 },
+  'gpt-4.1-nano': { id: 'gpt-4.1-nano', name: 'GPT-4.1 Nano', maxTokens: 16384, contextWindow: 128000 },
+  'o1': { id: 'o1', name: 'o1', maxTokens: 100000, contextWindow: 200000 },
+  'o3': { id: 'o3', name: 'o3', maxTokens: 100000, contextWindow: 200000 },
+  'o3-mini': { id: 'o3-mini', name: 'o3 Mini', maxTokens: 65536, contextWindow: 200000 },
+  'o4-mini': { id: 'o4-mini', name: 'o4 Mini', maxTokens: 100000, contextWindow: 200000 },
+};
+
+class OpenAIProvider extends BaseProvider {
+  constructor(config = {}) {
+    super({
+      name: 'openai',
+      baseUrl: config.baseUrl || 'https://api.openai.com/v1',
+      models: config.models || OPENAI_MODELS,
+      defaultModel: config.defaultModel || 'gpt-4o',
+      ...config,
+    });
+    this.timeout = config.timeout || 180000;
+    this.temperature = config.temperature ?? 0.2;
+  }
+
+  isConfigured() {
+    return !!this.getApiKey();
+  }
+
+  getApiKey() {
+    return process.env.OPENAI_API_KEY || null;
+  }
+
+  _getHeaders() {
+    const key = this.getApiKey();
+    if (!key) throw new Error('OPENAI_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 || 16384;
+    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 || 16384;
+    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 || `openai-${Date.now()}`,
+        function: {
+          name: tc.name,
+          arguments: tc.arguments,
+        },
+      }));
+  }
+}
+
+module.exports = { OpenAIProvider, OPENAI_MODELS };