@anh3d0nic/qwen-code-termux-ice 14.0.0 → 16.0.0

package/bin/api-setup-launcher.js

@@ -0,0 +1,14 @@
+#!/usr/bin/env node
+const { execSync } = require('child_process');
+const path = require('path');
+
+const ICE_HOME = '/data/data/com.termux/files/.qwen-ice';
+const isTermux = process.env.PREFIX?.includes('com.termux') || process.env.TERMUX_VERSION !== undefined;
+const actualIceHome = isTermux ? ICE_HOME : path.join(process.env.HOME || '~', '.qwen-ice');
+
+try {
+  execSync(`node "${path.join(actualIceHome, 'bin', 'qwen-ice-api-setup')}"`, { stdio: 'inherit' });
+} catch (e) {
+  console.error('❌ Qwen ICE not installed. Run: npm install -g @anh3d0nic/qwen-code-termux-ice');
+  process.exit(1);
+}

package/bin/qwen-ice

@@ -0,0 +1,350 @@
+#!/data/data/com.termux/files/usr/bin/node
+/**
+ * ❄️ Qwen Code ICE v16.0.0 — Main Binary
+ */
+
+const fs = require('fs');
+const path = require('path');
+const readline = require('readline');
+const { spawn } = require('child_process');
+
+const VERSION = '16.0.0';
+const INSTALL_DIR = '/data/data/com.termux/files/.qwen-ice';
+const CONFIG_DIR = path.join(INSTALL_DIR, 'config');
+const MEMORY_DIR = path.join(INSTALL_DIR, 'memory');
+const LOGS_DIR = path.join(INSTALL_DIR, 'logs');
+const SCRIPTS_DIR = path.join(INSTALL_DIR, 'scripts');
+const CORE_DIR = path.join(INSTALL_DIR, 'core');
+
+const API_KEYS_FILE = path.join(CONFIG_DIR, 'api-keys.json');
+const SESSION_MEMORY_FILE = path.join(MEMORY_DIR, 'session_memory.json');
+const QUALITY_HISTORY_FILE = path.join(MEMORY_DIR, 'quality_history.json');
+const SESSION_SUMMARY_FILE = path.join(MEMORY_DIR, 'session_summary.json');
+const YOLO_LOG = path.join(LOGS_DIR, 'yolo.log');
+
+// Parse CLI arguments
+const args = process.argv.slice(2);
+const yolo = args.includes('-y') || args.includes('--yolo');
+const versionFlag = args.includes('--version');
+const helpFlag = args.includes('--help');
+const statusFlag = args.includes('--status');
+const modelIndex = args.indexOf('--model');
+const selectedModel = modelIndex > -1 ? args[modelIndex + 1] : null;
+
+const command = args.find(arg => !arg.startsWith('-') && args.indexOf(arg) !== modelIndex && args.indexOf(arg) !== modelIndex + 1);
+
+function ensureDirs() {
+  [CONFIG_DIR, MEMORY_DIR, LOGS_DIR].forEach(dir => {
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+  });
+}
+
+function loadApiConfig() {
+  try {
+    if (fs.existsSync(API_KEYS_FILE)) {
+      return JSON.parse(fs.readFileSync(API_KEYS_FILE, 'utf8'));
+    }
+  } catch (err) {}
+  return {
+    keys: [{
+      id: 'qwen-oauth',
+      provider: 'qwen',
+      type: 'oauth',
+      model: 'qwen3-coder-plus',
+      active: true,
+      note: 'Uses existing Qwen OAuth — do not modify'
+    }],
+    default_provider: 'qwen',
+    fallback_order: ['qwen', 'gemini', 'groq', 'openai', 'dashscope']
+  };
+}
+
+function loadSessionMemory() {
+  try {
+    if (fs.existsSync(SESSION_MEMORY_FILE)) {
+      return JSON.parse(fs.readFileSync(SESSION_MEMORY_FILE, 'utf8'));
+    }
+  } catch (err) {}
+  return { patterns: [], known_errors: [] };
+}
+
+function loadQualityHistory() {
+  try {
+    if (fs.existsSync(QUALITY_HISTORY_FILE)) {
+      return JSON.parse(fs.readFileSync(QUALITY_HISTORY_FILE, 'utf8'));
+    }
+  } catch (err) {}
+  return { scores: [] };
+}
+
+function loadSessionSummary() {
+  try {
+    if (fs.existsSync(SESSION_SUMMARY_FILE)) {
+      return JSON.parse(fs.readFileSync(SESSION_SUMMARY_FILE, 'utf8'));
+    }
+  } catch (err) {}
+  return { last_session: null, total_queries: 0, total_errors: 0 };
+}
+
+function logYolo(message) {
+  if (yolo) {
+    const timestamp = new Date().toISOString();
+    const logLine = `[${timestamp}] ${message}\n`;
+    try { fs.appendFileSync(YOLO_LOG, logLine); } catch (e) {}
+  }
+}
+
+function printVersion() {
+  const config = loadApiConfig();
+  const memory = loadSessionMemory();
+  const quality = loadQualityHistory();
+  const summary = loadSessionSummary();
+
+  const providers = [...new Set((config.keys || []).map(k => k.provider))];
+  const avgQuality = quality.scores.length > 0
+    ? (quality.scores.reduce((a, b) => a + b, 0) / quality.scores.length).toFixed(1)
+    : 'N/A';
+
+  console.log(`
+❄️  Qwen Code ICE v${VERSION}
+📍 ${INSTALL_DIR}/
+🤖 Default model: ${config.keys?.find(k => k.provider === config.default_provider)?.model || 'qwen3-coder-plus'} (OAuth)
+🔑 APIs configured: ${providers.join(', ')}
+🔄 Fallback order: ${config.fallback_order.join(' → ')}
+🧠 Memory: ${memory.patterns?.length || 0} patterns learned
+📊 Avg quality: ${avgQuality}/10 (last ${quality.scores.length} sessions)
+📅 Built: 2026-03-22
+`);
+}
+
+function printHelp() {
+  console.log(`
+❄️  Qwen Code ICE v${VERSION} — Help
+
+USAGE:
+  qwen-ice                    Interactive mode
+  qwen-ice "query"            Single query
+  qwen-ice [options]          With options
+
+OPTIONS:
+  --version                   Show version info
+  --help                      Show this help
+  --status                    Show pipeline status
+  -y, --yolo                  YOLO mode (auto-approve all)
+  --model <provider>          Use specific model (qwen, groq, gemini, openai, dashscope)
+
+COMMANDS:
+  api-setup                   API key manager
+  status                      Show status (keys, models, memory)
+  reset                       Clear memory (keep API keys)
+  uninstall                   Clean uninstall with backup
+
+EXAMPLES:
+  qwen-ice "fix this error"   Run single query
+  qwen-ice -y "npm install"   YOLO mode (auto-approve)
+  qwen-ice --model groq       Use Groq provider
+  qwen-ice api-setup          Configure API keys
+  qwen-ice status             Check status
+`);
+}
+
+function printStatus() {
+  const config = loadApiConfig();
+  const memory = loadSessionMemory();
+  const quality = loadQualityHistory();
+  const summary = loadSessionSummary();
+
+  const avgQuality = quality.scores.length > 0
+    ? (quality.scores.reduce((a, b) => a + b, 0) / quality.scores.length).toFixed(1)
+    : 'N/A';
+
+  const getDirSize = (dir) => {
+    if (!fs.existsSync(dir)) return 0;
+    let size = 0;
+    try {
+      const entries = fs.readdirSync(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        const filePath = path.join(dir, entry.name);
+        if (entry.isDirectory()) size += getDirSize(filePath);
+        else size += fs.statSync(filePath).size;
+      }
+    } catch (e) {}
+    return size;
+  };
+
+  const configSize = (getDirSize(CONFIG_DIR) / 1024).toFixed(1);
+  const memorySize = (getDirSize(MEMORY_DIR) / 1024).toFixed(1);
+  const logsSize = (getDirSize(LOGS_DIR) / 1024).toFixed(1);
+
+  console.log(`
+❄️  Qwen Code ICE v${VERSION} — Status
+
+API KEYS:
+`);
+
+  for (const key of config.keys || []) {
+    const status = key.active ? '✅' : '❌';
+    const label = key.type === 'oauth' ? '(OAuth)' : '';
+    const calls = key.call_count || 0;
+    const lastUsed = key.last_used ? new Date(key.last_used).toLocaleDateString() : 'never';
+    const invalidMark = !key.active && key.type !== 'oauth' ? ' (invalid key - run api-setup to fix)' : '';
+    console.log(`${status} ${key.id.padEnd(15)} ${label.padEnd(8)} — active, ${calls} calls${invalidMark}`);
+    if (key.last_used) console.log(`   last used: ${lastUsed}`);
+  }
+
+  console.log(`
+MEMORY:
+🧠 Patterns learned: ${memory.patterns?.length || 0}
+⚠️  Known errors: ${memory.known_errors?.length || 0}
+📊 Avg quality score: ${avgQuality}/10
+🕐 Last session: ${summary.last_session || 'N/A'}
+
+INSTALL:
+📁 ${INSTALL_DIR}/
+💾 Config: ${configSize} KB
+🗃️  Memory: ${memorySize} KB
+📋 Logs: ${logsSize} KB
+
+PIPELINE:
+  1. ColdStartIntelligence
+  2. PatternPreventer
+  3. IntentLadder
+  4. ConfidenceGating
+  5. SmartContext
+  6. ApiRouter
+  7. SelfCritiqueLoop
+  8. CodeQualityGate
+  9. AutoRunLoop
+ 10. QualityBlocker
+ 11. DomainMemory
+ 12. QualityScorer
+ 13. ConfidenceRecord
+ 14. SessionSummary
+`);
+}
+
+function runApiSetup() {
+  const scriptPath = path.join(INSTALL_DIR, 'bin', 'qwen-ice-api-setup');
+  if (!fs.existsSync(scriptPath)) {
+    console.error('❌ api-setup not found. Reinstall ICE.');
+    return;
+  }
+  const child = spawn('node', [scriptPath], { stdio: 'inherit' });
+  child.on('close', (code) => process.exit(code));
+}
+
+function runUninstall() {
+  const scriptPath = path.join(CORE_DIR, 'uninstall.js');
+  if (!fs.existsSync(scriptPath)) {
+    console.error('❌ uninstall.js not found. Reinstall ICE.');
+    return;
+  }
+  const child = spawn('node', [scriptPath], { stdio: 'inherit' });
+  child.on('close', (code) => process.exit(code));
+}
+
+function resetMemory() {
+  console.log('❄️  Resetting memory...\n');
+  const emptyMemory = { patterns: [], known_errors: [], last_updated: new Date().toISOString() };
+  try {
+    fs.writeFileSync(SESSION_MEMORY_FILE, JSON.stringify(emptyMemory, null, 2));
+    fs.writeFileSync(QUALITY_HISTORY_FILE, JSON.stringify({ scores: [] }, null, 2));
+    fs.writeFileSync(path.join(MEMORY_DIR, 'confidence_history.json'), JSON.stringify({ thresholds: {} }, null, 2));
+    fs.writeFileSync(SESSION_SUMMARY_FILE, JSON.stringify({ last_session: null, total_queries: 0, total_errors: 0 }, null, 2));
+    console.log('✅ Memory cleared (API keys preserved)');
+  } catch (err) {
+    console.error('❌ Failed to reset memory:', err.message);
+  }
+}
+
+function printColdStart() {
+  const memory = loadSessionMemory();
+  const quality = loadQualityHistory();
+  const summary = loadSessionSummary();
+
+  const avgQuality = quality.scores.length > 0
+    ? (quality.scores.reduce((a, b) => a + b, 0) / quality.scores.length).toFixed(1)
+    : 'N/A';
+
+  const patternsCount = memory.patterns?.length || 0;
+  const providers = loadApiConfig().keys?.filter(k => k.active).length || 0;
+
+  if (patternsCount === 0 && summary.total_queries === 0) {
+    console.log(`\n❄️  Welcome to Qwen Code ICE v${VERSION}\n🔑 Run: qwen-ice api-setup to configure your API keys\n`);
+  } else {
+    console.log(`\n❄️  Qwen Code ICE v${VERSION} ready`);
+    console.log(`🧠 ${patternsCount} patterns loaded | 📊 Avg quality: ${avgQuality}/10 | 🔑 ${providers} providers active`);
+    console.log(`Last session: ${summary.total_queries || 0} queries, ${summary.total_errors || 0} errors\n`);
+  }
+}
+
+async function processQuery(query) {
+  try {
+    const { IceV16 } = require(path.join(CORE_DIR, 'ice-v16.js'));
+    const ice = new IceV16({ yolo, model: selectedModel });
+    return await ice.processQuery(query);
+  } catch (err) {
+    return { error: true, message: `Failed to process query: ${err.message}` };
+  }
+}
+
+async function interactiveMode() {
+  printColdStart();
+  if (yolo) console.log('⚡ YOLO MODE: All actions auto-approved\n');
+
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+
+  const ask = () => {
+    rl.question('> ', (query) => {
+      if (query.toLowerCase() === 'exit' || query.toLowerCase() === 'quit') {
+        console.log('👋 Goodbye!');
+        rl.close();
+        return;
+      }
+      logYolo(`Query: ${query}`);
+      processQuery(query).then(result => {
+        if (result.error) console.log(`❌ ${result.message}`);
+        else console.log(result.content);
+        ask();
+      });
+    });
+  };
+
+  ask();
+}
+
+async function singleQuery(query) {
+  if (yolo) console.log('⚡ YOLO MODE: All actions auto-approved\n');
+  logYolo(`Query: ${query}`);
+  const result = await processQuery(query);
+  if (result.error) {
+    console.log(`❌ ${result.message}`);
+    process.exit(1);
+  } else {
+    console.log(result.content);
+  }
+}
+
+async function main() {
+  ensureDirs();
+
+  if (versionFlag) { printVersion(); process.exit(0); }
+  if (helpFlag) { printHelp(); process.exit(0); }
+  if (statusFlag) { printStatus(); process.exit(0); }
+
+  if (command === 'api-setup' || args[0] === 'api-setup') { runApiSetup(); return; }
+  if (command === 'status' || args[0] === 'status') { printStatus(); process.exit(0); }
+  if (command === 'reset' || args[0] === 'reset') { resetMemory(); process.exit(0); }
+  if (command === 'uninstall' || args[0] === 'uninstall') { runUninstall(); return; }
+
+  const query = command || args.find(arg => !arg.startsWith('-'));
+  if (query) await singleQuery(query);
+  else await interactiveMode();
+}
+
+main().catch(err => {
+  console.error('❌ Error:', err.message);
+  process.exit(1);
+});

