@hmos-library-adapter/fast 0.0.17-beta.0 → 0.0.17-beta.1

package/node_modules/@hmos-library-adapter/executer/shared/skills/harmonyos-api-upgrade-adapter/scripts/shared/platform/scan-version-catalog.json

@@ -0,0 +1,43 @@
+{
+  "schemaVersion": 1,
+  "source": {
+    "ideVersion": "26.0.0.821",
+    "resourceDirectory": "plugins/harmony/arkanalyzer-apiscan/resources/apiChange",
+    "resourceArchive": "plugins/harmony/lib/project-api-change-assistant-26.0.0.821.jar",
+    "directoryVersionNamesSha256": "63a3aa73b3c0f3d78867b150b0265aea518127c93c7dd3aaef2abb9b0d3e4847",
+    "archiveVersionNamesSha256": "63a3aa73b3c0f3d78867b150b0265aea518127c93c7dd3aaef2abb9b0d3e4847"
+  },
+  "versions": [
+    "26.0.0(26) Beta1",
+    "26.0.0(26) Beta2",
+    "26.0.0(26) Release",
+    "5.0.1(13) Beta3",
+    "5.0.1(13) Release",
+    "5.0.2(14) Beta1",
+    "5.0.2(14) Release",
+    "5.0.3(15) Beta1",
+    "5.0.3(15) Beta2",
+    "5.0.3(15) Release",
+    "5.0.4(16) Release",
+    "5.0.5(17) Beta1",
+    "5.0.5(17) Release",
+    "5.1.0(18) Release",
+    "5.1.1(19) Beta1",
+    "5.1.1(19) Release",
+    "6.0.0(20) Beta1",
+    "6.0.0(20) Beta2",
+    "6.0.0(20) Beta3",
+    "6.0.0(20) Beta5",
+    "6.0.0(20) Release",
+    "6.0.1(21) Beta1",
+    "6.0.1(21) Release",
+    "6.0.2(22) Beta1",
+    "6.0.2(22) Release",
+    "6.1.0(23) Beta1",
+    "6.1.0(23) Beta2",
+    "6.1.0(23) Release",
+    "6.1.1(24) Beta1",
+    "6.1.1(24) Release"
+  ],
+  "versionsSha256": "aba4bd23484de909da0e852bd3165de3b39dd5470eabb5e9710c4f20d1876df5"
+}

package/node_modules/@hmos-library-adapter/executer/shared/skills/harmonyos-api-upgrade-adapter/scripts/shared/platform/scan-versions.mjs

@@ -0,0 +1,51 @@
+import { readFileSync } from 'node:fs';
+import { readdir } from 'node:fs/promises';
+import { createHash } from 'node:crypto';
+import path from 'node:path';
+import { parseHarmonyVersion, compareHarmonyVersions, canonicalHarmonyVersion } from './version.mjs';
+import { errorWithCode } from './errors.mjs';
+import { listZipEntries } from '../format/zip.mjs';
+
+const catalog = JSON.parse(readFileSync(new URL('./scan-version-catalog.json', import.meta.url), 'utf8'));
+if (createHash('sha256').update(JSON.stringify(catalog.versions)).digest('hex') !== catalog.versionsSha256)
+  throw errorWithCode('Bundled scan version catalog checksum differs', 'SCAN_VERSION_CATALOG_INVALID');
+export const bundledScanVersions = Object.freeze([...catalog.versions]);
+export const scanVersionCatalogSource = Object.freeze(catalog.source);
+export async function discoverScanVersions(toolchain = {}) {
+  const analyzer = toolchain.analyzer ?? toolchain;
+  const versions = new Set(bundledScanVersions);
+  const add = name => {
+    try { versions.add(canonicalHarmonyVersion(parseHarmonyVersion(path.basename(name, '.json')))); }
+    catch { /* Other resource files do not declare a version. */ }
+  };
+  async function visit(directory) {
+    let entries;
+    try { entries = await readdir(directory, { withFileTypes: true }); }
+    catch (error) { if (error.code === 'ENOENT') return; throw error; }
+    for (const entry of entries) {
+      if (entry.isDirectory()) await visit(path.join(directory, entry.name));
+      else if (entry.isFile() && entry.name.endsWith('.json')) add(entry.name);
+    }
+  }
+  if (analyzer.apiChangeResourceRoot) await visit(analyzer.apiChangeResourceRoot);
+  if (analyzer.apiChangeResourceArchive) for (const name of await listZipEntries(analyzer.apiChangeResourceArchive))
+    if (/^apiChange\/.*\.json$/i.test(name)) add(name);
+  return [...versions].sort(compareHarmonyVersions);
+}
+
+export function resolveScanVersion(input, { endpoint, compileSdkVersion = null, versions = bundledScanVersions } = {}) {
+  const parsed = parseHarmonyVersion(input);
+  const explicit = /(?:\s|_)(?:Beta\d*|Release|Canary\d*)$/i.test(String(input).trim());
+  // API12 is the existing behavior baseline; it has no scan rule resource.
+  const known = [...new Set(['5.0.0(12) Release', ...versions].map(value => canonicalHarmonyVersion(value)))];
+  let candidates = known.filter(value => {
+    const version = parseHarmonyVersion(value);
+    return version.apiLevel === parsed.apiLevel && version.platformVersion === parsed.platformVersion;
+  }).sort(compareHarmonyVersions);
+  if (explicit) candidates = candidates.filter(value => compareHarmonyVersions(value, parsed) === 0);
+  if (!candidates.length) throw errorWithCode(`No verified scan version for ${input}`, 'SCAN_VERSION_UNKNOWN', { input, endpoint });
+  if (endpoint === 'to' && compileSdkVersion) candidates = candidates.filter(value => compareHarmonyVersions(value, compileSdkVersion) <= 0);
+  if (!candidates.length) throw errorWithCode(`Scan endpoint ${input} exceeds compile SDK ${compileSdkVersion}`,
+    'SCAN_TARGET_NOT_COVERED', { input, compileSdkVersion });
+  return endpoint === 'from' ? candidates[0] : candidates.at(-1);
+}

