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

package/scripts/copy_files.js

@@ -0,0 +1,86 @@
+#!/usr/bin/env node
+
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+// Copyright 2025 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+import fs from 'node:fs';
+import path from 'node:path';
+
+const sourceDir = path.join('src');
+const targetDir = path.join('dist', 'src');
+
+const extensionsToCopy = ['.md', '.json', '.sb'];
+
+function copyFilesRecursive(source, target, rootSourceDir) {
+  if (!fs.existsSync(target)) {
+    fs.mkdirSync(target, { recursive: true });
+  }
+
+  const items = fs.readdirSync(source, { withFileTypes: true });
+
+  for (const item of items) {
+    const sourcePath = path.join(source, item.name);
+    const targetPath = path.join(target, item.name);
+
+    if (item.isDirectory()) {
+      copyFilesRecursive(sourcePath, targetPath, rootSourceDir);
+    } else {
+      const ext = path.extname(item.name);
+      // Copy standard extensions, or .js files in i18n/locales directory
+      // Use path.relative for precise matching to avoid false positives
+      const relativePath = path.relative(rootSourceDir, sourcePath);
+      const normalizedPath = relativePath.replace(/\\/g, '/');
+      const isLocaleJs =
+        ext === '.js' && normalizedPath.startsWith('i18n/locales/');
+      if (extensionsToCopy.includes(ext) || isLocaleJs) {
+        fs.copyFileSync(sourcePath, targetPath);
+      }
+    }
+  }
+}
+
+if (!fs.existsSync(sourceDir)) {
+  console.error(`Source directory ${sourceDir} not found.`);
+  process.exit(1);
+}
+
+copyFilesRecursive(sourceDir, targetDir, sourceDir);
+
+// Copy example extensions into the bundle.
+const packageName = path.basename(process.cwd());
+if (packageName === 'cli') {
+  const examplesSource = path.join(
+    sourceDir,
+    'commands',
+    'extensions',
+    'examples',
+  );
+  const examplesTarget = path.join(
+    targetDir,
+    'commands',
+    'extensions',
+    'examples',
+  );
+  if (fs.existsSync(examplesSource)) {
+    fs.cpSync(examplesSource, examplesTarget, { recursive: true });
+  }
+}
+
+console.log('Successfully copied files.');

package/scripts/create_alias.sh

@@ -0,0 +1,39 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# This script creates an alias for the Gemini CLI
+
+# Determine the project directory
+PROJECT_DIR=$(cd "$(dirname "$0")/.." && pwd)
+ALIAS_COMMAND="alias qwen='node "${PROJECT_DIR}/scripts/start.js"'"
+
+# Detect shell and set config file path
+if [[ "${SHELL}" == *"/bash" ]]; then
+    CONFIG_FILE="${HOME}/.bashrc"
+elif [[ "${SHELL}" == *"/zsh" ]]; then
+    CONFIG_FILE="${HOME}/.zshrc"
+else
+    echo "Unsupported shell. Only bash and zsh are supported."
+    exit 1
+fi
+
+echo "This script will add the following alias to your shell configuration file (${CONFIG_FILE}):"
+echo "  ${ALIAS_COMMAND}"
+echo ""
+
+# Check if the alias already exists
+if grep -q "alias qwen=" "${CONFIG_FILE}"; then
+    echo "A 'qwen' alias already exists in ${CONFIG_FILE}. No changes were made."
+    exit 0
+fi
+
+read -p "Do you want to proceed? (y/n) " -n 1 -r
+echo ""
+if [[ "${REPLY}" =~ ^[Yy]$ ]]; then
+    echo "${ALIAS_COMMAND}" >> "${CONFIG_FILE}"
+    echo ""
+    echo "Alias added to ${CONFIG_FILE}."
+    echo "Please run 'source ${CONFIG_FILE}' or open a new terminal to use the 'qwen' command."
+else
+    echo "Aborted. No changes were made."
+fi

package/scripts/dev.js

