ultra-dex 1.8.0 → 2.2.1

package/lib/config/urls.js

@@ -0,0 +1,16 @@
+export const GITHUB_REPO = 'Srujan0798/Ultra-Dex';
+export const GITHUB_WEB_BASE = `https://github.com/${GITHUB_REPO}`;
+export const GITHUB_RAW_BASE = `https://raw.githubusercontent.com/${GITHUB_REPO}/main`;
+
+export function githubBlobUrl(pathname) {
+  return `${GITHUB_WEB_BASE}/blob/main/${pathname}`;
+}
+
+export function githubTreeUrl(pathname) {
+  return `${GITHUB_WEB_BASE}/tree/main/${pathname}`;
+}
+
+export function githubWebUrl(pathname = '') {
+  if (!pathname) return GITHUB_WEB_BASE;
+  return `${GITHUB_WEB_BASE}/${pathname}`;
+}

package/lib/providers/base.js

@@ -0,0 +1,82 @@
+/**
+ * Base AI Provider Interface
+ * All providers (Claude, OpenAI, Gemini) must implement this interface
+ */
+
+export class BaseProvider {
+  constructor(apiKey, options = {}) {
+    if (new.target === BaseProvider) {
+      throw new Error('BaseProvider is abstract and cannot be instantiated directly');
+    }
+    this.apiKey = apiKey;
+    this.model = options.model || this.getDefaultModel();
+    this.maxTokens = options.maxTokens || 8192;
+  }
+
+  /**
+   * Get the default model for this provider
+   * @returns {string} Default model identifier
+   */
+  getDefaultModel() {
+    throw new Error('getDefaultModel() must be implemented by subclass');
+  }
+
+  /**
+   * Get available models for this provider
+   * @returns {Array<{id: string, name: string, maxTokens: number}>}
+   */
+  getAvailableModels() {
+    throw new Error('getAvailableModels() must be implemented by subclass');
+  }
+
+  /**
+   * Estimate the cost for a given number of tokens
+   * @param {number} inputTokens - Number of input tokens
+   * @param {number} outputTokens - Number of output tokens
+   * @returns {{input: number, output: number, total: number}} Cost in USD
+   */
+  estimateCost(inputTokens, outputTokens) {
+    throw new Error('estimateCost() must be implemented by subclass');
+  }
+
+  /**
+   * Generate a completion from the AI model
+   * @param {string} systemPrompt - System instructions
+   * @param {string} userPrompt - User message/request
+   * @param {Object} options - Additional options
+   * @returns {Promise<{content: string, usage: {inputTokens: number, outputTokens: number}}>}
+   */
+  async generate(systemPrompt, userPrompt, options = {}) {
+    throw new Error('generate() must be implemented by subclass');
+  }
+
+  /**
+   * Generate a completion with streaming support
+   * @param {string} systemPrompt - System instructions
+   * @param {string} userPrompt - User message/request
+   * @param {Function} onChunk - Callback for each chunk: (text: string) => void
+   * @param {Object} options - Additional options
+   * @returns {Promise<{content: string, usage: {inputTokens: number, outputTokens: number}}>}
+   */
+  async generateStream(systemPrompt, userPrompt, onChunk, options = {}) {
+    throw new Error('generateStream() must be implemented by subclass');
+  }
+
+  /**
+   * Validate that the API key is configured and working
+   * @returns {Promise<boolean>}
+   */
+  async validateApiKey() {
+    throw new Error('validateApiKey() must be implemented by subclass');
+  }
+
+  /**
+   * Get the provider name
+   * @returns {string}
+   */
+  getName() {
+    throw new Error('getName() must be implemented by subclass');
+  }
+}
+
+export default BaseProvider;

package/lib/providers/claude.js

