@anh3d0nic/qwen-code-termux-ice 16.0.5 → 16.0.8

package/bin/qwen-ice

@@ -1,15 +1,15 @@
 #!/data/data/com.termux/files/usr/bin/node
 /**
- * ❄️ Qwen Code ICE v16.0.0 — Main Binary
+ * ❄️ Qwen Code ICE v16.0.6 — Main Binary
+ * Fixed: Auto-runs postinstall if core dir missing on fresh install
  */
 
 const fs = require('fs');
 const path = require('path');
-const { pathToFileURL } = require('url');
 const readline = require('readline');
 const { spawn } = require('child_process');
 
-const VERSION = '16.0.0';
+const VERSION = '16.0.6';
 const INSTALL_DIR = process.env.HOME + '/.qwen-ice';
 const CONFIG_DIR = path.join(INSTALL_DIR, 'config');
 const MEMORY_DIR = path.join(INSTALL_DIR, 'memory');
@@ -281,14 +281,30 @@ function printColdStart() {
   }
 }
 
-function processQuery(query) {
+function getLatestIceVersion() {
+  // Check if core directory exists, run postinstall if not
+  if (!fs.existsSync(CORE_DIR)) {
+    const { execSync } = require('child_process');
+    execSync('node ' + path.join(__dirname, '../scripts/postinstall.cjs'), { stdio: 'inherit' });
+  }
+  const versions = fs.readdirSync(CORE_DIR)
+    .filter(f => f.startsWith('ice-v') && f.endsWith('.js'))
+    .sort();
+  if (!versions || versions.length === 0) {
+    console.error('ICE core not found. Run: node scripts/postinstall.cjs');
+    process.exit(1);
+  }
+  return versions[versions.length - 1] || 'ice-v15.js';
+}
+
+async function processQuery(query) {
   try {
     // Dynamically load latest ICE version
-    const versions = fs.readdirSync(CORE_DIR).filter(f => f.startsWith('ice-v') && f.endsWith('.js')).sort();
-    const latest = versions[versions.length - 1] || 'ice-v15.js';
+    const latest = getLatestIceVersion();
     const iceModule = require(path.join(CORE_DIR, latest));
     const IceV16 = iceModule.IceV16 || iceModule.UnifiedPipeline;
-    const ice = new IceV16({ yolo, model: selectedModel }); return ice.process(query);
+    const ice = new IceV16({ yolo, model: selectedModel });
+    return ice.process(query);
   } catch (err) {
     return { error: true, message: `Failed to process query: ${err.message}` };
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@anh3d0nic/qwen-code-termux-ice",
-  "version": "16.0.5",
+  "version": "16.0.8",
   "description": "Qwen Code ICE v16.0.5 — Compounding Intelligence with proper npm install structure",
   "main": "core/ice-v16.js",
   "bin": {

package/scripts/api-caller.js

@@ -0,0 +1,205 @@
+#!/usr/bin/env node
+/**
+ * Simple API caller for ICE v15
+ * Supports: Qwen (DashScope), Gemini, Groq
+ */
+
+const https = require('https');
+
+const TERMUX = {
+  PREFIX: '/data/data/com.termux/files/usr',
+  HOME: '/data/data/com.termux/files/home'
+};
+
+const API_CONFIG = {
+  qwen: {
+    url: 'dashscope.aliyuncs.com',
+    path: '/compatible-mode/v1/chat/completions',
+    model: 'qwen3-coder-plus'
+  },
+  gemini: {
+    url: 'generativelanguage.googleapis.com',
+    path: '/v1beta/models/gemini-2.0-flash:generateContent',
+    model: 'gemini-2.0-flash'
+  },
+  groq: {
+    url: 'api.groq.com',
+    path: '/openai/v1/chat/completions',
+    model: 'llama-3.1-70b-versatile'
+  }
+};
+
+function loadApiKeys() {
+  const fs = require('fs');
+  const path = require('path');
+  const keysFile = path.join(TERMUX.HOME, '.qwen-ice', 'config', 'api-keys.json');
+  try {
+    if (fs.existsSync(keysFile)) {
+      return JSON.parse(fs.readFileSync(keysFile, 'utf8'));
+    }
+  } catch (e) {}
+  return { keys: [], default_provider: 'qwen' };
+}
+
+function callQwenAPI(apiKey, messages) {
+  return new Promise((resolve, reject) => {
+    const data = JSON.stringify({
+      model: API_CONFIG.qwen.model,
+      messages: messages,
+      max_tokens: 4096
+    });
+
+    const options = {
+      hostname: API_CONFIG.qwen.url,
+      port: 443,
+      path: API_CONFIG.qwen.path,
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Authorization': `Bearer ${apiKey}`,
+        'Content-Length': data.length
+      }
+    };
+
+    const req = https.request(options, (res) => {
+      let responseData = '';
+      res.on('data', chunk => responseData += chunk);
+      res.on('end', () => {
+        if (res.statusCode >= 400) {
+          reject(new Error(`Qwen API error: ${res.statusCode}`));
+        } else {
+          try {
+            const parsed = JSON.parse(responseData);
+            resolve(parsed.choices?.[0]?.message?.content || '');
+          } catch (e) {
+            reject(new Error('Failed to parse Qwen response'));
+          }
+        }
+      });
+    });
+
+    req.on('error', reject);
+    req.setTimeout(60000, () => reject(new Error('Qwen API timeout')));
+    req.write(data);
+    req.end();
+  });
+}
+
+function callGeminiAPI(apiKey, messages) {
+  return new Promise((resolve, reject) => {
+    const lastMessage = messages[messages.length - 1]?.content || '';
+    const data = JSON.stringify({
+      contents: [{ parts: [{ text: lastMessage }] }],
+      generationConfig: { maxOutputTokens: 4096 }
+    });
+
+    const options = {
+      hostname: API_CONFIG.gemini.url,
+      port: 443,
+      path: `${API_CONFIG.gemini.path}?key=${apiKey}`,
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Content-Length': data.length
+      }
+    };
+
+    const req = https.request(options, (res) => {
+      let responseData = '';
+      res.on('data', chunk => responseData += chunk);
+      res.on('end', () => {
+        if (res.statusCode === 429) {
+          reject(new Error('Gemini rate limit exceeded'));
+        } else if (res.statusCode >= 400) {
+          reject(new Error(`Gemini API error: ${res.statusCode}`));
+        } else {
+          try {
+            const parsed = JSON.parse(responseData);
+            resolve(parsed.candidates?.[0]?.content?.parts?.[0]?.text || '');
+          } catch (e) {
+            reject(new Error('Failed to parse Gemini response'));
+          }
+        }
+      });
+    });
+
+    req.on('error', reject);
+    req.setTimeout(60000, () => reject(new Error('Gemini API timeout')));
+    req.write(data);
+    req.end();
+  });
+}
+
+function callGroqAPI(apiKey, messages) {
+  return new Promise((resolve, reject) => {
+    const data = JSON.stringify({
+      model: API_CONFIG.groq.model,
+      messages: messages,
+      max_tokens: 4096
+    });
+
+    const options = {
+      hostname: API_CONFIG.groq.url,
+      port: 443,
+      path: API_CONFIG.groq.path,
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Authorization': `Bearer ${apiKey}`,
+        'Content-Length': data.length
+      }
+    };
+
+    const req = https.request(options, (res) => {
+      let responseData = '';
+      res.on('data', chunk => responseData += chunk);
+      res.on('end', () => {
+        if (res.statusCode >= 400) {
+          reject(new Error(`Groq API error: ${res.statusCode}`));
+        } else {
+          try {
+            const parsed = JSON.parse(responseData);
+            resolve(parsed.choices?.[0]?.message?.content || '');
+          } catch (e) {
+            reject(new Error('Failed to parse Groq response'));
+          }
+        }
+      });
+    });
+
+    req.on('error', reject);
+    req.setTimeout(60000, () => reject(new Error('Groq API timeout')));
+    req.write(data);
+    req.end();
+  });
+}
+
+async function callLLM(messages, provider = null) {
+  const config = loadApiKeys();
+  const selectedProvider = provider || config.default_provider || 'qwen';
+  
+  const keyEntry = config.keys?.find(k => k.provider === selectedProvider && k.type !== 'oauth');
+  
+  if (!keyEntry || !keyEntry.key) {
+    // No API key - return stub response
+    const lastMessage = messages[messages.length - 1]?.content || '';
+    return `[No API key configured for ${selectedProvider}]\n\nI understand your query: "${lastMessage.substring(0, 100)}${lastMessage.length > 100 ? '...' : ''}"\n\nTo get real AI responses, run: qwen-ice api-setup`;
+  }
+  
+  try {
+    switch (selectedProvider) {
+      case 'qwen':
+        return await callQwenAPI(keyEntry.key, messages);
+      case 'gemini':
+        return await callGeminiAPI(keyEntry.key, messages);
+      case 'groq':
+        return await callGroqAPI(keyEntry.key, messages);
+      default:
+        return await callQwenAPI(keyEntry.key, messages);
+    }
+  } catch (err) {
+    return `[API Error: ${err.message}]\n\nYour query was: "${messages[messages.length - 1]?.content.substring(0, 100)}"`;
+  }
+}
+
+module.exports = { callLLM, loadApiKeys };

package/scripts/ice-v15.js

@@ -1244,7 +1244,7 @@ class UnifiedPipeline {
 
     // Step 4: Generate response
     console.log('✏️  Step 4: Generate Response');
-    let response = this.generateResponse(enhancedInput, intent);
+    let response = await this.generateResponse(enhancedInput, intent);
     console.log('   Response generated\n');
 
     // Step 5: Self-Critique
@@ -1358,14 +1358,18 @@ class UnifiedPipeline {
     return response;
   }
 
-  generateResponse(input, intent) {
-    if (input.includes('sudo')) {
-      return `To fix this on Termux, use pkg instead:\n\`\`\`bash\npkg install python\n\`\`\`\nNote: sudo is not available on Termux.`;
-    }
-    if (input.includes('function')) {
-      return `Here's the function:\n\`\`\`javascript\nfunction example() {\n  return 'Hello from Termux';\n}\n\`\`\`\nThis follows Termux best practices.`;
-    }
-    return `I understand you want to ${intent.real}. The deep goal is: ${intent.deep}.\n\nHere's how to proceed...`;
+  async generateResponse(input, intent) {
+    const { callLLM } = require('./api-caller.js');
+    
+    const systemPrompt = 'You are Qwen Code ICE v15.0 - a Termux-optimized AI assistant. Always provide Termux-compatible solutions (no sudo, use pkg instead of apt-get, use ' + TERMUX.PREFIX + ' paths).';
+    
+    const messages = [
+      { role: 'system', content: systemPrompt },
+      { role: 'user', content: input }
+    ];
+    
+    const response = await callLLM(messages);
+    return response;
   }
 
   printSessionSummary() {