@@ -0,0 +1,109 @@
+/**
+ * @license
+ * Copyright 2025 Qwen
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Development entry point for Qwen Code CLI.
+ *
+ * Runs the CLI directly from TypeScript source files without requiring a build step.
+ * Changes to packages/core or packages/cli are reflected immediately.
+ *
+ * Usage: npm run dev -- [args]
+ * Example: npm run dev -- help
+ */
+
+import { spawn } from 'node:child_process';
+import { dirname, join } from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import { writeFileSync, mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir, platform } from 'node:os';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const root = join(__dirname, '..');
+const cliPackageDir = join(root, 'packages', 'cli');
+
+// Entry point for the CLI
+const cliEntry = join(cliPackageDir, 'index.ts');
+
+// Create a temporary loader file
+const tmpDir = mkdtempSync(join(tmpdir(), 'qwen-dev-'));
+const loaderPath = join(tmpDir, 'loader.mjs');
+
+const coreSourcePath = join(root, 'packages', 'core', 'index.ts');
+const coreSourceUrl = pathToFileURL(coreSourcePath).href;
+
+const loaderCode = `
+import { pathToFileURL } from 'node:url';
+
+const coreSourceUrl = '${coreSourceUrl}';
+
+export function resolve(specifier, context, nextResolve) {
+  if (specifier === '@qwen-code/qwen-code-core') {
+    return {
+      shortCircuit: true,
+      url: coreSourceUrl,
+      format: 'module',
+    };
+  }
+  return nextResolve(specifier, context);
+}
+`;
+
+writeFileSync(loaderPath, loaderCode);
+
+// Create the register script that uses the new register() API
+const registerPath = join(tmpDir, 'register.mjs');
+const loaderUrl = pathToFileURL(loaderPath).href;
+const registerCode = `
+import { register } from 'node:module';
+import { pathToFileURL } from 'node:url';
+
+register('${loaderUrl}', pathToFileURL('./'));
+`;
+writeFileSync(registerPath, registerCode);
+
+// Preserve existing NODE_OPTIONS (e.g. VS Code debugger injects --inspect flags via NODE_OPTIONS)
+const existingNodeOptions = process.env.NODE_OPTIONS || '';
+const importFlag = `--import ${pathToFileURL(registerPath).href}`;
+
+const env = {
+  ...process.env,
+  DEV: 'true',
+  CLI_VERSION: 'dev',
+  NODE_ENV: 'development',
+  NODE_OPTIONS: `${existingNodeOptions} ${importFlag}`.trim(),
+};
+
+// On Windows, use tsx.cmd; on Unix, use tsx directly
+const isWin = platform() === 'win32';
+const tsxCmd = isWin ? 'tsx.cmd' : 'tsx';
+const tsxArgs = [cliEntry, ...process.argv.slice(2)];
+
+const child = spawn(tsxCmd, tsxArgs, {
+  stdio: 'inherit',
+  env,
+  cwd: process.cwd(),
+  shell: isWin, // Use shell on Windows to resolve .cmd files
+});
+
+child.on('error', (err) => {
+  console.error('Failed to start dev server:', err.message);
+  try {
+    rmSync(tmpDir, { recursive: true, force: true });
+  } catch {
+    // Ignore cleanup errors
+  }
+  process.exit(1);
+});
+
+child.on('close', (code) => {
+  // Cleanup temp directory
+  try {
+    rmSync(tmpDir, { recursive: true, force: true });
+  } catch {
+    // Ignore cleanup errors
+  }
+  process.exit(code ?? 0);
+});

package/scripts/esbuild-shims.js

@@ -0,0 +1,29 @@
+/**
+ * @license
+ * Copyright 2025 Qwen
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Shims for esbuild ESM bundles to support require() calls
+ * This file is injected into the bundle via esbuild's inject option
+ */
+
+import { createRequire } from 'node:module';
+import { fileURLToPath } from 'node:url';
+import { dirname } from 'node:path';
+
+// Create require function for the current module and make it global
+const _require = createRequire(import.meta.url);
+
+// Make require available globally for dynamic requires
+if (typeof globalThis.require === 'undefined') {
+  globalThis.require = _require;
+}
+
+// Export for esbuild injection
+export const require = _require;
+
+// Setup __filename and __dirname for compatibility
+export const __filename = fileURLToPath(import.meta.url);
+export const __dirname = dirname(__filename);

package/scripts/generate-git-commit-info.js

@@ -0,0 +1,71 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+import { execSync } from 'node:child_process';
+import { existsSync, mkdirSync, writeFileSync } from 'node:fs';
+import { dirname, join, relative } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { readPackageUp } from 'read-package-up';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const root = join(__dirname, '..');
+const scriptPath = relative(root, fileURLToPath(import.meta.url));
+const generatedCliDir = join(root, 'packages/cli/src/generated');
+const cliGitCommitFile = join(generatedCliDir, 'git-commit.ts');
+const generatedCoreDir = join(root, 'packages/core/src/generated');
+const coreGitCommitFile = join(generatedCoreDir, 'git-commit.ts');
+let gitCommitInfo = 'N/A';
+let cliVersion = 'UNKNOWN';
+
+if (!existsSync(generatedCliDir)) {
+  mkdirSync(generatedCliDir, { recursive: true });
+}
+
+if (!existsSync(generatedCoreDir)) {
+  mkdirSync(generatedCoreDir, { recursive: true });
+}
+
+try {
+  const gitHash = execSync('git rev-parse --short HEAD', {
+    encoding: 'utf-8',
+  }).trim();
+  if (gitHash) {
+    gitCommitInfo = gitHash;
+  }
+
+  const result = await readPackageUp();
+  cliVersion = result?.packageJson?.version ?? 'UNKNOWN';
+} catch {
+  // ignore
+}
+
+const fileContent = `/**
+ * @license
+ * Copyright ${new Date().getFullYear()} Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+// This file is auto-generated by the build script (${scriptPath})
+// Do not edit this file manually.
+export const GIT_COMMIT_INFO = '${gitCommitInfo}';
+export const CLI_VERSION = '${cliVersion}';
+`;
+
+writeFileSync(cliGitCommitFile, fileContent);
+writeFileSync(coreGitCommitFile, fileContent);