@@ -0,0 +1,177 @@
+/**
+ * Claude AI Provider (Anthropic)
+ * Primary provider for Ultra-Dex generate command
+ */
+
+import { BaseProvider } from './base.js';
+
+// Model pricing per 1M tokens (as of Jan 2026)
+const PRICING = {
+  'claude-sonnet-4-20250514': { input: 3.00, output: 15.00 },
+  'claude-3-5-sonnet-20241022': { input: 3.00, output: 15.00 },
+  'claude-3-opus-20240229': { input: 15.00, output: 75.00 },
+  'claude-3-haiku-20240307': { input: 0.25, output: 1.25 },
+};
+
+const MODELS = [
+  { id: 'claude-sonnet-4-20250514', name: 'Claude Sonnet 4 (Latest)', maxTokens: 8192, default: true },
+  { id: 'claude-3-5-sonnet-20241022', name: 'Claude 3.5 Sonnet', maxTokens: 8192 },
+  { id: 'claude-3-opus-20240229', name: 'Claude 3 Opus (Premium)', maxTokens: 4096 },
+  { id: 'claude-3-haiku-20240307', name: 'Claude 3 Haiku (Fast)', maxTokens: 4096 },
+];
+
+export class ClaudeProvider extends BaseProvider {
+  constructor(apiKey, options = {}) {
+    super(apiKey, options);
+    this.baseUrl = 'https://api.anthropic.com/v1';
+    this.apiVersion = '2023-06-01';
+  }
+
+  getName() {
+    return 'Claude (Anthropic)';
+  }
+
+  getDefaultModel() {
+    return 'claude-sonnet-4-20250514';
+  }
+
+  getAvailableModels() {
+    return MODELS;
+  }
+
+  estimateCost(inputTokens, outputTokens) {
+    const pricing = PRICING[this.model] || PRICING['claude-sonnet-4-20250514'];
+    const inputCost = (inputTokens / 1_000_000) * pricing.input;
+    const outputCost = (outputTokens / 1_000_000) * pricing.output;
+    return {
+      input: inputCost,
+      output: outputCost,
+      total: inputCost + outputCost,
+    };
+  }
+
+  async generate(systemPrompt, userPrompt, options = {}) {
+    const response = await fetch(`${this.baseUrl}/messages`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'x-api-key': this.apiKey,
+        'anthropic-version': this.apiVersion,
+      },
+      body: JSON.stringify({
+        model: this.model,
+        max_tokens: options.maxTokens || this.maxTokens,
+        system: systemPrompt,
+        messages: [
+          { role: 'user', content: userPrompt }
+        ],
+      }),
+    });
+
+    if (!response.ok) {
+      const error = await response.json().catch(() => ({}));
+      throw new Error(`Claude API error: ${error.error?.message || response.statusText}`);
+    }
+
+    const data = await response.json();
+    
+    return {
+      content: data.content[0]?.text || '',
+      usage: {
+        inputTokens: data.usage?.input_tokens || 0,
+        outputTokens: data.usage?.output_tokens || 0,
+      },
+    };
+  }
+
+  async generateStream(systemPrompt, userPrompt, onChunk, options = {}) {
+    const response = await fetch(`${this.baseUrl}/messages`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'x-api-key': this.apiKey,
+        'anthropic-version': this.apiVersion,
+      },
+      body: JSON.stringify({
+        model: this.model,
+        max_tokens: options.maxTokens || this.maxTokens,
+        stream: true,
+        system: systemPrompt,
+        messages: [
+          { role: 'user', content: userPrompt }
+        ],
+      }),
+    });
+
+    if (!response.ok) {
+      const error = await response.json().catch(() => ({}));
+      throw new Error(`Claude API error: ${error.error?.message || response.statusText}`);
+    }
+
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let fullContent = '';
+    let usage = { inputTokens: 0, outputTokens: 0 };
+
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+
+      const chunk = decoder.decode(value);
+      const lines = chunk.split('\n');
+
+      for (const line of lines) {
+        if (line.startsWith('data: ')) {
+          const data = line.slice(6);
+          if (data === '[DONE]') continue;
+
+          try {
+            const parsed = JSON.parse(data);
+            
+            if (parsed.type === 'content_block_delta' && parsed.delta?.text) {
+              fullContent += parsed.delta.text;
+              onChunk(parsed.delta.text);
+            }
+            
+            if (parsed.type === 'message_delta' && parsed.usage) {
+              usage.outputTokens = parsed.usage.output_tokens || 0;
+            }
+            
+            if (parsed.type === 'message_start' && parsed.message?.usage) {
+              usage.inputTokens = parsed.message.usage.input_tokens || 0;
+            }
+          } catch {
+            // Skip malformed JSON
+          }
+        }
+      }
+    }
+
+    return { content: fullContent, usage };
+  }
+
+  async validateApiKey() {
+    try {
+      // Make a minimal request to check API key validity
+      const response = await fetch(`${this.baseUrl}/messages`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'x-api-key': this.apiKey,
+          'anthropic-version': this.apiVersion,
+        },
+        body: JSON.stringify({
+          model: 'claude-3-haiku-20240307',
+          max_tokens: 10,
+          messages: [{ role: 'user', content: 'Hi' }],
+        }),
+      });
+
+      return response.ok || response.status === 400; // 400 is OK, means key is valid but request malformed
+    } catch {
+      return false;
+    }
+  }
+}
+
+export default ClaudeProvider;