package/node_modules/@hmos-library-adapter/executer/shared/skills/harmonyos-api-upgrade-adapter/scripts/shared/platform/sdk-layout.mjs

@@ -0,0 +1,27 @@
+import { access } from 'node:fs/promises';
+import path from 'node:path';
+import { errorWithCode } from './errors.mjs';
+
+async function exists(file) {
+  try { await access(file); return true; }
+  catch (error) { if (error.code === 'ENOENT' || error.code === 'ENOTDIR') return false; throw error; }
+}
+
+export async function resolveSdkRoot(input, { required = true } = {}) {
+  const inputPath = path.resolve(input);
+  let root = inputPath;
+  const checkedPaths = [path.join(root, 'default', 'sdk-pkg.json')];
+  if (!await exists(checkedPaths[0])) {
+    if ((process.platform === 'win32' ? path.basename(inputPath).toLowerCase() : path.basename(inputPath)) === 'default') {
+      checkedPaths.push(path.join(inputPath, 'sdk-pkg.json'));
+      if (await exists(checkedPaths[1])) root = path.dirname(inputPath);
+      else root = null;
+    } else root = null;
+  }
+  if (!root) {
+    if (!required) return null;
+    throw errorWithCode(`DevEco SDK metadata not found: ${inputPath}。请选择 SDK 根目录或其 default 目录。`,
+      'SDK_ROOT_INVALID', { inputPath, checkedPaths, hint: 'SDK 根目录应包含 default/sdk-pkg.json' });
+  }
+  return { root, inputPath, defaultRoot: path.join(root, 'default'), packagePath: path.join(root, 'default', 'sdk-pkg.json') };
+}

package/node_modules/@hmos-library-adapter/executer/shared/skills/harmonyos-api-upgrade-adapter/scripts/shared/platform/source-scope.mjs

