@anh3d0nic/qwen-code-termux-ice 16.0.4 → 16.0.7

package/scripts/lint.js

@@ -0,0 +1,205 @@
+#!/usr/bin/env node
+
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { execSync } from 'node:child_process';
+import { mkdirSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+const ACTIONLINT_VERSION = '1.7.7';
+const SHELLCHECK_VERSION = '0.11.0';
+const YAMLLINT_VERSION = '1.35.1';
+
+const TEMP_DIR = join(tmpdir(), 'qwen-code-linters');
+
+function getPlatformArch() {
+  const platform = process.platform;
+  const arch = process.arch;
+  if (platform === 'linux' && arch === 'x64') {
+    return {
+      actionlint: 'linux_amd64',
+      shellcheck: 'linux.x86_64',
+    };
+  }
+  if (platform === 'darwin' && arch === 'x64') {
+    return {
+      actionlint: 'darwin_amd64',
+      shellcheck: 'darwin.x86_64',
+    };
+  }
+  if (platform === 'darwin' && arch === 'arm64') {
+    return {
+      actionlint: 'darwin_arm64',
+      shellcheck: 'darwin.aarch64',
+    };
+  }
+  throw new Error(`Unsupported platform/architecture: ${platform}/${arch}`);
+}
+
+const platformArch = getPlatformArch();
+
+/**
+ * @typedef {{
+ *   check: string;
+ *   installer: string;
+ *   run: string;
+ * }}
+ */
+
+/**
+ * @type {{[linterName: string]: Linter}}
+ */
+const LINTERS = {
+  actionlint: {
+    check: 'command -v actionlint',
+    installer: `
+      mkdir -p "${TEMP_DIR}/actionlint"
+      curl -sSLo "${TEMP_DIR}/.actionlint.tgz" "https://github.com/rhysd/actionlint/releases/download/v${ACTIONLINT_VERSION}/actionlint_${ACTIONLINT_VERSION}_${platformArch.actionlint}.tar.gz"
+      tar -xzf "${TEMP_DIR}/.actionlint.tgz" -C "${TEMP_DIR}/actionlint"
+    `,
+    run: `
+      actionlint \
+        -color \
+        -ignore 'SC2002:' \
+        -ignore 'SC2016:' \
+        -ignore 'SC2129:' \
+        -ignore 'label ".+" is unknown'
+    `,
+  },
+  shellcheck: {
+    check: 'command -v shellcheck',
+    installer: `
+      mkdir -p "${TEMP_DIR}/shellcheck"
+      curl -sSLo "${TEMP_DIR}/.shellcheck.txz" "https://github.com/koalaman/shellcheck/releases/download/v${SHELLCHECK_VERSION}/shellcheck-v${SHELLCHECK_VERSION}.${platformArch.shellcheck}.tar.xz"
+      tar -xf "${TEMP_DIR}/.shellcheck.txz" -C "${TEMP_DIR}/shellcheck" --strip-components=1
+    `,
+    run: `
+      git ls-files | grep -v '^integration-tests/terminal-bench/' | grep -E '^([^.]+|.*\\.(sh|zsh|bash))' | xargs file --mime-type \
+        | grep "text/x-shellscript" | awk '{ print substr($1, 1, length($1)-1) }' \
+        | xargs shellcheck \
+          --check-sourced \
+          --enable=all \
+          --exclude=SC2002,SC2129,SC2310 \
+          --severity=style \
+          --format=gcc \
+          --color=never | sed -e 's/note:/warning:/g' -e 's/style:/warning:/g'
+    `,
+  },
+  yamllint: {
+    check: 'command -v yamllint',
+    installer: `pip3 install --user "yamllint==${YAMLLINT_VERSION}"`,
+    run: "git ls-files | grep -E '\\.(yaml|yml)' | xargs yamllint --format github",
+  },
+};
+
+function runCommand(command, stdio = 'inherit') {
+  try {
+    const env = { ...process.env };
+    const nodeBin = join(process.cwd(), 'node_modules', '.bin');
+    env.PATH = `${nodeBin}:${TEMP_DIR}/actionlint:${TEMP_DIR}/shellcheck:${env.PATH}`;
+    if (process.platform === 'darwin') {
+      env.PATH = `${env.PATH}:${process.env.HOME}/Library/Python/3.12/bin`;
+    } else if (process.platform === 'linux') {
+      env.PATH = `${env.PATH}:${process.env.HOME}/.local/bin`;
+    }
+    execSync(command, { stdio, env });
+    return true;
+  } catch (_e) {
+    return false;
+  }
+}
+
+export function setupLinters() {
+  console.log('Setting up linters...');
+  rmSync(TEMP_DIR, { recursive: true, force: true });
+  mkdirSync(TEMP_DIR, { recursive: true });
+
+  for (const linter in LINTERS) {
+    const { check, installer } = LINTERS[linter];
+    if (!runCommand(check, 'ignore')) {
+      console.log(`Installing ${linter}...`);
+      if (!runCommand(installer)) {
+        console.error(
+          `Failed to install ${linter}. Please install it manually.`,
+        );
+        process.exit(1);
+      }
+    }
+  }
+  console.log('All required linters are available.');
+}
+
+export function runESLint() {
+  console.log('\nRunning ESLint...');
+  if (!runCommand('npm run lint:ci')) {
+    process.exit(1);
+  }
+}
+
+export function runActionlint() {
+  console.log('\nRunning actionlint...');
+  if (!runCommand(LINTERS.actionlint.run)) {
+    process.exit(1);
+  }
+}
+
+export function runShellcheck() {
+  console.log('\nRunning shellcheck...');
+  if (!runCommand(LINTERS.shellcheck.run)) {
+    process.exit(1);
+  }
+}
+
+export function runYamllint() {
+  console.log('\nRunning yamllint...');
+  if (!runCommand(LINTERS.yamllint.run)) {
+    process.exit(1);
+  }
+}
+
+export function runPrettier() {
+  console.log('\nRunning Prettier...');
+  if (!runCommand('prettier --write .')) {
+    process.exit(1);
+  }
+}
+
+function main() {
+  const args = process.argv.slice(2);
+
+  if (args.includes('--setup')) {
+    setupLinters();
+  }
+  if (args.includes('--eslint')) {
+    runESLint();
+  }
+  if (args.includes('--actionlint')) {
+    runActionlint();
+  }
+  if (args.includes('--shellcheck')) {
+    runShellcheck();
+  }
+  if (args.includes('--yamllint')) {
+    runYamllint();
+  }
+  if (args.includes('--prettier')) {
+    runPrettier();
+  }
+
+  if (args.length === 0) {
+    setupLinters();
+    runESLint();
+    runActionlint();
+    runShellcheck();
+    runYamllint();
+    runPrettier();
+    console.log('\nAll linting checks passed!');
+  }
+}
+
+main();

package/scripts/local_telemetry.js

@@ -0,0 +1,219 @@
+#!/usr/bin/env node
+
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import path from 'node:path';
+import fs from 'node:fs';
+import { spawn, execSync } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+import {
+  BIN_DIR,
+  OTEL_DIR,
+  ensureBinary,
+  fileExists,
+  manageTelemetrySettings,
+  registerCleanup,
+  waitForPort,
+} from './telemetry_utils.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const OTEL_CONFIG_FILE = path.join(OTEL_DIR, 'collector-local.yaml');
+const OTEL_LOG_FILE = path.join(OTEL_DIR, 'collector.log');
+const JAEGER_LOG_FILE = path.join(OTEL_DIR, 'jaeger.log');
+const JAEGER_PORT = 16686;
+
+// This configuration is for the primary otelcol-contrib instance.
+// It receives from the CLI on 4317, exports traces to Jaeger on 14317,
+// and sends metrics/logs to the debug log.
+const OTEL_CONFIG_CONTENT = `
+receivers:
+  otlp:
+    protocols:
+      grpc:
+        endpoint: "localhost:4317"
+processors:
+  batch:
+    timeout: 1s
+exporters:
+  otlp:
+    endpoint: "localhost:14317"
+    tls:
+      insecure: true
+  debug:
+    verbosity: detailed
+service:
+  telemetry:
+    logs:
+      level: "debug"
+    metrics:
+      level: "none"
+  pipelines:
+    traces:
+      receivers: [otlp]
+      processors: [batch]
+      exporters: [otlp]
+    metrics:
+      receivers: [otlp]
+      processors: [batch]
+      exporters: [debug]
+    logs:
+      receivers: [otlp]
+      processors: [batch]
+      exporters: [debug]
+`;
+
+async function main() {
+  // 1. Ensure binaries are available, downloading if necessary.
+  // Binaries are stored in the project's .qwen/otel/bin directory
+  // to avoid modifying the user's system.
+  if (!fileExists(BIN_DIR)) fs.mkdirSync(BIN_DIR, { recursive: true });
+
+  const otelcolPath = await ensureBinary(
+    'otelcol-contrib',
+    'open-telemetry/opentelemetry-collector-releases',
+    (version, platform, arch, ext) =>
+      `otelcol-contrib_${version}_${platform}_${arch}.${ext}`,
+    'otelcol-contrib',
+    false, // isJaeger = false
+  ).catch((e) => {
+    console.error(`🛑 Error getting otelcol-contrib: ${e.message}`);
+    return null;
+  });
+  if (!otelcolPath) process.exit(1);
+
+  const jaegerPath = await ensureBinary(
+    'jaeger',
+    'jaegertracing/jaeger',
+    (version, platform, arch, ext) =>
+      `jaeger-${version}-${platform}-${arch}.${ext}`,
+    'jaeger',
+    true, // isJaeger = true
+  ).catch((e) => {
+    console.error(`🛑 Error getting jaeger: ${e.message}`);
+    return null;
+  });
+  if (!jaegerPath) process.exit(1);
+
+  // 2. Kill any existing processes to ensure a clean start.
+  console.log('🧹 Cleaning up old processes and logs...');
+  try {
+    execSync('pkill -f "otelcol-contrib"');
+    console.log('✅ Stopped existing otelcol-contrib process.');
+  } catch (_e) {} // eslint-disable-line no-empty
+  try {
+    execSync('pkill -f "jaeger"');
+    console.log('✅ Stopped existing jaeger process.');
+  } catch (_e) {} // eslint-disable-line no-empty
+  try {
+    if (fileExists(OTEL_LOG_FILE)) fs.unlinkSync(OTEL_LOG_FILE);
+    console.log('✅ Deleted old collector log.');
+  } catch (e) {
+    if (e.code !== 'ENOENT') console.error(e);
+  }
+  try {
+    if (fileExists(JAEGER_LOG_FILE)) fs.unlinkSync(JAEGER_LOG_FILE);
+    console.log('✅ Deleted old jaeger log.');
+  } catch (e) {
+    if (e.code !== 'ENOENT') console.error(e);
+  }
+
+  let jaegerProcess, collectorProcess;
+  let jaegerLogFd, collectorLogFd;
+
+  const originalSandboxSetting = manageTelemetrySettings(
+    true,
+    'http://localhost:4317',
+    'local',
+  );
+
+  registerCleanup(
+    () => [jaegerProcess, collectorProcess],
+    () => [jaegerLogFd, collectorLogFd],
+    originalSandboxSetting,
+  );
+
+  if (!fileExists(OTEL_DIR)) fs.mkdirSync(OTEL_DIR, { recursive: true });
+  fs.writeFileSync(OTEL_CONFIG_FILE, OTEL_CONFIG_CONTENT);
+  console.log('📄 Wrote OTEL collector config.');
+
+  // Start Jaeger
+  console.log(`🚀 Starting Jaeger service... Logs: ${JAEGER_LOG_FILE}`);
+  jaegerLogFd = fs.openSync(JAEGER_LOG_FILE, 'a');
+  jaegerProcess = spawn(
+    jaegerPath,
+    ['--set=receivers.otlp.protocols.grpc.endpoint=localhost:14317'],
+    { stdio: ['ignore', jaegerLogFd, jaegerLogFd] },
+  );
+  console.log(`⏳ Waiting for Jaeger to start (PID: ${jaegerProcess.pid})...`);
+
+  try {
+    await waitForPort(JAEGER_PORT);
+    console.log(`✅ Jaeger started successfully.`);
+  } catch (_) {
+    console.error(`🛑 Error: Jaeger failed to start on port ${JAEGER_PORT}.`);
+    if (jaegerProcess && jaegerProcess.pid) {
+      process.kill(jaegerProcess.pid, 'SIGKILL');
+    }
+    if (fileExists(JAEGER_LOG_FILE)) {
+      console.error('📄 Jaeger Log Output:');
+      console.error(fs.readFileSync(JAEGER_LOG_FILE, 'utf-8'));
+    }
+    process.exit(1);
+  }
+
+  // Start the primary OTEL collector
+  console.log(`🚀 Starting OTEL collector... Logs: ${OTEL_LOG_FILE}`);
+  collectorLogFd = fs.openSync(OTEL_LOG_FILE, 'a');
+  collectorProcess = spawn(otelcolPath, ['--config', OTEL_CONFIG_FILE], {
+    stdio: ['ignore', collectorLogFd, collectorLogFd],
+  });
+  console.log(
+    `⏳ Waiting for OTEL collector to start (PID: ${collectorProcess.pid})...`,
+  );
+
+  try {
+    await waitForPort(4317);
+    console.log(`✅ OTEL collector started successfully.`);
+  } catch (_) {
+    console.error(`🛑 Error: OTEL collector failed to start on port 4317.`);
+    if (collectorProcess && collectorProcess.pid) {
+      process.kill(collectorProcess.pid, 'SIGKILL');
+    }
+    if (fileExists(OTEL_LOG_FILE)) {
+      console.error('📄 OTEL Collector Log Output:');
+      console.error(fs.readFileSync(OTEL_LOG_FILE, 'utf-8'));
+    }
+    process.exit(1);
+  }
+
+  [jaegerProcess, collectorProcess].forEach((proc) => {
+    if (proc) {
+      proc.on('error', (err) => {
+        console.error(`${proc.spawnargs[0]} process error:`, err);
+        process.exit(1);
+      });
+    }
+  });
+
+  console.log(`
+✨ Local telemetry environment is running.`);
+  console.log(
+    `
+🔎 View traces in the Jaeger UI: http://localhost:${JAEGER_PORT}`,
+  );
+  console.log(`📊 View metrics in the logs and metrics: ${OTEL_LOG_FILE}`);
+  console.log(
+    `
+📄 Tail logs and metrics in another terminal: tail -f ${OTEL_LOG_FILE}`,
+  );
+  console.log(`
+Press Ctrl+C to exit.`);
+}
+
+main();

package/scripts/postinstall.cjs

@@ -0,0 +1,235 @@
+#!/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
+ */
+
+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 + '/..';
+
+// 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/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' },
+  { src: 'bin/qwen-ice-api-setup', dest: 'bin/qwen-ice-api-setup' }
+];
+
+// 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'
+];
+
+function ensureDir(dir) {
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+    console.log(`✅ Created ${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');
+      }
+    }
+    
+    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;
+}
+
+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));
+    }
+  });
+}
+
+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') },
+    { target: path.join(INSTALL_DIR, 'bin', 'qwen-ice-api-setup'), link: path.join(binDir, 'qwen-ice-api-setup') }
+  ];
+  
+  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}`);
+    }
+  });
+}
+
+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 api-setup    — Configure API keys');
+  console.log('   qwen-ice exit         — Show session summary\n');
+}
+
+// Run if called directly
+if (require.main === module) {
+  main();
+}
+
+module.exports = { main };

package/scripts/pre-commit.js

@@ -0,0 +1,22 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { execSync } from 'node:child_process';
+import lintStaged from 'lint-staged';
+
+try {
+  // Get repository root
+  const root = execSync('git rev-parse --show-toplevel').toString().trim();
+
+  // Run lint-staged with API directly
+  const passed = await lintStaged({ cwd: root });
+
+  // Exit with appropriate code
+  process.exit(passed ? 0 : 1);
+} catch {
+  // Exit with error code
+  process.exit(1);
+}