package/lib/providers/gemini.js

@@ -0,0 +1,170 @@
+/**
+ * Google Gemini Provider
+ * Gemini models for Ultra-Dex generate command
+ */
+
+import { BaseProvider } from './base.js';
+
+// Model pricing per 1M tokens (as of Jan 2026)
+const PRICING = {
+  'gemini-1.5-pro': { input: 1.25, output: 5.00 },
+  'gemini-1.5-flash': { input: 0.075, output: 0.30 },
+  'gemini-2.0-flash-exp': { input: 0.10, output: 0.40 },
+};
+
+const MODELS = [
+  { id: 'gemini-1.5-pro', name: 'Gemini 1.5 Pro', maxTokens: 8192, default: true },
+  { id: 'gemini-1.5-flash', name: 'Gemini 1.5 Flash (Fast)', maxTokens: 8192 },
+  { id: 'gemini-2.0-flash-exp', name: 'Gemini 2.0 Flash (Experimental)', maxTokens: 8192 },
+];
+
+export class GeminiProvider extends BaseProvider {
+  constructor(apiKey, options = {}) {
+    super(apiKey, options);
+    this.baseUrl = 'https://generativelanguage.googleapis.com/v1beta';
+  }
+
+  getName() {
+    return 'Google Gemini';
+  }
+
+  getDefaultModel() {
+    return 'gemini-1.5-pro';
+  }
+
+  getAvailableModels() {
+    return MODELS;
+  }
+
+  estimateCost(inputTokens, outputTokens) {
+    const pricing = PRICING[this.model] || PRICING['gemini-1.5-pro'];
+    const inputCost = (inputTokens / 1_000_000) * pricing.input;
+    const outputCost = (outputTokens / 1_000_000) * pricing.output;
+    return {
+      input: inputCost,
+      output: outputCost,
+      total: inputCost + outputCost,
+    };
+  }
+
+  async generate(systemPrompt, userPrompt, options = {}) {
+    const url = `${this.baseUrl}/models/${this.model}:generateContent?key=${this.apiKey}`;
+    
+    const response = await fetch(url, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({
+        systemInstruction: {
+          parts: [{ text: systemPrompt }],
+        },
+        contents: [
+          {
+            role: 'user',
+            parts: [{ text: userPrompt }],
+          },
+        ],
+        generationConfig: {
+          maxOutputTokens: options.maxTokens || this.maxTokens,
+        },
+      }),
+    });
+
+    if (!response.ok) {
+      const error = await response.json().catch(() => ({}));
+      throw new Error(`Gemini API error: ${error.error?.message || response.statusText}`);
+    }
+
+    const data = await response.json();
+    const content = data.candidates?.[0]?.content?.parts?.[0]?.text || '';
+    
+    return {
+      content,
+      usage: {
+        inputTokens: data.usageMetadata?.promptTokenCount || 0,
+        outputTokens: data.usageMetadata?.candidatesTokenCount || 0,
+      },
+    };
+  }
+
+  async generateStream(systemPrompt, userPrompt, onChunk, options = {}) {
+    const url = `${this.baseUrl}/models/${this.model}:streamGenerateContent?key=${this.apiKey}&alt=sse`;
+    
+    const response = await fetch(url, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({
+        systemInstruction: {
+          parts: [{ text: systemPrompt }],
+        },
+        contents: [
+          {
+            role: 'user',
+            parts: [{ text: userPrompt }],
+          },
+        ],
+        generationConfig: {
+          maxOutputTokens: options.maxTokens || this.maxTokens,
+        },
+      }),
+    });
+
+    if (!response.ok) {
+      const error = await response.json().catch(() => ({}));
+      throw new Error(`Gemini API error: ${error.error?.message || response.statusText}`);
+    }
+
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let fullContent = '';
+    let usage = { inputTokens: 0, outputTokens: 0 };
+
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+
+      const chunk = decoder.decode(value);
+      const lines = chunk.split('\n');
+
+      for (const line of lines) {
+        if (line.startsWith('data: ')) {
+          const data = line.slice(6);
+          
+          try {
+            const parsed = JSON.parse(data);
+            
+            const text = parsed.candidates?.[0]?.content?.parts?.[0]?.text;
+            if (text) {
+              fullContent += text;
+              onChunk(text);
+            }
+            
+            if (parsed.usageMetadata) {
+              usage.inputTokens = parsed.usageMetadata.promptTokenCount || 0;
+              usage.outputTokens = parsed.usageMetadata.candidatesTokenCount || 0;
+            }
+          } catch {
+            // Skip malformed JSON
+          }
+        }
+      }
+    }
+
+    return { content: fullContent, usage };
+  }
+
+  async validateApiKey() {
+    try {
+      const url = `${this.baseUrl}/models?key=${this.apiKey}`;
+      const response = await fetch(url);
+      return response.ok;
+    } catch {
+      return false;
+    }
+  }
+}
+
+export default GeminiProvider;