@@ -0,0 +1,108 @@
+import path from 'node:path';
+import { existsSync, realpathSync } from 'node:fs';
+import { readFile, realpath, stat } from 'node:fs/promises';
+import { createHash } from 'node:crypto';
+import { parseJson5 } from '../format/json5.mjs';
+import { errorWithCode } from './errors.mjs';
+
+export const SOURCE_EXCLUDED = new Set(['.git', 'oh_modules', 'node_modules', 'build', 'build-tools', '.hvigor', '.cxx',
+  '.test', '.preview', 'test', 'ohosTest', '.api-change-output', 'api-change-output', 'api-upgrade-runs']);
+export const inside = (root, file) => {
+  const relative = path.relative(root, file);
+  return relative === '' || relative !== '..' && !relative.startsWith(`..${path.sep}`) && !path.isAbsolute(relative);
+};
+export const overlaps = (left, right) => inside(left, right) || inside(right, left);
+export const relativeSource = (root, file) => path.relative(root, file).split(path.sep).join('/');
+
+// Existing paths and parents of new helpers are checked physically, including junctions.
+function physical(file) {
+  let parent = path.resolve(file), tail = [];
+  while (!existsSync(parent)) {
+    const next = path.dirname(parent);
+    if (next === parent) return path.resolve(file);
+    tail.unshift(path.basename(parent)); parent = next;
+  }
+  return path.join(realpathSync.native(parent), ...tail);
+}
+
+export function resolveSourcePath(root, file, scope = null) {
+  const resolved = path.resolve(root, file), actual = physical(resolved);
+  const roots = [root, ...(scope?.modules ?? []).map(module => module.root)];
+  if (!roots.some(directory => inside(physical(directory), actual)))
+    throw errorWithCode(`Source path is outside the project and registered modules: ${file}`, 'SOURCE_PATH_OUTSIDE_PROJECT');
+  return resolved;
+}
+
+export async function projectModules(root, profile) {
+  const modules = [];
+  for (const item of profile.modules ?? []) {
+    if (typeof item.name !== 'string' || typeof item.srcPath !== 'string') continue;
+    const declared = path.resolve(root, item.srcPath);
+    let moduleRoot, json;
+    try {
+      moduleRoot = await realpath(declared);
+      json = parseJson5(await readFile(path.join(moduleRoot, 'src/main/module.json5'), 'utf8'));
+    } catch (error) { if (error.code === 'ENOENT') continue; throw error; }
+    let build = {};
+    try { build = parseJson5(await readFile(path.join(moduleRoot, 'build-profile.json5'), 'utf8')); }
+    catch (error) { if (error.code !== 'ENOENT') throw error; }
+    modules.push({ name: item.name, root: moduleRoot, relativeRoot: relativeSource(root, moduleRoot),
+      type: json.module?.type ?? null, deviceTypes: json.module?.deviceTypes ?? [],
+      target: build.targets?.find(target => target.name === 'default')?.name ?? build.targets?.[0]?.name ?? 'default',
+      hasNativeConfig: typeof build.buildOption?.externalNativeOptions?.path === 'string' });
+  }
+  return modules;
+}
+
+export async function createSourceScope(root, modules, { scanDirs = [], scanModules = [], projectType = 'app' } = {}) {
+  if (!['app', 'har'].includes(projectType)) throw errorWithCode('project-type must be app or har', 'INVALID_PROJECT_TYPE');
+  if (projectType === 'har' && !scanDirs.length && !scanModules.length)
+    throw errorWithCode('HAR requires --scan-module or --scan-dir', 'HAR_SCAN_SCOPE_REQUIRED');
+  for (const name of scanModules) if (modules.filter(module => module.name === name).length !== 1)
+    throw errorWithCode(`Unknown or ambiguous scan module: ${name}`, 'SCAN_MODULE_INVALID');
+  const directories = [];
+  for (const directory of scanDirs) {
+    const absolute = resolveSourcePath(root, directory, { modules });
+    if (!(await stat(absolute)).isDirectory()) throw errorWithCode(`Not a scan directory: ${directory}`, 'SCAN_DIRECTORY_INVALID');
+    directories.push(await realpath(absolute));
+  }
+  const selected = modules.filter(module => (!scanModules.length || scanModules.includes(module.name))
+    && (!directories.length || directories.some(directory => overlaps(module.root, directory))));
+  if (!selected.length) throw errorWithCode('No HarmonyOS modules intersect the requested scan scope', 'SCAN_SCOPE_EMPTY');
+  if (projectType === 'har' && selected.some(module => module.type !== 'har'))
+    throw errorWithCode('HAR scan scope must contain only HAR modules', 'HAR_SCAN_SCOPE_INVALID');
+  const roots = scanModules.length || projectType === 'har' ? selected.map(module => module.root)
+    : [root, ...selected.filter(module => !inside(root, module.root)).map(module => module.root)];
+  const scope = { projectType, modules, scanModules: [...new Set(scanModules)].sort(),
+    scanDirs: [...new Set(directories)].sort(), roots: [...new Set(roots)].sort(),
+    selectedModules: selected.map(module => module.name).sort(), restricted: Boolean(scanDirs.length || scanModules.length || projectType === 'har') };
+  scope.fingerprint = createHash('sha256').update(JSON.stringify(scope)).digest('hex');
+  return scope;
+}
+
+export function sourceInScope(root, file, scope) {
+  if (!scope) return inside(root, path.resolve(root, file));
+  let absolute;
+  try { absolute = physical(resolveSourcePath(root, file, scope)); } catch { return false; }
+  return scope.roots.some(directory => inside(directory, absolute))
+    && (!scope.scanDirs.length || scope.scanDirs.some(directory => inside(directory, absolute)))
+    && !relativeSource(root, absolute).split('/').some(segment => SOURCE_EXCLUDED.has(segment));
+}
+
+export function sourceLocation(root, modules, location) {
+  const match = String(location).match(/^(.*?):(\d+)(?::(\d+))?$/);
+  if (!match) throw errorWithCode(`Invalid Code Location: ${location}`, 'SOURCE_LOCATION_INVALID');
+  const normalized = match[1].replaceAll('\\', '/'), first = normalized.split('/')[0];
+  const exact = modules.filter(module => module.name === first);
+  const candidates = exact.length ? exact : modules.filter(module => path.basename(module.root) === first);
+  if (candidates.length > 1) throw errorWithCode(`Ambiguous module in Code Location: ${location}`, 'SOURCE_LOCATION_AMBIGUOUS');
+  const file = candidates.length ? path.join(candidates[0].root, ...normalized.split('/').slice(1)) : path.resolve(root, normalized);
+  const absolutePath = resolveSourcePath(root, file, { modules });
+  const owners = modules.filter(module => inside(module.root, absolutePath)).sort((a,b) => b.root.length-a.root.length);
+  return { absolutePath, projectRelative: relativeSource(root, absolutePath), moduleName: owners[0]?.name ?? null,
+    line: Number(match[2]), column: match[3] ? Number(match[3]) : null };
+}
+
+export function sourceDiscoveryRoots(root, scope) {
+  return [...new Set([root, ...(scope?.modules ?? []).map(module => module.root).filter(directory => !inside(root, directory))])].sort();
+}

