@mmmbuto/qwen-code-termux 0.6.3-termux → 0.6.401

package/scripts/get-release-version.js

@@ -0,0 +1,411 @@
+#!/usr/bin/env node
+
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { execSync } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+import { readFileSync } from 'node:fs';
+import semver from 'semver';
+
+function readJson(filePath) {
+  return JSON.parse(readFileSync(filePath, 'utf-8'));
+}
+
+function getArgs() {
+  const args = {};
+  process.argv.slice(2).forEach((arg) => {
+    if (arg.startsWith('--')) {
+      const [key, value] = arg.substring(2).split('=');
+      args[key] = value === undefined ? true : value;
+    }
+  });
+  return args;
+}
+
+function getVersionFromNPM(distTag) {
+  const command = `npm view @qwen-code/qwen-code version --tag=${distTag}`;
+  try {
+    return execSync(command).toString().trim();
+  } catch (error) {
+    console.error(
+      `Failed to get NPM version for dist-tag "${distTag}": ${error.message}`,
+    );
+    return '';
+  }
+}
+
+function getAllVersionsFromNPM() {
+  const command = `npm view @qwen-code/qwen-code versions --json`;
+  try {
+    const versionsJson = execSync(command).toString().trim();
+    return JSON.parse(versionsJson);
+  } catch (error) {
+    console.error(`Failed to get all NPM versions: ${error.message}`);
+    return [];
+  }
+}
+
+function isVersionDeprecated(version) {
+  const command = `npm view @qwen-code/qwen-code@${version} deprecated`;
+  try {
+    const output = execSync(command).toString().trim();
+    return output.length > 0;
+  } catch (error) {
+    // This command shouldn't fail for existing versions, but as a safeguard:
+    console.error(
+      `Failed to check deprecation status for ${version}: ${error.message}`,
+    );
+    return false; // Assume not deprecated on error to avoid breaking the release.
+  }
+}
+
+function detectRollbackAndGetBaseline(npmDistTag) {
+  // Get the current dist-tag version
+  const distTagVersion = getVersionFromNPM(npmDistTag);
+  if (!distTagVersion) return { baseline: '', isRollback: false };
+
+  // Get all published versions
+  const allVersions = getAllVersionsFromNPM();
+  if (allVersions.length === 0)
+    return { baseline: distTagVersion, isRollback: false };
+
+  // Filter versions by type to match the dist-tag
+  let matchingVersions;
+  if (npmDistTag === 'latest') {
+    // Stable versions: no prerelease identifiers
+    matchingVersions = allVersions.filter(
+      (v) => semver.valid(v) && !semver.prerelease(v),
+    );
+  } else if (npmDistTag === 'preview') {
+    // Preview versions: contain -preview
+    matchingVersions = allVersions.filter(
+      (v) => semver.valid(v) && v.includes('-preview'),
+    );
+  } else if (npmDistTag === 'nightly') {
+    // Nightly versions: contain -nightly
+    matchingVersions = allVersions.filter(
+      (v) => semver.valid(v) && v.includes('-nightly'),
+    );
+  } else {
+    // For other dist-tags, just use the dist-tag version
+    return { baseline: distTagVersion, isRollback: false };
+  }
+
+  if (matchingVersions.length === 0)
+    return { baseline: distTagVersion, isRollback: false };
+
+  // Sort by semver to get a list from highest to lowest
+  matchingVersions.sort((a, b) => semver.rcompare(a, b));
+
+  // Find the highest non-deprecated version
+  let highestExistingVersion = '';
+  for (const version of matchingVersions) {
+    if (!isVersionDeprecated(version)) {
+      highestExistingVersion = version;
+      break; // Found the one we want
+    } else {
+      console.error(`Ignoring deprecated version: ${version}`);
+    }
+  }
+
+  // If all matching versions were deprecated, fall back to the dist-tag version
+  if (!highestExistingVersion) {
+    highestExistingVersion = distTagVersion;
+  }
+
+  // Check if we're in a rollback scenario
+  const isRollback = semver.gt(highestExistingVersion, distTagVersion);
+
+  return {
+    baseline: isRollback ? highestExistingVersion : distTagVersion,
+    isRollback,
+    distTagVersion,
+    highestExistingVersion,
+  };
+}
+
+function doesVersionExist(version) {
+  // Check NPM
+  try {
+    const command = `npm view @qwen-code/qwen-code@${version} version 2>/dev/null`;
+    const output = execSync(command).toString().trim();
+    if (output === version) {
+      console.error(`Version ${version} already exists on NPM.`);
+      return true;
+    }
+  } catch (_error) {
+    // This is expected if the version doesn't exist.
+  }
+
+  // Check Git tags
+  try {
+    const command = `git tag -l 'v${version}'`;
+    const tagOutput = execSync(command).toString().trim();
+    if (tagOutput === `v${version}`) {
+      console.error(`Git tag v${version} already exists.`);
+      return true;
+    }
+  } catch (error) {
+    console.error(`Failed to check git tags for conflicts: ${error.message}`);
+  }
+
+  // Check GitHub releases
+  try {
+    const command = `gh release view "v${version}" --json tagName --jq .tagName 2>/dev/null`;
+    const output = execSync(command).toString().trim();
+    if (output === `v${version}`) {
+      console.error(`GitHub release v${version} already exists.`);
+      return true;
+    }
+  } catch (error) {
+    const isExpectedNotFound =
+      error.message.includes('release not found') ||
+      error.message.includes('Not Found') ||
+      error.message.includes('not found') ||
+      error.status === 1;
+    if (!isExpectedNotFound) {
+      console.error(
+        `Failed to check GitHub releases for conflicts: ${error.message}`,
+      );
+    }
+  }
+
+  return false;
+}
+
+function getAndVerifyTags(npmDistTag, _gitTagPattern) {
+  // Detect rollback scenarios and get the correct baseline
+  const rollbackInfo = detectRollbackAndGetBaseline(npmDistTag);
+  const baselineVersion = rollbackInfo.baseline;
+
+  if (!baselineVersion) {
+    throw new Error(`Unable to determine baseline version for ${npmDistTag}`);
+  }
+
+  if (rollbackInfo.isRollback) {
+    // Rollback scenario: warn about the rollback but don't fail
+    console.error(
+      `Rollback detected! NPM ${npmDistTag} tag is ${rollbackInfo.distTagVersion}, but using ${baselineVersion} as baseline for next version calculation (highest existing version).`,
+    );
+  }
+
+  // Not verifying against git tags or GitHub releases as per user request.
+
+  return {
+    latestVersion: baselineVersion,
+    latestTag: `v${baselineVersion}`,
+  };
+}
+
+function getLatestStableReleaseTag() {
+  try {
+    const { latestTag } = getAndVerifyTags('latest', 'v[0-9].[0-9].[0-9]');
+    return latestTag;
+  } catch (error) {
+    console.error(
+      `Failed to determine latest stable release tag: ${error.message}`,
+    );
+    return '';
+  }
+}
+
+function promoteNightlyVersion() {
+  const { latestVersion } = getAndVerifyTags('nightly', 'v*-nightly*');
+  const baseVersion = latestVersion.split('-')[0];
+  const versionParts = baseVersion.split('.');
+  const major = versionParts[0];
+  const minor = versionParts[1] ? parseInt(versionParts[1]) : 0;
+  const nextMinor = minor + 1;
+  const date = new Date().toISOString().slice(0, 10).replace(/-/g, '');
+  const gitShortHash = execSync('git rev-parse --short HEAD').toString().trim();
+  return {
+    releaseVersion: `${major}.${nextMinor}.0-nightly.${date}.${gitShortHash}`,
+    npmTag: 'nightly',
+  };
+}
+
+function getNightlyVersion() {
+  const packageJson = readJson('package.json');
+  const baseVersion = packageJson.version.split('-')[0];
+  const date = new Date().toISOString().slice(0, 10).replace(/-/g, '');
+  const gitShortHash = execSync('git rev-parse --short HEAD').toString().trim();
+  const releaseVersion = `${baseVersion}-nightly.${date}.${gitShortHash}`;
+  return {
+    releaseVersion,
+    npmTag: 'nightly',
+  };
+}
+
+function validateVersion(version, format, name) {
+  const versionRegex = {
+    'X.Y.Z': /^\d+\.\d+\.\d+$/,
+    'X.Y.Z-preview.N': /^\d+\.\d+\.\d+-preview\.\d+$/,
+  };
+
+  if (!versionRegex[format] || !versionRegex[format].test(version)) {
+    throw new Error(
+      `Invalid ${name}: ${version}. Must be in ${format} format.`,
+    );
+  }
+}
+
+function getStableVersion(args) {
+  const { latestVersion: latestPreviewVersion } = getAndVerifyTags(
+    'preview',
+    'v*-preview*',
+  );
+  let releaseVersion;
+  if (args.stable_version_override) {
+    const overrideVersion = args.stable_version_override.replace(/^v/, '');
+    validateVersion(overrideVersion, 'X.Y.Z', 'stable_version_override');
+    releaseVersion = overrideVersion;
+  } else {
+    releaseVersion = latestPreviewVersion.replace(/-preview.*/, '');
+  }
+
+  return {
+    releaseVersion,
+    npmTag: 'latest',
+  };
+}
+
+function getPreviewVersion(args) {
+  const { latestVersion: latestNightlyVersion } = getAndVerifyTags(
+    'nightly',
+    'v*-nightly*',
+  );
+  let releaseVersion;
+  if (args.preview_version_override) {
+    const overrideVersion = args.preview_version_override.replace(/^v/, '');
+    validateVersion(
+      overrideVersion,
+      'X.Y.Z-preview.N',
+      'preview_version_override',
+    );
+    releaseVersion = overrideVersion;
+  } else {
+    releaseVersion =
+      latestNightlyVersion.replace(/-nightly.*/, '') + '-preview.0';
+  }
+
+  return {
+    releaseVersion,
+    npmTag: 'preview',
+  };
+}
+
+function getPatchVersion(patchFrom) {
+  if (!patchFrom || (patchFrom !== 'stable' && patchFrom !== 'preview')) {
+    throw new Error(
+      'Patch type must be specified with --patch-from=stable or --patch-from=preview',
+    );
+  }
+  const distTag = patchFrom === 'stable' ? 'latest' : 'preview';
+  const pattern = distTag === 'latest' ? 'v[0-9].[0-9].[0-9]' : 'v*-preview*';
+  const { latestVersion } = getAndVerifyTags(distTag, pattern);
+
+  if (patchFrom === 'stable') {
+    // For stable versions, increment the patch number: 0.5.4 -> 0.5.5
+    const versionParts = latestVersion.split('.');
+    const major = versionParts[0];
+    const minor = versionParts[1];
+    const patch = versionParts[2] ? parseInt(versionParts[2]) : 0;
+    const releaseVersion = `${major}.${minor}.${patch + 1}`;
+    return {
+      releaseVersion,
+      npmTag: distTag,
+    };
+  } else {
+    // For preview versions, increment the preview number: 0.6.0-preview.2 -> 0.6.0-preview.3
+    const [version, prereleasePart] = latestVersion.split('-');
+    if (!prereleasePart || !prereleasePart.startsWith('preview.')) {
+      throw new Error(
+        `Invalid preview version format: ${latestVersion}. Expected format like "0.6.0-preview.2"`,
+      );
+    }
+
+    const previewNumber = parseInt(prereleasePart.split('.')[1]);
+    if (isNaN(previewNumber)) {
+      throw new Error(`Could not parse preview number from: ${prereleasePart}`);
+    }
+
+    const releaseVersion = `${version}-preview.${previewNumber + 1}`;
+    return {
+      releaseVersion,
+      npmTag: distTag,
+    };
+  }
+}
+
+export function getVersion(options = {}) {
+  const args = { ...getArgs(), ...options };
+  const type = args.type || 'nightly';
+
+  let versionData;
+  switch (type) {
+    case 'nightly':
+      versionData = getNightlyVersion();
+      // Nightly versions include a git hash, so conflicts are highly unlikely
+      // and indicate a problem. We'll still validate but not auto-increment.
+      if (doesVersionExist(versionData.releaseVersion)) {
+        throw new Error(
+          `Version conflict! Nightly version ${versionData.releaseVersion} already exists.`,
+        );
+      }
+      break;
+    case 'promote-nightly':
+      versionData = promoteNightlyVersion();
+      break;
+    case 'stable':
+      versionData = getStableVersion(args);
+      break;
+    case 'preview':
+      versionData = getPreviewVersion(args);
+      break;
+    case 'patch':
+      versionData = getPatchVersion(args['patch-from']);
+      break;
+    default:
+      throw new Error(`Unknown release type: ${type}`);
+  }
+
+  // For patchable versions, check for existence and increment if needed.
+  if (type === 'stable' || type === 'preview' || type === 'patch') {
+    let releaseVersion = versionData.releaseVersion;
+    while (doesVersionExist(releaseVersion)) {
+      console.error(`Version ${releaseVersion} exists, incrementing.`);
+      if (releaseVersion.includes('-preview.')) {
+        // Increment preview number: 0.6.0-preview.2 -> 0.6.0-preview.3
+        const [version, prereleasePart] = releaseVersion.split('-');
+        const previewNumber = parseInt(prereleasePart.split('.')[1]);
+        releaseVersion = `${version}-preview.${previewNumber + 1}`;
+      } else {
+        // Increment patch number: 0.5.4 -> 0.5.5
+        const versionParts = releaseVersion.split('.');
+        const major = versionParts[0];
+        const minor = versionParts[1];
+        const patch = parseInt(versionParts[2]);
+        releaseVersion = `${major}.${minor}.${patch + 1}`;
+      }
+    }
+    versionData.releaseVersion = releaseVersion;
+  }
+
+  // All checks are done, construct the final result.
+  const result = {
+    releaseTag: `v${versionData.releaseVersion}`,
+    ...versionData,
+  };
+
+  result.previousReleaseTag = getLatestStableReleaseTag();
+
+  return result;
+}
+
+if (process.argv[1] === fileURLToPath(import.meta.url)) {
+  console.log(JSON.stringify(getVersion(getArgs()), null, 2));
+}

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();