package/lib/providers/index.js

@@ -0,0 +1,93 @@
+/**
+ * AI Provider Factory
+ * Creates and manages AI providers for the generate command
+ */
+
+import { ClaudeProvider } from './claude.js';
+import { OpenAIProvider } from './openai.js';
+import { GeminiProvider } from './gemini.js';
+
+const PROVIDERS = {
+  claude: {
+    class: ClaudeProvider,
+    envKey: 'ANTHROPIC_API_KEY',
+    name: 'Claude (Anthropic)',
+  },
+  openai: {
+    class: OpenAIProvider,
+    envKey: 'OPENAI_API_KEY',
+    name: 'OpenAI',
+  },
+  gemini: {
+    class: GeminiProvider,
+    envKey: 'GOOGLE_AI_KEY',
+    name: 'Google Gemini',
+  },
+};
+
+/**
+ * Get the list of available providers
+ * @returns {Array<{id: string, name: string, envKey: string}>}
+ */
+export function getAvailableProviders() {
+  return Object.entries(PROVIDERS).map(([id, config]) => ({
+    id,
+    name: config.name,
+    envKey: config.envKey,
+  }));
+}
+
+/**
+ * Create an AI provider instance
+ * @param {string} providerId - Provider identifier (claude, openai, gemini)
+ * @param {Object} options - Provider options
+ * @param {string} options.apiKey - API key (optional, will use env var if not provided)
+ * @param {string} options.model - Model to use (optional)
+ * @returns {BaseProvider}
+ */
+export function createProvider(providerId, options = {}) {
+  const providerConfig = PROVIDERS[providerId];
+  
+  if (!providerConfig) {
+    throw new Error(`Unknown provider: ${providerId}. Available: ${Object.keys(PROVIDERS).join(', ')}`);
+  }
+
+  // Get API key from options or environment
+  const apiKey = options.apiKey || process.env[providerConfig.envKey];
+  
+  if (!apiKey) {
+    throw new Error(
+      `API key not found for ${providerConfig.name}.\n` +
+      `Set the ${providerConfig.envKey} environment variable or use --key option.`
+    );
+  }
+
+  return new providerConfig.class(apiKey, options);
+}
+
+/**
+ * Get the default provider based on available API keys
+ * @returns {string|null} Provider ID or null if none available
+ */
+export function getDefaultProvider() {
+  // Check environment variables in order of preference
+  if (process.env.ANTHROPIC_API_KEY) return 'claude';
+  if (process.env.OPENAI_API_KEY) return 'openai';
+  if (process.env.GOOGLE_AI_KEY) return 'gemini';
+  return null;
+}
+
+/**
+ * Check which providers have API keys configured
+ * @returns {Array<{id: string, name: string, configured: boolean}>}
+ */
+export function checkConfiguredProviders() {
+  return Object.entries(PROVIDERS).map(([id, config]) => ({
+    id,
+    name: config.name,
+    envKey: config.envKey,
+    configured: !!process.env[config.envKey],
+  }));
+}
+
+export { ClaudeProvider, OpenAIProvider, GeminiProvider };

package/lib/providers/openai.js