package/node_modules/@hmos-library-adapter/executer/shared/skills/harmonyos-api-upgrade-adapter/scripts/shared/platform/source-types.mjs

@@ -0,0 +1,7 @@
+import path from 'node:path';
+
+const arkTs = new Set(['.ets', '.ts']);
+const native = new Set(['.c', '.cc', '.cpp', '.cxx', '.h', '.hpp']);
+
+export const isArkTsSource = file => typeof file === 'string' && arkTs.has(path.extname(file).toLowerCase());
+export const isSourceFile = file => isArkTsSource(file) || typeof file === 'string' && native.has(path.extname(file).toLowerCase());

package/node_modules/@hmos-library-adapter/executer/shared/skills/harmonyos-api-upgrade-adapter/scripts/shared/platform/version.mjs

@@ -0,0 +1,76 @@
+export const API_PLATFORM = new Map([
+  [12, '5.0.0'], [13, '5.0.1'], [14, '5.0.2'], [15, '5.0.3'], [16, '5.0.4'], [17, '5.0.5'],
+  [18, '5.1.0'], [19, '5.1.1'], [20, '6.0.0'], [21, '6.0.1'], [22, '6.0.2'], [23, '6.1.0'],
+  [24, '6.1.1'], [26, '26.0.0'],
+]);
+const PLATFORM_API = new Map([...API_PLATFORM].map(([level, platform]) => [platform, level]));
+const CHANNEL_RANK = { canary: 0, beta: 1, release: 2 };
+
+export function parseHarmonyVersion(input) {
+  if (!['string', 'number'].includes(typeof input)) throw new Error('SDK version must be a string or number');
+  let value = String(input).trim().replace(/^HarmonyOS_/i, '').replaceAll('_', ' ');
+  if (/^\d+$/.test(value)) {
+    const platform = API_PLATFORM.get(Number(value));
+    if (!platform) throw new Error(`Unknown HarmonyOS API level: ${value}`);
+    value = `${platform}(${value})`;
+  }
+  const match = value.match(/^(\d+)\.(\d+)\.(\d+)(?:\((\d+)(?:\.\d+\.\d+)?\))?(?:\s+(Canary|Beta|Release)(\d*)?)?$/i);
+  if (!match) throw new Error(`Unsupported SDK version: ${input}`);
+  let platformVersion = `${match[1]}.${match[2]}.${match[3]}`;
+  const apiLevel = match[4] ? Number(match[4]) : PLATFORM_API.get(platformVersion) ?? null;
+  if (apiLevel === 26 && platformVersion === '7.0.0') platformVersion = '26.0.0';
+  const [major, minor, patch] = platformVersion.split('.').map(Number);
+  const channel = (match[5] || 'Release').toLowerCase();
+  const channelNumber = Number(match[6] || 0);
+  const rank = apiLevel ?? major;
+  return { raw: String(input), platformVersion, major, minor, patch, apiLevel, rank,
+    channel, channelNumber, channelRank: CHANNEL_RANK[channel],
+    key: [rank, major, minor, patch, CHANNEL_RANK[channel], channelNumber] };
+}
+
+export function compareHarmonyVersions(left, right) {
+  const a = typeof left === 'object' ? left : parseHarmonyVersion(left);
+  const b = typeof right === 'object' ? right : parseHarmonyVersion(right);
+  const key = value => [value.apiLevel ?? value.rank ?? value.major,
+    ...(value.platformVersion ? value.platformVersion.split('.').map(Number) : [value.major, value.minor, value.patch]),
+    CHANNEL_RANK[value.channel], value.channelNumber];
+  const ak = key(a), bk = key(b);
+  for (let i = 0; i < ak.length; i += 1) if (ak[i] !== bk[i]) return Math.sign(ak[i] - bk[i]);
+  return 0;
+}
+
+// Build profiles contain platform/API versions, not SDK release channels.
+export function compareConfigurationVersions(left, right) {
+  const a = typeof left === 'object' ? left : parseHarmonyVersion(left);
+  const b = typeof right === 'object' ? right : parseHarmonyVersion(right);
+  return compareHarmonyVersions({ ...a, channel: 'release', channelNumber: 0 },
+    { ...b, channel: 'release', channelNumber: 0 });
+}
+
+export function canonicalHarmonyVersion(input, includeChannel = true) {
+  const v = typeof input === 'object' ? input : parseHarmonyVersion(input);
+  const base = `${v.platformVersion ?? `${v.major}.${v.minor}.${v.patch}`}${v.apiLevel === null ? '' : `(${v.apiLevel})`}`;
+  return includeChannel ? `${base} ${v.channel[0].toUpperCase()}${v.channel.slice(1)}${v.channelNumber || ''}` : base;
+}
+
+export function parseVersion(input) {
+  const version = parseHarmonyVersion(input);
+  if (version.apiLevel === null) throw new Error(`SDK API level is required for unknown version: ${input}`);
+  return version;
+}
+
+export function assertUpgradeRange(from, to) {
+  const start = parseVersion(from);
+  const end = parseVersion(to);
+  if (compareHarmonyVersions(start, end) >= 0) {
+    throw new Error(`--from must be lower than --to: ${from} >= ${to}`);
+  }
+  return { start, end };
+}
+
+export function devecoVersionName(version) {
+  const parsed = typeof version === 'string' ? parseVersion(version) : version;
+  const channel = parsed.channel === 'release' ? 'Release'
+    : `${parsed.channel[0].toUpperCase()}${parsed.channel.slice(1)}${parsed.channelNumber || ''}`;
+  return `HarmonyOS_${parsed.platformVersion}(${parsed.apiLevel})_${channel}`;
+}

