@anh3d0nic/qwen-code-termux-ice 21.0.0 → 21.1.0

package/bin/qwen-ice

@@ -1,363 +1,159 @@
 #!/data/data/com.termux/files/usr/bin/node
 /**
- * ❄️ Qwen Code ICE v16.0.6 — Main Binary
- * Fixed: Auto-runs postinstall if core dir missing on fresh install
+ * ❄️ Qwen Code ICE — Launcher
+ * Wraps global Qwen Code CLI with ICE enhancements
  */
 
-const fs = require('fs');
-const path = require('path');
-const readline = require('readline');
 const { spawn } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+const { execSync } = require('child_process');
 
-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');
-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');
+// User data directory
+const HOME = process.env.HOME || '/data/data/com.termux/files/home';
+const USER_ICE_DIR = path.join(HOME, '.qwen-ice-data');
+const MEMORY_DIR = path.join(USER_ICE_DIR, 'memory');
 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']
-  };
-}
+const QUALITY_FILE = path.join(MEMORY_DIR, 'quality_history.json');
+const MEMORY_FILE = path.join(MEMORY_DIR, 'session_memory.json');
 
-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)) {
-      const data = JSON.parse(fs.readFileSync(QUALITY_HISTORY_FILE, 'utf8')); return Array.isArray(data) ? { scores: data } : data;
-    }
-  } catch (err) {}
-  return { scores: [] };
-}
+// Ensure user data directory exists
+if (!fs.existsSync(USER_ICE_DIR)) fs.mkdirSync(USER_ICE_DIR, { recursive: true });
+if (!fs.existsSync(MEMORY_DIR)) fs.mkdirSync(MEMORY_DIR, { recursive: true });
 
-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 };
+// ICE Core Functions
+function loadJson(file, defaultVal) {
+  try { if (fs.existsSync(file)) return JSON.parse(fs.readFileSync(file, 'utf8')); } catch (e) {}
+  return defaultVal;
 }
 
-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.score || 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:
-  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 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.score || 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';
-    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 saveJson(file, data) {
+  if (!fs.existsSync(path.dirname(file))) fs.mkdirSync(path.dirname(file), { recursive: true });
+  fs.writeFileSync(file, JSON.stringify(data, null, 2));
 }
 
-function runApiSetup() {
-  if (!fs.existsSync(scriptPath)) {
-    return;
-  }
-  const child = spawn('node', [scriptPath], { stdio: 'inherit' });
-  child.on('close', (code) => process.exit(code));
-}
+let sessionStats = { queries: 0, patternsLearned: 0, errorsFixed: 0, intentCounts: {} };
 