@@ -0,0 +1,163 @@
+/**
+ * OpenAI Provider
+ * GPT models for Ultra-Dex generate command
+ */
+
+import { BaseProvider } from './base.js';
+
+// Model pricing per 1M tokens (as of Jan 2026)
+const PRICING = {
+  'gpt-4o': { input: 2.50, output: 10.00 },
+  'gpt-4o-mini': { input: 0.15, output: 0.60 },
+  'gpt-4-turbo': { input: 10.00, output: 30.00 },
+  'gpt-4': { input: 30.00, output: 60.00 },
+};
+
+const MODELS = [
+  { id: 'gpt-4o', name: 'GPT-4o (Latest)', maxTokens: 16384, default: true },
+  { id: 'gpt-4o-mini', name: 'GPT-4o Mini (Fast)', maxTokens: 16384 },
+  { id: 'gpt-4-turbo', name: 'GPT-4 Turbo', maxTokens: 4096 },
+  { id: 'gpt-4', name: 'GPT-4', maxTokens: 8192 },
+];
+
+export class OpenAIProvider extends BaseProvider {
+  constructor(apiKey, options = {}) {
+    super(apiKey, options);
+    this.baseUrl = 'https://api.openai.com/v1';
+  }
+
+  getName() {
+    return 'OpenAI';
+  }
+
+  getDefaultModel() {
+    return 'gpt-4o';
+  }
+
+  getAvailableModels() {
+    return MODELS;
+  }
+
+  estimateCost(inputTokens, outputTokens) {
+    const pricing = PRICING[this.model] || PRICING['gpt-4o'];
+    const inputCost = (inputTokens / 1_000_000) * pricing.input;
+    const outputCost = (outputTokens / 1_000_000) * pricing.output;
+    return {
+      input: inputCost,
+      output: outputCost,
+      total: inputCost + outputCost,
+    };
+  }
+
+  async generate(systemPrompt, userPrompt, options = {}) {
+    const response = await fetch(`${this.baseUrl}/chat/completions`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Authorization': `Bearer ${this.apiKey}`,
+      },
+      body: JSON.stringify({
+        model: this.model,
+        max_tokens: options.maxTokens || this.maxTokens,
+        messages: [
+          { role: 'system', content: systemPrompt },
+          { role: 'user', content: userPrompt },
+        ],
+      }),
+    });
+
+    if (!response.ok) {
+      const error = await response.json().catch(() => ({}));
+      throw new Error(`OpenAI API error: ${error.error?.message || response.statusText}`);
+    }
+
+    const data = await response.json();
+    
+    return {
+      content: data.choices[0]?.message?.content || '',
+      usage: {
+        inputTokens: data.usage?.prompt_tokens || 0,
+        outputTokens: data.usage?.completion_tokens || 0,
+      },
+    };
+  }
+
+  async generateStream(systemPrompt, userPrompt, onChunk, options = {}) {
+    const response = await fetch(`${this.baseUrl}/chat/completions`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Authorization': `Bearer ${this.apiKey}`,
+      },
+      body: JSON.stringify({
+        model: this.model,
+        max_tokens: options.maxTokens || this.maxTokens,
+        stream: true,
+        stream_options: { include_usage: true },
+        messages: [
+          { role: 'system', content: systemPrompt },
+          { role: 'user', content: userPrompt },
+        ],
+      }),
+    });
+
+    if (!response.ok) {
+      const error = await response.json().catch(() => ({}));
+      throw new Error(`OpenAI API error: ${error.error?.message || response.statusText}`);
+    }
+
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let fullContent = '';
+    let usage = { inputTokens: 0, outputTokens: 0 };
+
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+
+      const chunk = decoder.decode(value);
+      const lines = chunk.split('\n');
+
+      for (const line of lines) {
+        if (line.startsWith('data: ')) {
+          const data = line.slice(6);
+          if (data === '[DONE]') continue;
+
+          try {
+            const parsed = JSON.parse(data);
+            
+            const content = parsed.choices?.[0]?.delta?.content;
+            if (content) {
+              fullContent += content;
+              onChunk(content);
+            }
+            
+            if (parsed.usage) {
+              usage.inputTokens = parsed.usage.prompt_tokens || 0;
+              usage.outputTokens = parsed.usage.completion_tokens || 0;
+            }
+          } catch {
+            // Skip malformed JSON
+          }
+        }
+      }
+    }
+
+    return { content: fullContent, usage };
+  }
+
+  async validateApiKey() {
+    try {
+      const response = await fetch(`${this.baseUrl}/models`, {
+        headers: {
+          'Authorization': `Bearer ${this.apiKey}`,
+        },
+      });
+      return response.ok;
+    } catch {
+      return false;
+    }
+  }
+}
+
+export default OpenAIProvider;