package/node_modules/@hmos-library-adapter/executer/shared/skills/harmonyos-api-upgrade-adapter/scripts/shared/test/deveco-version.test.mjs

@@ -0,0 +1,50 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { assertDevEcoCompatibility, inspectDevEcoCompatibility } from '../platform/deveco-version.mjs';
+
+test('DevEco minimum follows the target API mapping and compares numeric version components', () => {
+  for (const [version, target, status, required] of [
+    ['26.0.0', '26', 'COMPATIBLE', '26.0.0'],
+    ['26.0.0.821', '26.0.0(26) Beta2', 'COMPATIBLE', '26.0.0'],
+    ['6.1.1.280', '24', 'COMPATIBLE', '6.1.1'],
+    ['6.1.1', '6.1.1(24)', 'COMPATIBLE', '6.1.1'],
+    ['26.0.0.821', '24', 'COMPATIBLE', '6.1.1'],
+    ['6.1.1.999', '26', 'TOO_OLD', '26.0.0'],
+    ['6.1.0.999', '24', 'TOO_OLD', '6.1.1'],
+    ['6.0.9', '24', 'TOO_OLD', '6.1.1'],
+    ['6.10.0', '24', 'COMPATIBLE', '6.1.1'],
+    ['5.0.1.100', '13', 'COMPATIBLE', '5.0.1'],
+  ]) {
+    const result = inspectDevEcoCompatibility({ version }, target);
+    assert.equal(result.status, status, `${version} -> ${target}`);
+    assert.equal(result.requiredVersion, required);
+    assert.equal(result.installedVersion, version);
+  }
+});
+
+test('missing or malformed IDE versions never fall back to SDK or build numbers', () => {
+  for (const version of [undefined, null, 26, '', '26', '26.0', '26.0.0.1.2', '26.0.0 Beta1', 'invalid', '9007199254740992.0.0']) {
+    const result = inspectDevEcoCompatibility({ version, buildNumber: '26.0.0.821', file: '/IDE/product-info.json' }, '26', '/IDE');
+    assert.equal(result.status, 'UNRESOLVED');
+    assert.throws(() => assertDevEcoCompatibility(result), error => {
+      assert.equal(error.code, 'DEVECO_VERSION_UNRESOLVED');
+      assert.equal(error.stage, 'VALIDATE_DEVECO_VERSION');
+      assert.equal(error.details.metadataPath, '/IDE/product-info.json');
+      assert.match(error.message, /修复本地环境/);
+      return true;
+    });
+  }
+});
+
+test('old IDE errors preserve the actual version and actionable target requirements', () => {
+  const result = inspectDevEcoCompatibility({ version: '6.1.1.280' }, '26');
+  assert.throws(() => assertDevEcoCompatibility(result), error => {
+    assert.equal(error.code, 'DEVECO_TARGET_NOT_COVERED');
+    assert.equal(error.details.installedVersion, '6.1.1.280');
+    assert.equal(error.details.requiredVersion, '26.0.0');
+    assert.match(error.message, /不在当前环境扫描范围内/);
+    assert.match(error.message, /降低预期目标版本或升级/);
+    return true;
+  });
+  assert.doesNotThrow(() => assertDevEcoCompatibility(inspectDevEcoCompatibility({ version: '26.0.0.821' }, '26')));
+});

package/node_modules/@hmos-library-adapter/executer/shared/skills/harmonyos-api-upgrade-adapter/scripts/shared/test/document-links.test.mjs