package/scripts/generate-settings-schema.ts

@@ -0,0 +1,146 @@
+/**
+ * @license
+ * Copyright 2025 Qwen team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Generates a JSON Schema from the internal SETTINGS_SCHEMA definition.
+ *
+ * Usage: npx tsx scripts/generate-settings-schema.ts
+ *
+ * This reads the TypeScript settings schema and converts it to a standard
+ * JSON Schema file that VS Code uses for IntelliSense in settings.json files.
+ *
+ * Prerequisites: npm run build (core package must be built first)
+ */
+
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+import type {
+  SettingDefinition,
+  SettingsSchema,
+} from '../packages/cli/src/config/settingsSchema.js';
+import { getSettingsSchema } from '../packages/cli/src/config/settingsSchema.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+interface JsonSchemaProperty {
+  $schema?: string;
+  type?: string | string[];
+  description?: string;
+  properties?: Record<string, JsonSchemaProperty>;
+  items?: JsonSchemaProperty;
+  enum?: (string | number)[];
+  default?: unknown;
+  additionalProperties?: boolean | JsonSchemaProperty;
+}
+
+function convertSettingToJsonSchema(
+  setting: SettingDefinition,
+): JsonSchemaProperty {
+  const schema: JsonSchemaProperty = {};
+
+  if (setting.description) {
+    schema.description = setting.description;
+  }
+
+  switch (setting.type) {
+    case 'boolean':
+      schema.type = 'boolean';
+      break;
+    case 'string':
+      schema.type = 'string';
+      break;
+    case 'number':
+      schema.type = 'number';
+      break;
+    case 'array':
+      schema.type = 'array';
+      schema.items = { type: 'string' };
+      break;
+    case 'enum':
+      if (setting.options && setting.options.length > 0) {
+        schema.enum = setting.options.map((o) => o.value);
+        schema.description +=
+          ' Options: ' + setting.options.map((o) => `${o.value}`).join(', ');
+      } else {
+        // Enum without predefined options - accept any string
+        schema.type = 'string';
+      }
+      break;
+    case 'object':
+      schema.type = 'object';
+      if (setting.properties) {
+        schema.properties = {};
+        for (const [key, childDef] of Object.entries(setting.properties)) {
+          schema.properties[key] = convertSettingToJsonSchema(
+            childDef as SettingDefinition,
+          );
+        }
+      } else {
+        schema.additionalProperties = true;
+      }
+      break;
+  }
+
+  // Add default value for simple types only
+  if (setting.default !== undefined && setting.default !== null) {
+    const defaultVal = setting.default;
+    if (
+      typeof defaultVal === 'boolean' ||
+      typeof defaultVal === 'number' ||
+      typeof defaultVal === 'string'
+    ) {
+      schema.default = defaultVal;
+    } else if (Array.isArray(defaultVal) && defaultVal.length > 0) {
+      schema.default = defaultVal;
+    }
+  }
+
+  return schema;
+}
+
+function generateJsonSchema(
+  settingsSchema: SettingsSchema,
+): JsonSchemaProperty {
+  const jsonSchema: JsonSchemaProperty = {
+    $schema: 'http://json-schema.org/draft-07/schema#',
+    type: 'object',
+    description: 'Qwen Code settings configuration',
+    properties: {},
+    additionalProperties: true,
+  };
+
+  for (const [key, setting] of Object.entries(settingsSchema)) {
+    jsonSchema.properties![key] = convertSettingToJsonSchema(
+      setting as SettingDefinition,
+    );
+  }
+
+  // Add $version property
+  jsonSchema.properties!['$version'] = {
+    type: 'number',
+    description: 'Settings schema version for migration tracking.',
+    default: 3,
+  };
+
+  return jsonSchema;
+}
+
+const schema = getSettingsSchema();
+const jsonSchema = generateJsonSchema(schema as unknown as SettingsSchema);
+
+const outputDir = path.resolve(
+  __dirname,
+  '../packages/vscode-ide-companion/schemas',
+);
+const outputPath = path.join(outputDir, 'settings.schema.json');
+
+fs.mkdirSync(outputDir, { recursive: true });
+fs.writeFileSync(outputPath, JSON.stringify(jsonSchema, null, 2) + '\n');
+
+console.log(`Generated settings JSON Schema at: ${outputPath}`);