package/bin/qwen-ice-api-setup

@@ -0,0 +1,340 @@
+#!/data/data/com.termux/files/usr/bin/node
+/**
+ * ❄️ ICE v16.0.0 — API Key Manager
+ */
+
+const fs = require('fs');
+const path = require('path');
+const readline = require('readline');
+const https = require('https');
+
+const INSTALL_DIR = '/data/data/com.termux/files/.qwen-ice';
+const CONFIG_DIR = path.join(INSTALL_DIR, 'config');
+const API_KEYS_FILE = path.join(CONFIG_DIR, 'api-keys.json');
+
+function loadApiConfig() {
+  try {
+    if (fs.existsSync(API_KEYS_FILE)) {
+      return JSON.parse(fs.readFileSync(API_KEYS_FILE, 'utf8'));
+    }
+  } catch (err) {}
+  return {
+    keys: [{
+      id: 'qwen-oauth',
+      provider: 'qwen',
+      type: 'oauth',
+      model: 'qwen3-coder-plus',
+      active: true,
+      note: 'Uses existing Qwen OAuth — do not modify'
+    }],
+    default_provider: 'qwen',
+    fallback_order: ['qwen', 'gemini', 'groq', 'openai', 'dashscope']
+  };
+}
+
+function saveApiConfig(config) {
+  fs.writeFileSync(API_KEYS_FILE, JSON.stringify(config, null, 2));
+}
+
+function createInterface() {
+  return readline.createInterface({ input: process.stdin, output: process.stdout });
+}
+
+function printMenu() {
+  console.log(`
+┌─────────────────────────────────┐
+│   Qwen ICE API Key Manager      │
+├─────────────────────────────────┤
+│ 1. View configured APIs         │
+│ 2. Add new API key              │
+│ 3. Remove API key               │
+│ 4. Test all API keys            │
+│ 5. Set default provider         │
+│ 6. Exit                         │
+└─────────────────────────────────┘
+`);
+}
+
+function viewConfiguredAPIs(config) {
+  console.log('\n📋 Configured API Keys:\n');
+  for (const key of config.keys) {
+    const status = key.active ? '✅' : '❌';
+    const oauth = key.type === 'oauth' ? ' (OAuth)' : '';
+    const defaultMark = key.provider === config.default_provider ? ' [DEFAULT]' : '';
+    const calls = key.call_count || 0;
+    const lastUsed = key.last_used ? new Date(key.last_used).toLocaleString() : 'never';
+    console.log(`${status} ${key.id}${oauth}${defaultMark}`);
+    console.log(`   Provider: ${key.provider}`);
+    console.log(`   Model: ${key.model || 'N/A'}`);
+    console.log(`   Calls: ${calls} | Last used: ${lastUsed}`);
+    if (key.note) console.log(`   Note: ${key.note}`);
+    console.log('');
+  }
+  console.log(`Fallback order: ${config.fallback_order.join(' → ')}\n`);
+}
+
+async function addNewApiKey(config) {
+  const rl = createInterface();
+  try {
+    console.log('\nSelect provider:');
+    console.log('1. groq');
+    console.log('2. gemini');
+    console.log('3. openai');
+    console.log('4. dashscope');
+    console.log('5. qwen (API key, not OAuth)');
+
+    const provider = await new Promise(resolve => {
+      rl.question('Provider (1-5): ', answer => {
+        const providers = { '1': 'groq', '2': 'gemini', '3': 'openai', '4': 'dashscope', '5': 'qwen' };
+        resolve(providers[answer] || 'groq');
+      });
+    });
+
+    const defaultModels = {
+      groq: 'llama-3.1-70b-versatile',
+      gemini: 'gemini-2.0-flash',
+      openai: 'gpt-4o',
+      dashscope: 'qwen-turbo',
+      qwen: 'qwen3-coder-plus'
+    };
+
+    const model = await new Promise(resolve => {
+      rl.question(`Model [${defaultModels[provider]}]: `, answer => {
+        resolve(answer.trim() || defaultModels[provider]);
+      });
+    });
+
+    const apiKey = await new Promise(resolve => {
+      const keyNames = { groq: 'gsk_...', gemini: 'AIza...', openai: 'sk-...', dashscope: 'sk-...', qwen: 'sk-...' };
+      rl.question(`Enter ${provider} API key (${keyNames[provider]}): `, resolve);
+    });
+
+    if (!apiKey) {
+      console.log('❌ API key cannot be empty');
+      return;
+    }
+
+    const id = `${provider}-${Date.now().toString(36)}`;
+    const newKey = { id, provider, key: apiKey, model, active: true, added: new Date().toISOString(), last_used: null, call_count: 0 };
+
+    config.keys.push(newKey);
+    saveApiConfig(config);
+    console.log(`\n✅ Added ${provider} API key: ${id}`);
+  } finally {
+    rl.close();
+  }
+}
+
+async function removeApiKey(config) {
+  const rl = createInterface();
+  try {
+    console.log('\nKeys to remove (enter ID):');
+    for (const key of config.keys) {
+      if (key.type !== 'oauth') {
+        console.log(`  - ${key.id} (${key.provider})`);
+      }
+    }
+
+    const keyId = await new Promise(resolve => {
+      rl.question('Enter key ID to remove (or "cancel"): ', resolve);
+    });
+
+    if (keyId.toLowerCase() === 'cancel') {
+      console.log('Cancelled');
+      return;
+    }
+
+    const index = config.keys.findIndex(k => k.id === keyId);
+    if (index === -1) {
+      console.log('❌ Key not found');
+      return;
+    }
+
+    if (config.keys[index].type === 'oauth') {
+      console.log('❌ Cannot remove OAuth key');
+      return;
+    }
+
+    config.keys.splice(index, 1);
+    saveApiConfig(config);
+    console.log(`✅ Removed key: ${keyId}`);
+  } finally {
+    rl.close();
+  }
+}
+
+function testProvider(key, provider, model) {
+  return new Promise((resolve) => {
+    let req;
+
+    if (provider === 'groq') {
+      const data = JSON.stringify({
+        model: model || 'llama-3.1-70b-versatile',
+        messages: [{ role: 'user', content: 'Hi' }],
+        max_tokens: 10
+      });
+      const options = {
+        hostname: 'api.groq.com',
+        port: 443,
+        path: '/openai/v1/chat/completions',
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'Authorization': `Bearer ${key}`,
+          'Content-Length': data.length
+        }
+      };
+      req = https.request(options, (res) => {
+        let responseData = '';
+        res.on('data', chunk => responseData += chunk);
+        res.on('end', () => {
+          if (res.statusCode === 200) resolve({ success: true, message: 'OK' });
+          else if (res.statusCode === 401) resolve({ success: false, message: 'Invalid API key' });
+          else if (res.statusCode === 429) resolve({ success: false, message: 'Rate limit exceeded' });
+          else resolve({ success: false, message: `Error ${res.statusCode}` });
+        });
+      });
+    } else if (provider === 'gemini') {
+      const data = JSON.stringify({ contents: [{ parts: [{ text: 'Hi' }] }] });
+      const options = {
+        hostname: 'generativelanguage.googleapis.com',
+        port: 443,
+        path: `/v1beta/models/${model || 'gemini-2.0-flash'}:generateContent?key=${key}`,
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'Content-Length': data.length
+        }
+      };
+      req = https.request(options, (res) => {
+        let responseData = '';
+        res.on('data', chunk => responseData += chunk);
+        res.on('end', () => {
+          if (res.statusCode === 200) resolve({ success: true, message: 'OK' });
+          else if (res.statusCode === 400) resolve({ success: false, message: 'Invalid API key or model' });
+          else if (res.statusCode === 429) resolve({ success: false, message: 'Rate limit exceeded' });
+          else resolve({ success: false, message: `Error ${res.statusCode}` });
+        });
+      });
+    } else if (provider === 'openai') {
+      const data = JSON.stringify({
+        model: model || 'gpt-4o',
+        messages: [{ role: 'user', content: 'Hi' }],
+        max_tokens: 10
+      });
+      const options = {
+        hostname: 'api.openai.com',
+        port: 443,
+        path: '/v1/chat/completions',
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'Authorization': `Bearer ${key}`,
+          'Content-Length': data.length
+        }
+      };
+      req = https.request(options, (res) => {
+        let responseData = '';
+        res.on('data', chunk => responseData += chunk);
+        res.on('end', () => {
+          if (res.statusCode === 200) resolve({ success: true, message: 'OK' });
+          else if (res.statusCode === 401) resolve({ success: false, message: 'Invalid API key' });
+          else if (res.statusCode === 429) resolve({ success: false, message: 'Rate limit exceeded' });
+          else resolve({ success: false, message: `Error ${res.statusCode}` });
+        });
+      });
+    } else {
+      resolve({ success: false, message: 'Provider not supported for testing' });
+      return;
+    }
+
+    req.on('error', (err) => resolve({ success: false, message: err.message }));
+    req.setTimeout(10000, () => {
+      resolve({ success: false, message: 'Timeout' });
+      req.destroy();
+    });
+    req.write(data);
+    req.end();
+  });
+}
+
+async function testAllApiKeys(config) {
+  console.log('\n🧪 Testing API keys...\n');
+  for (const key of config.keys) {
+    if (key.type === 'oauth') {
+      console.log(`✅ ${key.id} (OAuth) - Skipped (uses built-in auth)`);
+      continue;
+    }
+    process.stdout.write(`Testing ${key.id} (${key.provider})... `);
+    try {
+      const result = await testProvider(key.key, key.provider, key.model);
+      if (result.success) {
+        console.log('✅ OK');
+        key.active = true;
+      } else {
+        console.log(`❌ ${result.message}`);
+        if (result.message.includes('Invalid')) key.active = false;
+      }
+    } catch (err) {
+      console.log(`❌ ${err.message}`);
+    }
+  }
+  saveApiConfig(config);
+  console.log('\n');
+}
+
+async function setDefaultProvider(config) {
+  const rl = createInterface();
+  try {
+    console.log('\nAvailable providers:');
+    const providers = [...new Set(config.keys.filter(k => k.active).map(k => k.provider))];
+    providers.forEach((p, i) => console.log(`  ${i + 1}. ${p}`));
+
+    const answer = await new Promise(resolve => {
+      rl.question('Select default provider (name or number): ', resolve);
+    });
+
+    let selected = answer.trim();
+    const num = parseInt(selected) - 1;
+    if (!isNaN(num) && providers[num]) selected = providers[num];
+
+    if (!providers.includes(selected)) {
+      console.log('❌ Invalid provider');
+      return;
+    }
+
+    config.default_provider = selected;
+    saveApiConfig(config);
+    console.log(`✅ Default provider set to: ${selected}`);
+  } finally {
+    rl.close();
+  }
+}
+
+async function main() {
+  const config = loadApiConfig();
+  printMenu();
+  const rl = createInterface();
+
+  const ask = async () => {
+    rl.question('Select option (1-6): ', async (answer) => {
+      switch (answer.trim()) {
+        case '1': viewConfiguredAPIs(config); printMenu(); ask(); break;
+        case '2': await addNewApiKey(config); printMenu(); ask(); break;
+        case '3': await removeApiKey(config); printMenu(); ask(); break;
+        case '4': await testAllApiKeys(config); printMenu(); ask(); break;
+        case '5': await setDefaultProvider(config); printMenu(); ask(); break;
+        case '6': console.log('👋 Goodbye!'); rl.close(); break;
+        default: console.log('Invalid option. Please enter 1-6.'); printMenu(); ask();
+      }
+    });
+  };
+
+  ask();
+}
+
+if (require.main === module) {
+  main();
+}
+
+module.exports = { loadApiConfig, saveApiConfig, viewConfiguredAPIs };