-function runUninstall() {
-  const scriptPath = path.join(CORE_DIR, 'uninstall.js');
-  if (!fs.existsSync(scriptPath)) {
-    console.error('❌ uninstall.js not found. Reinstall ICE.');
-    return;
+function showWelcome() {
+  const memory = loadJson(MEMORY_FILE, { user_patterns: [], known_errors: [] });
+  const quality = loadJson(QUALITY_FILE, { history: [] });
+  const summary = loadJson(SESSION_SUMMARY_FILE, { total_queries: 0, avg_quality: 0 });
+  const patternsCount = memory.user_patterns?.length || 0;
+  const avgQuality = quality.history?.length > 0 ? (quality.history.reduce((a, b) => a + (b.score || b), 0) / quality.history.length).toFixed(1) : 'N/A';
+  const totalQueries = summary.total_queries || 0;
+  if (patternsCount === 0 && totalQueries === 0) {
+    return '\n❄️  Welcome to Qwen Code ICE\n🚀 Real Qwen Code session with ICE enhancements\n🔑 Qwen OAuth enabled by default\n';
   }
-  const child = spawn('node', [scriptPath], { stdio: 'inherit' });
-  child.on('close', (code) => process.exit(code));
+  return `\n❄️  Qwen Code ICE — Session ${totalQueries + 1}\n📊 Last: ${totalQueries} queries, ${avgQuality}/10 | 🧠 ${patternsCount} patterns\n`;
 }
 
-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 preventPatterns(query) {
+  let enhanced = query;
+  const warnings = [];
+  if (query.toLowerCase().includes('sudo')) {
+    enhanced = enhanced.replace(/\bsudo\b\s*/gi, '');
+    warnings.push('🛡️  Auto-removed sudo (Termux uses pkg)');
   }
-}
-
-function printColdStart() {
-  const memory = loadSessionMemory();
-  const quality = loadQualityHistory();
-  const summary = loadSessionSummary();
-
-  const avgQuality = quality.scores.length > 0
-    ? (quality.scores.reduce((a, b) => a + (b.score || 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) {
-  } 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`);
+  if (query.includes('/usr/bin') || query.includes('/bin/')) {
+    enhanced = enhanced.replace(/\/usr\/bin/g, '$PREFIX/bin').replace(/\/bin\//g, '$PREFIX/bin/');
+    warnings.push('🛡️  Auto-fixed paths for Termux');
   }
-}
-
-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' });
+  if (query.includes('apt-get')) {
+    enhanced = enhanced.replace(/apt-get/g, 'pkg');
+    warnings.push('🛡️  Replaced apt-get with pkg');
   }
-  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 { enhanced, warnings };
+}
+
+function analyzeIntent(query) {
+  let real = 'assistance';
+  if (query.includes('how to')) real = 'step-by-step';
+  else if (query.includes('fix') || query.includes('error')) real = 'working solution';
+  else if (query.includes('write') || query.includes('create')) real = 'code implementation';
+  let deep = 'Complete request successfully';
+  if (query.includes('fix') || query.includes('error')) deep = 'stable production code';
+  else if (query.includes('write') || query.includes('create')) deep = 'ship working feature';
+  if (!sessionStats.intentCounts[deep]) sessionStats.intentCounts[deep] = 0;
+  sessionStats.intentCounts[deep]++;
+  return { surface: query, real, deep };
+}
+
+function saveSessionSummary() {
+  const quality = loadJson(QUALITY_FILE, { history: [] });
+  const avgQuality = quality.history?.length > 0 ? (quality.history.reduce((a, b) => a + (b.score || b), 0) / quality.history.length).toFixed(1) : '0';
+  const topIntent = Object.entries(sessionStats.intentCounts).sort((a, b) => b[1] - a[1])[0]?.[0] || 'assistance';
+  const summary = {
+    date: new Date().toISOString(),
+    total_queries: sessionStats.queries,
+    avg_quality: parseFloat(avgQuality),
+    patterns_learned: sessionStats.patternsLearned,
+    errors_fixed: sessionStats.errorsFixed,
+    top_intent: topIntent
+  };
+  saveJson(SESSION_SUMMARY_FILE, summary);
+  console.log('\n📊 Session Summary:');
+  console.log(`   Queries: ${summary.total_queries}`);
+  console.log(`   Avg Quality: ${summary.avg_quality}/10`);
+  console.log(`   Top Intent: ${summary.top_intent}\n`);
+}
+
+// Show ICE welcome
+console.log(showWelcome());
+
+// Get user query
+const userQuery = process.argv.slice(2).join(' ');
+let finalQuery = userQuery;
+
+if (userQuery) {
+  // Apply ICE pre-processing
+  const patternResult = preventPatterns(userQuery);
+  finalQuery = patternResult.enhanced;
+  if (patternResult.warnings.length > 0) {
+    console.log('🛡️  ICE Pattern Prevention:');
+    patternResult.warnings.forEach(w => console.log('   ' + w));
+    console.log();
   }
-  return versions[versions.length - 1] || 'ice-v15.js';
+  const intent = analyzeIntent(patternResult.enhanced);
+  console.log('🎯 ICE Intent Analysis:');
+  console.log(`   Surface: "${intent.surface}"`);
+  console.log(`   Real Need: ${intent.real}`);
+  console.log(`   Deep Goal: ${intent.deep}`);
+  console.log();
 }
 
-async function processQuery(query) {
-  try {
-    // Dynamically load latest ICE version
-    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);
-  } catch (err) {
-    return { error: true, message: `Failed to process query: ${err.message}` };
-  }
+// Find global Qwen Code CLI
+let qwenCliPath;
+try {
+  qwenCliPath = execSync('which qwen', { encoding: 'utf8' }).trim();
+} catch (e) {
+  qwenCliPath = '/data/data/com.termux/files/usr/lib/node_modules/@mmmbuto/qwen-code-termux/cli.js';
 }
 
-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();
+if (!fs.existsSync(qwenCliPath)) {
+  console.error('❌ Error: Qwen Code CLI not found');
+  console.error('   Please install: npm install -g @mmmbuto/qwen-code-termux');
+  process.exit(1);
 }
 
-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);
+// Spawn Qwen Code CLI with ICE enhancements
+const args = finalQuery ? ['-p', finalQuery] : [];
+const qwen = spawn(process.execPath, [qwenCliPath, ...args], {
+  stdio: 'inherit',
+  env: {
+    ...process.env,
+    ICE_ENABLED: 'true',
+    ICE_SESSION_ID: Date.now().toString()
   }
-}
-
-async function main() {
-  ensureDirs();
-
-  if (versionFlag) { printVersion(); process.exit(0); }
-  if (helpFlag) { printHelp(); process.exit(0); }
-  if (statusFlag) { printStatus(); process.exit(0); }
-
-  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();
-}
+qwen.on('close', (code) => {
+  sessionStats.queries++;
+  saveSessionSummary();
+  process.exit(code);
+});
 
-main().catch(err => {
-  console.error('❌ Error:', err.message);
+qwen.on('error', (err) => {
+  console.error('❌ Failed to launch Qwen Code:', err.message);
+  console.error('   CLI Path:', qwenCliPath);
   process.exit(1);
 });

package/core/ice-core.js

@@ -0,0 +1,101 @@
+/**
+ * ❄️ ICE Core - CommonJS Module
+ */
+const fs = require('fs');
+const path = require('path');
+
+const HOME = process.env.HOME || '/data/data/com.termux/files/home';
+const ICE_DIR = path.join(HOME, '.qwen-ice');
+const MEMORY_DIR = path.join(ICE_DIR, 'memory');
+
+const FILES = {
+  sessionMemory: path.join(MEMORY_DIR, 'session_memory.json'),
+  qualityHistory: path.join(MEMORY_DIR, 'quality_history.json'),
+  sessionSummary: path.join(MEMORY_DIR, 'session_summary.json'),
+};
+
+const TERMUX = { PREFIX: '/data/data/com.termux/files/usr', HOME: HOME };
+
+let sessionStats = { queries: 0, errorsFixed: 0, patternsLearned: 0, intentCounts: {}, sessionId: Date.now() };
+
+function loadJson(file, defaultVal) {
+  try { if (fs.existsSync(file)) return JSON.parse(fs.readFileSync(file, 'utf8')); } catch (e) {}
+  return defaultVal;
+}
+
+function saveJson(file, data) {
+  const dir = path.dirname(file);
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(file, JSON.stringify(data, null, 2));
+}
+
+function showColdStartWelcome() {
+  const memory = loadJson(FILES.sessionMemory, { user_patterns: [], known_errors: [] });
+  const quality = loadJson(FILES.qualityHistory, { history: [] });
+  const summary = loadJson(FILES.sessionSummary, { total_queries: 0, avg_quality: 0 });
+  const patternsCount = memory.user_patterns?.length || 0;
+  const avgQuality = quality.history?.length > 0 ? (quality.history.reduce((a, b) => a + (b.score || b), 0) / quality.history.length).toFixed(1) : 'N/A';
+  const totalQueries = summary.total_queries || 0;
+  if (patternsCount === 0 && totalQueries === 0) return '\n❄️  Welcome to Qwen Code ICE v21.0.1\n🔑 Qwen OAuth enabled by default\n';
+  return `\n❄️  Qwen Code ICE v21.0.1\n📊 Last: ${totalQueries} queries, ${avgQuality}/10 | 🧠 ${patternsCount} patterns\n`;
+}
+
+function preventPatterns(query) {
+  let enhancedQuery = query;
+  const warnings = [];
+  const preAppliedFixes = [];
+  if (query.toLowerCase().includes('sudo')) {
+    enhancedQuery = enhancedQuery.replace(/\bsudo\b\s*/gi, '');
+    warnings.push('⚠️  Auto-removed sudo');
+    preAppliedFixes.push('sudo_stripped');
+  }
+  if (query.includes('/usr/bin') || query.includes('/bin/')) {
+    enhancedQuery = enhancedQuery.replace(/\/usr\/bin/g, TERMUX.PREFIX + '/bin').replace(/\/bin\//g, TERMUX.PREFIX + '/bin/');
+    warnings.push('⚠️  Auto-fixed paths');
+    preAppliedFixes.push('paths_fixed');
+  }
+  return { enhancedQuery, warnings, preAppliedFixes };
+}
+
+function analyzeIntent(query) {
+  const surface = query;
+  let real = 'assistance';
+  if (surface.includes('how to')) real = 'step-by-step';
+  else if (surface.includes('fix') || surface.includes('error')) real = 'working solution';
+  else if (surface.includes('write') || surface.includes('create')) real = 'code implementation';
+  let deep = real;
+  if (surface.includes('fix') || surface.includes('error')) deep = 'stable production code';
+  else if (surface.includes('write') || surface.includes('create')) deep = 'ship working feature';
+  if (!sessionStats.intentCounts[deep]) sessionStats.intentCounts[deep] = 0;
+  sessionStats.intentCounts[deep]++;
+  return { surface, real, deep };
+}
+
+function scoreResponse(response, codeSuccess) {
+  let score = 5;
+  if (codeSuccess) score += 3;
+  const tokenCount = Math.ceil(response.length / 4);
+  if (tokenCount < 200) score += 1;
+  if (!response.includes('sudo') && !response.includes('/usr/bin/')) score += 1;
+  score = Math.max(1, Math.min(10, score));
+  const history = loadJson(FILES.qualityHistory, { history: [] });
+  history.history.push({ score, timestamp: Date.now() });
+  if (history.history.length > 20) history.history.shift();
+  saveJson(FILES.qualityHistory, history);
+  return score;
+}
+
+function saveSessionSummary() {
+  const quality = loadJson(FILES.qualityHistory, { history: [] });
+  const avgQuality = quality.history?.length > 0 ? (quality.history.reduce((a, b) => a + (b.score || b), 0) / quality.history.length).toFixed(1) : '0';
+  const topIntent = Object.entries(sessionStats.intentCounts).sort((a, b) => b[1] - a[1])[0]?.[0] || 'assistance';
+  const summary = { date: new Date().toISOString(), total_queries: sessionStats.queries, avg_quality: parseFloat(avgQuality), patterns_learned: sessionStats.patternsLearned, errors_fixed: sessionStats.errorsFixed, top_intent: topIntent };
+  saveJson(FILES.sessionSummary, summary);
+  console.log('\n📊 Session:', summary.total_queries, 'queries,', summary.avg_quality + '/10 avg\n');
+}
+
+function getSessionStats() { return sessionStats; }
+function incrementQueries() { sessionStats.queries++; }
+function incrementErrorsFixed(count) { sessionStats.errorsFixed += count; }
+
+module.exports = { showColdStartWelcome, preventPatterns, analyzeIntent, scoreResponse, saveSessionSummary, getSessionStats, incrementQueries, incrementErrorsFixed, loadJson, saveJson, TERMUX, FILES };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@anh3d0nic/qwen-code-termux-ice",
-  "version": "21.0.0",
+  "version": "21.1.0",
   "description": "Qwen Code ICE v16.0.5 — Compounding Intelligence with proper npm install structure",
   "main": "core/ice-v16.js",
   "bin": {
@@ -43,6 +43,7 @@
   ],
   "preferGlobal": true,
   "files": [
+    "cli-dist/",
     "bin/",
     "core/",
     "config/",

package/scripts/postinstall.cjs

@@ -1,234 +1,107 @@
 #!/usr/bin/env node
 /**
- * ❄️ ICE v15.0.0 — Postinstall Script
- * Runs automatically after: npm install -g @anh3d0nic/qwen-code-termux-ice
- * 
- * Creates ~/.qwen-ice/ directory structure and copies ICE scripts
+ * ❄️ ICE Postinstall Script
+ * Sets up self-contained Qwen Code ICE installation
  */
 
 const fs = require('fs');
 const path = require('path');
 
-// Paths
 const HOME = process.env.HOME || '/data/data/com.termux/files/home';
-const USER_QWEN_DIR = path.join(HOME, '.qwen');
-const INSTALL_DIR = path.join(HOME, '.qwen-ice');
-const PACKAGE_DIR = __dirname + '/..';
+const PREFIX = process.env.PREFIX || '/data/data/com.termux/files/usr';
+const PACKAGE_DIR = path.join(__dirname, '..');
+const INSTALL_DIR = path.join(HOME, '.qwen-ice-package');
+const CLI_DIST_DIR = path.join(INSTALL_DIR, 'cli-dist');
 
-// Directories to create
-const DIRS = [
-  INSTALL_DIR,
-  path.join(INSTALL_DIR, 'core'),
-  path.join(INSTALL_DIR, 'bin'),
-  path.join(INSTALL_DIR, 'memory'),
-  path.join(INSTALL_DIR, 'sessions'),
-  path.join(INSTALL_DIR, 'config'),
-  path.join(INSTALL_DIR, 'logs')
-];
-
-// Files to copy from package to install dir
-const FILES_TO_COPY = [
-  { src: 'scripts/ice-v15.js', dest: 'core/ice-v15.js' },
-  { src: 'scripts/api-caller.js', dest: 'core/api-caller.js' },
-  { src: 'scripts/ice-v14.js', dest: 'core/ice-v14.js' },
-  { src: 'scripts/ice-v13.js', dest: 'core/ice-v13.js' },
-  { src: 'bin/qwen-ice', dest: 'bin/qwen-ice' },
-];
-
-// JSON files to preserve from ~/.qwen/
-const JSON_FILES_TO_PRESERVE = [
-  'session_memory.json',
-  'quality_history.json',
-  'confidence_history.json',
-  'session_summary.json',
-  'trend_history.json',
-  'ice_session.json',
-  'ice_active_context.json'
-];
+console.log('\n❄️  Qwen Code ICE — Postinstall\n');
 
-function ensureDir(dir) {
-  if (!fs.existsSync(dir)) {
-    fs.mkdirSync(dir, { recursive: true });
-    console.log(`✅ Created ${dir}`);
-  }
+// Create installation directory
+if (!fs.existsSync(INSTALL_DIR)) {
+  fs.mkdirSync(INSTALL_DIR, { recursive: true });
+  console.log('✅ Created', INSTALL_DIR);
 }
 
-function copyFile(src, dest) {
-  const srcPath = path.join(PACKAGE_DIR, src);
-  const destPath = path.join(INSTALL_DIR, dest);
-  
-  if (fs.existsSync(srcPath)) {
-    const content = fs.readFileSync(srcPath, 'utf8');
-    
-    // Ensure correct shebang for Termux
-    let fixedContent = content;
-    if (content.startsWith('#!')) {
-      const lines = content.split('\n');
-      if (lines[0].includes('/usr/bin/env node') || lines[0].includes('/usr/bin/node')) {
-        lines[0] = '#!/data/data/com.termux/files/usr/bin/node';
-        fixedContent = lines.join('\n');
+// Copy CLI dist
+const srcCliDist = path.join(PACKAGE_DIR, 'packages', 'cli', 'dist');
+if (fs.existsSync(srcCliDist)) {
+  const destCliDist = path.join(INSTALL_DIR, 'cli-dist');
+  if (!fs.existsSync(destCliDist)) fs.mkdirSync(destCliDist, { recursive: true });
+  
+  // Copy files recursively
+  function copyDir(src, dest) {
+    if (!fs.existsSync(dest)) fs.mkdirSync(dest, { recursive: true });
+    const entries = fs.readdirSync(src, { withFileTypes: true });
+    for (const entry of entries) {
+      const srcPath = path.join(src, entry.name);
+      const destPath = path.join(dest, entry.name);
+      if (entry.isDirectory()) {
+        copyDir(srcPath, destPath);
+      } else {
+        fs.copyFileSync(srcPath, destPath);
       }
     }
-    
-    fs.writeFileSync(destPath, fixedContent);
-    fs.chmodSync(destPath, 0o755);
-    console.log(`✅ Copied ${src} → ${dest}`);
-  } else {
-    console.log(`⚠️  Source not found: ${srcPath}`);
   }
-}
-
-function preserveUserMemory() {
-  let preserved = 0;
   
-  JSON_FILES_TO_PRESERVE.forEach(file => {
-    const srcPath = path.join(USER_QWEN_DIR, file);
-    const destPath = path.join(INSTALL_DIR, 'memory', file);
-    
-    if (fs.existsSync(srcPath)) {
-      try {
-        const content = fs.readFileSync(srcPath, 'utf8');
-        // Validate JSON
-        JSON.parse(content);
-        fs.writeFileSync(destPath, content);
-        console.log(`✅ Preserved ${file}`);
-        preserved++;
-      } catch (e) {
-        console.log(`⚠️  Corrupted ${file}, skipping`);
-      }
-    }
-  });
-  
-  return preserved;
+  copyDir(srcCliDist, destCliDist);
+  console.log('✅ Copied Qwen Code CLI to cli-dist/');
+} else {
+  console.log('⚠️  CLI dist not found at', srcCliDist);
 }
 
-function createDefaultConfigFiles() {
-  const configDir = path.join(INSTALL_DIR, 'config');
-  const memoryDir = path.join(INSTALL_DIR, 'memory');
-  
-  // Default API keys config
-  const apiKeysFile = path.join(configDir, 'api-keys.json');
-  if (!fs.existsSync(apiKeysFile)) {
-    const defaultKeys = {
-      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']
-    };
-    fs.writeFileSync(apiKeysFile, JSON.stringify(defaultKeys, null, 2));
-    console.log('✅ Created config/api-keys.json');
-  }
-  
-  // Default settings
-  const settingsFile = path.join(configDir, 'settings.json');
-  if (!fs.existsSync(settingsFile)) {
-    const defaultSettings = {
-      version: '15.0.0',
-      theme: 'default',
-      yolo_mode: false,
-      auto_approve_commands: [],
-      max_context_length: 8192,
-      quality_threshold: 5,
-      created_at: new Date().toISOString()
-    };
-    fs.writeFileSync(settingsFile, JSON.stringify(defaultSettings, null, 2));
-    console.log('✅ Created config/settings.json');
-  }
-  
-  // Default memory files if not preserved
-  const memoryFiles = {
-    'session_memory.json': { user_patterns: [], known_errors: [], project_state: {}, user_preferences: [] },
-    'quality_history.json': { history: [] },
-    'confidence_history.json': { history: [] },
-    'session_summary.json': { total_queries: 0, avg_quality: 0, patterns_learned: 0, errors_fixed: 0, top_intent: 'none' },
-    'trend_history.json': { trends: [], alerts: [] }
-  };
-  
-  Object.entries(memoryFiles).forEach(([file, data]) => {
-    const filePath = path.join(memoryDir, file);
-    if (!fs.existsSync(filePath)) {
-      fs.writeFileSync(filePath, JSON.stringify(data, null, 2));
-    }
-  });
+// Create user data directory
+const userDataDir = path.join(HOME, '.qwen-ice-data');
+const memoryDir = path.join(userDataDir, 'memory');
+if (!fs.existsSync(memoryDir)) {
+  fs.mkdirSync(memoryDir, { recursive: true });
+  console.log('✅ Created user data directory');
 }
 
-function createSymlinks() {
-  const termuxPrefix = '/data/data/com.termux/files/usr';
-  const binDir = path.join(termuxPrefix, 'bin');
-  
-  // Ensure bin directory exists
-  if (!fs.existsSync(binDir)) {
-    try {
-      fs.mkdirSync(binDir, { recursive: true });
-    } catch (e) {
-      console.log(`⚠️  Cannot create ${binDir}, skipping symlinks`);
-      return;
-    }
-  }
-  
-  // Create symlinks
-  const symlinks = [
-    { target: path.join(INSTALL_DIR, 'bin', 'qwen-ice'), link: path.join(binDir, 'qwen-ice') },
-  ];
-  
-  symlinks.forEach(({ target, link }) => {
-    try {
-      if (fs.existsSync(link)) {
-        fs.unlinkSync(link);
-      }
-      fs.symlinkSync(target, link);
-      console.log(`✅ Symlink: ${link} → ${target}`);
-    } catch (e) {
-      console.log(`⚠️  Failed to create symlink ${link}: ${e.message}`);
+// Create default config
+const configFile = path.join(userDataDir, 'config.json');
+if (!fs.existsSync(configFile)) {
+  const defaultConfig = {
+    provider: 'qwen',
+    model: 'qwen3-coder-plus',
+    oauth_enabled: true,
+    ice_enhancements: {
+      pattern_prevention: true,
+      intent_analysis: true,
+      session_summary: true
     }
-  });
+  };
+  fs.writeFileSync(configFile, JSON.stringify(defaultConfig, null, 2));
+  console.log('✅ Created default config');
 }
 
-function main() {
-  console.log('\n❄️  Qwen Code ICE v15.0.0 — Installing...\n');
-  
-  // Step 1: Create directories
-  DIRS.forEach(ensureDir);
-  
-  // Step 2: Copy ICE scripts
-  FILES_TO_COPY.forEach(({ src, dest }) => copyFile(src, dest));
-  
-  // Step 3: Preserve user memory
-  const preserved = preserveUserMemory();
-  if (preserved === 0) {
-    console.log('ℹ️  No existing memory files found, creating defaults');
-  }
-  
-  // Step 4: Create default config files
-  createDefaultConfigFiles();
-  
-  // Step 5: Create symlinks
-  createSymlinks();
-  
-  // Final message
-  console.log('\n' + '='.repeat(60));
-  console.log('✅ ICE v15.0.0 installed to ~/.qwen-ice');
-  console.log('='.repeat(60));
-  console.log('\n🚀 Commands:');
-  console.log('   qwen-ice              — Interactive mode');
-  console.log('   qwen-ice "query"      — Single query');
-  console.log('   qwen-ice --version    — Show version');
-  console.log('   qwen-ice --help       — Show help');
-  
-  console.log('   qwen-ice exit         — Show session summary\n');
+// Create symlinks
+const binDir = path.join(PREFIX, 'bin');
+if (!fs.existsSync(binDir)) {
+  try { fs.mkdirSync(binDir, { recursive: true }); } catch (e) {}
 }
 
-// Run if called directly
-if (require.main === module) {
-  main();
+const symlinks = [
+  { target: path.join(PACKAGE_DIR, 'bin', 'qwen-ice'), link: path.join(binDir, 'qwen-ice') }
+];
+
+for (const { target, link } of symlinks) {
+  try {
+    if (fs.existsSync(link)) fs.unlinkSync(link);
+    fs.symlinkSync(target, link);
+    console.log('✅ Symlink:', link);
+  } catch (e) {
+    console.log('⚠️  Symlink failed:', e.message);
+  }
 }
 
-module.exports = { main };
+console.log('\n' + '='.repeat(60));
+console.log('✅ Qwen Code ICE installed successfully');
+console.log('='.repeat(60));
+console.log('\n🚀 Usage:');
+console.log('   qwen-ice                    # Interactive session');
+console.log('   qwen-ice "your query"       # Single query');
+console.log('   qwen-ice --version          # Show version');
+console.log('   qwen-ice --help             # Show help');
+console.log('\n📁 Installation:');
+console.log('   Package:', INSTALL_DIR);
+console.log('   User Data:', userDataDir);
+console.log();