@@ -0,0 +1,13 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {normalizeDocumentUrl,ruleDocumentLink} from '../platform/document-links.mjs';
+test('synthetic and other-rule anchors cannot override a verified canonical change entry',()=>{
+ const expected='https://developer.huawei.com/consumer/cn/doc/doccenter-release-notes/changelogs-ux-7001#ch2026031846233';
+ const old='https://developer.huawei.com/consumer/cn/doc/harmonyos-releases/changelogs-ux-7001/';
+ for(const [fragment,reason]of [['scan-a45022895e24852a8a1f','SYNTHETIC_SCAN_ANCHOR'],['ch2026032801249','RULE_LINK_MISMATCH']]){
+  const result=ruleDocumentLink({url:expected},old+'#'+fragment);assert.equal(result.url,expected);assert.equal(result.rejectedReason,reason);
+ }
+ assert.equal(normalizeDocumentUrl(old+'#ch2026031846233'),expected);
+ assert.equal(ruleDocumentLink({url:expected},old+'#ch2026031846233').source,'VERIFIED_DEVECO_REPORT');
+ assert.equal(ruleDocumentLink({url:old},old+'#scan-fake').url,'');
+});

package/node_modules/@hmos-library-adapter/executer/shared/skills/harmonyos-api-upgrade-adapter/scripts/shared/test/errors.test.mjs

@@ -0,0 +1,40 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { serializeError } from '../platform/errors.mjs';
+
+const execFileAsync = promisify(execFile);
+const skillRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../../..');
+
+test('serializes stack, command, stage, cause and diagnostic artifacts', () => {
+  const cause = Object.assign(new Error('scanner failed'), { code: 'SCAN_FAILED', stage: 'RUN_DEVECO_SCAN' });
+  const error = Object.assign(new Error('adapter failed', { cause }), {
+    code: 'PREPARE_FAILED',
+    stage: 'RESOLVE_SDK_REFERENCE',
+    details: { file: 'D:/SDK/api/test.d.ts' },
+    validationErrors: ['missing source'],
+    artifactPaths: ['D:/project/diagnostics.json'],
+  });
+  const result = serializeError(error, { command: 'prepare' });
+  assert.equal(result.command, 'prepare');
+  assert.equal(result.stage, 'RESOLVE_SDK_REFERENCE');
+  assert.match(result.stack, /adapter failed/);
+  assert.equal(result.cause.code, 'SCAN_FAILED');
+  assert.deepEqual(result.artifactPaths, ['D:/project/diagnostics.json']);
+});
+
+test('scanner CLI failures expose structured stacks', async () => {
+  for (const script of ['scripts/scanner/bin/harmony-api-scan.mjs']) {
+    await assert.rejects(execFileAsync(process.execPath, [path.join(skillRoot, script), 'unknown-command']), error => {
+      const response = JSON.parse(error.stderr);
+      assert.equal(response.ok, false);
+      assert.equal(response.error.command, 'unknown-command');
+      assert.match(response.error.stack, /Unknown command/);
+      assert.ok(response.error.code);
+      return true;
+    });
+  }
+});

package/node_modules/@hmos-library-adapter/executer/shared/skills/harmonyos-api-upgrade-adapter/scripts/shared/test/fs-utils.test.mjs

@@ -0,0 +1,31 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtemp, mkdir, readFile, writeFile, rm } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { atomicWrite, exists, pathExists, listFiles } from '../io/fs-utils.mjs';
+
+test('shared traversal preserves strict scanner and optional maintenance missing-directory behavior', async t => {
+  const root = await mkdtemp(path.join(os.tmpdir(), 'shared-files-中文 空格-'));
+  t.after(() => rm(root, { recursive: true, force: true }));
+  const missing = path.join(root, 'missing');
+  await assert.rejects(listFiles(missing), { code: 'ENOENT' });
+  assert.deepEqual(await listFiles(missing, () => true, () => true, { allowMissing: true }), []);
+  assert.equal(await exists(missing), false);
+  assert.equal(await pathExists(missing), false);
+  assert.equal(await exists(null), false);
+  await assert.rejects(pathExists(null), TypeError);
+  await mkdir(path.join(root, 'excluded'));
+  await writeFile(path.join(root, 'a.txt'), 'a');
+  await writeFile(path.join(root, 'excluded', 'b.txt'), 'b');
+  assert.deepEqual(await listFiles(root, file => file.endsWith('.txt'), directory => path.basename(directory) !== 'excluded'), [path.join(root, 'a.txt')]);
+});
+
+test('shared atomic writes replace an existing file', async t => {
+  const root = await mkdtemp(path.join(os.tmpdir(), 'shared-write-'));
+  t.after(() => rm(root, { recursive: true, force: true }));
+  const file = path.join(root, 'existing.txt');
+  await writeFile(file, 'before');
+  await atomicWrite(file, 'after');
+  assert.equal(await readFile(file, 'utf8'), 'after');
+});

package/node_modules/@hmos-library-adapter/executer/shared/skills/harmonyos-api-upgrade-adapter/scripts/shared/test/platform-paths.test.mjs

@@ -0,0 +1,19 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { portablePath, samePath, relativePathInside, comparableCodeLocation } from '../platform/paths.mjs';
+
+test('normalizes Windows path identity and portable report paths', () => {
+  assert.equal(samePath('C:\\Work\\App\\Entry.ets', 'c:\\work\\app\\entry.ets', 'win32'), true);
+  assert.equal(samePath('C:\\Work\\App', 'D:\\Work\\App', 'win32'), false);
+  assert.equal(portablePath('entry\\src\\main\\A.ets'), 'entry/src/main/A.ets');
+});
+
+test('Windows containment and locations handle drives, UNC, casing and line numbers', () => {
+  assert.equal(relativePathInside('C:\\工程 空格','c:/工程 空格/Entry/A.ts','win32'),'Entry/A.ts');
+  assert.equal(relativePathInside('C:\\App','D:\\App\\A.ts','win32'),null);
+  assert.equal(relativePathInside('C:\\App','C:\\Application\\A.ts','win32'),null);
+  assert.equal(relativePathInside('C:\\App','C:\\App\\..\\secret.ts','win32'),null);
+  assert.equal(relativePathInside('\\\\server\\share\\App','\\\\SERVER\\SHARE\\app\\A.ts','win32'),'A.ts');
+  assert.equal(comparableCodeLocation('c:/WORK/App/Entry/A.ts:12:4','C:\\Work\\App','win32'),'entry/a.ts:12:4');
+  assert.notEqual(comparableCodeLocation('Entry/A.ts:1',null,'darwin'),comparableCodeLocation('entry/A.ts:1',null,'darwin'));
+});

package/node_modules/@hmos-library-adapter/executer/shared/skills/harmonyos-api-upgrade-adapter/scripts/shared/test/process-utils.test.mjs

@@ -0,0 +1,68 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtemp, readFile, writeFile } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { runProcess } from '../platform/process.mjs';
+import { prependPath } from '../platform/process.mjs';
+
+test('Windows PATH keeps the original search path with exactly one case-insensitive key', () => {
+  const original={Path:'C:\\Windows',OTHER:'kept'};
+  const env=prependPath(original,['D:\\工具 空格'],'win32');
+  assert.deepEqual(Object.keys(env).filter(key=>key.toLowerCase()==='path'),['Path']);
+  assert.equal(env.Path,'D:\\工具 空格;C:\\Windows');
+  assert.equal(original.Path,'C:\\Windows');
+  assert.equal(prependPath({Path:'old',PATH:'explicit'},['tools'],'win32').Path,'tools;explicit');
+  assert.deepEqual(prependPath({Path:'unrelated',PATH:'/bin'},['/tools'],'darwin'),{Path:'unrelated',PATH:'/tools:/bin'});
+});
+
+test('output callbacks preserve stream arrival order, and spawn failure is explicit', async () => {
+  const output=[];
+  const result=await runProcess(process.execPath,['-e',"process.stdout.write('中文');setTimeout(()=>process.stderr.write('error'),30);setTimeout(()=>process.stdout.write('done'),60)"],
+    {onOutput:(chunk,stream)=>output.push([chunk,stream]),timeoutMs:3000});
+  assert.equal(result.exitCode,0);
+  assert.equal(output.filter(([,stream])=>stream==='stdout').map(([chunk])=>chunk).join(''),result.stdout);
+  assert.equal(output.filter(([,stream])=>stream==='stderr').map(([chunk])=>chunk).join(''),result.stderr);
+  assert.equal(result.stdout,'中文done');assert.equal(result.stderr,'error');
+  const missing=await runProcess(path.join(os.tmpdir(),'missing-adapter-executable'),[],{timeoutMs:1000});
+  assert.equal(missing.exitCode,null);assert.match(missing.error,/ENOENT/);
+});
+
+test('a timeout terminates the spawned process tree', async () => {
+  const root = await mkdtemp(path.join(os.tmpdir(), 'adapter-process-tree-'));
+  const marker = path.join(root, 'orphan-marker.txt');
+  const grandchild = path.join(root, 'grandchild.mjs');
+  const parent = path.join(root, 'parent.mjs');
+  await writeFile(grandchild, `
+    import { writeFile } from 'node:fs/promises';
+    setTimeout(() => writeFile(process.argv[2], 'orphaned'), 500);
+    setInterval(() => {}, 1000);
+  `);
+  await writeFile(parent, `
+    import { spawn } from 'node:child_process';
+    spawn(process.execPath, [process.argv[2], process.argv[3]], { stdio: 'ignore' });
+    setInterval(() => {}, 1000);
+  `);
+  const result = await runProcess(process.execPath, [parent, grandchild, marker], {
+    detached: true,
+    timeoutMs: 75,
+    terminationGraceMs: 100,
+  });
+  assert.equal(result.timedOut, true);
+  await new Promise((resolve) => setTimeout(resolve, 650));
+  await assert.rejects(readFile(marker, 'utf8'), /ENOENT/);
+});
+
+test('Windows command wrappers preserve spaces, Unicode, and shell metacharacters', {
+  skip: process.platform !== 'win32',
+}, async () => {
+  const root = await mkdtemp(path.join(os.tmpdir(), 'adapter cmd 中文-'));
+  const capture = path.join(root, 'capture.mjs');
+  const wrapper = path.join(root, 'capture args.cmd');
+  await writeFile(capture, 'process.stdout.write(JSON.stringify(process.argv.slice(2)));\n');
+  await writeFile(wrapper, '@echo off\r\n"%NODE_PATH%" "%~dp0capture.mjs" %*\r\n');
+  const expected = ['plain', 'space value', '中文 参数', 'a&b', 'caret^value', 'pipe|value', 'percent%value', 'bang!value'];
+  const result = await runProcess(wrapper, expected, { env: { ...process.env, NODE_PATH: process.execPath } });
+  assert.equal(result.exitCode, 0, result.stderr);
+  assert.deepEqual(JSON.parse(result.stdout), expected);
+});

package/node_modules/@hmos-library-adapter/executer/shared/skills/harmonyos-api-upgrade-adapter/scripts/shared/test/scan-versions.test.mjs

@@ -0,0 +1,26 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { readFile } from 'node:fs/promises';
+import { bundledScanVersions, resolveScanVersion } from '../platform/scan-versions.mjs';
+import { compareConfigurationVersions, compareHarmonyVersions } from '../platform/version.mjs';
+
+test('version guide lists exactly the thirty supported API13+ versions in chronological order', async () => {
+  const guide = await readFile(new URL('../../../references/common/sdk-versions.md', import.meta.url), 'utf8');
+  const listed = [...guide.matchAll(/^\| \d+ \| `([^`]+)` \|/gm)].map(match => match[1]);
+  assert.deepEqual(listed, [...bundledScanVersions].sort(compareHarmonyVersions));
+  assert.equal(listed.length, 30);
+  assert.doesNotMatch(guide, /API\s*12|5\.0\.0\(12\)/i);
+});
+
+test('verified catalog chooses earliest starts, latest bounded ends and preserves explicit channels',()=>{
+  assert.equal(bundledScanVersions.length,30);
+  for (const [input,expected] of [['13','5.0.1(13) Beta3'],['16','5.0.4(16) Release'],['22','6.0.2(22) Beta1'],['23','6.1.0(23) Beta1']])
+    assert.equal(resolveScanVersion(input,{endpoint:'from'}),expected);
+  assert.equal(resolveScanVersion('20',{endpoint:'to',compileSdkVersion:'6.0.0(20) Beta5'}),'6.0.0(20) Beta5');
+  for(const channel of ['Beta1','Beta2','Release']) {
+    assert.equal(compareConfigurationVersions(`26.0.0 ${channel}`,'26.0.0'),0);
+  }
+  assert.equal(resolveScanVersion('6.1.0(23) Beta2',{endpoint:'from'}),'6.1.0(23) Beta2');
+  assert.throws(()=>resolveScanVersion('26.0.0(26) Release',{endpoint:'to',compileSdkVersion:'26.0.0 Beta1'}),{code:'SCAN_TARGET_NOT_COVERED'});
+  assert.throws(()=>resolveScanVersion('6.0.0(20) Beta4',{endpoint:'from'}),{code:'SCAN_VERSION_UNKNOWN'});
+});

package/node_modules/@hmos-library-adapter/executer/shared/skills/harmonyos-api-upgrade-adapter/scripts/shared/test/sdk-version.test.mjs

@@ -0,0 +1,17 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {
+  assertUpgradeRange,
+  compareHarmonyVersions as compareVersions,
+  devecoVersionName,
+} from '../platform/version.mjs';
+
+test('orders beta channels before release and validates an exclusive-inclusive range', () => {
+  assert.equal(devecoVersionName('26.0.0(26) Release'), 'HarmonyOS_26.0.0(26)_Release');
+  assert.ok(compareVersions('26.0.0(26) Canary1', '26.0.0(26) Beta') < 0);
+  assert.ok(compareVersions('26.0.0(26) Beta', '26.0.0(26) Beta1') < 0);
+  assert.ok(compareVersions('26.0.0(26) Beta1', '26.0.0(26) Beta2') < 0);
+  assert.ok(compareVersions('26.0.0(26) Beta2', '26.0.0(26) Release') < 0);
+  assert.equal(assertUpgradeRange('5.0.0(12)', '6.1.1(24)').end.apiLevel, 24);
+  assert.throws(() => assertUpgradeRange('6.1.1(24)', '6.1.1(24)'), /must be lower/);
+});