@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/scanner/test/deveco.test.mjs

@@ -0,0 +1,262 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtemp, mkdir, writeFile, readFile, readdir, rm } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { deflateRawSync } from 'node:zlib';
+import { discoverDevEco, validateTargetCoverage } from '../core/deveco.mjs';
+import { execute } from '../core/cli.mjs';
+import { buildSdkCatalog } from '../core/sdk-deprecations.mjs';
+import { loadDevEcoRules } from '../core/rules.mjs';
+import { assertUpgradeRange, parseVersion } from '../../shared/platform/version.mjs';
+
+function zip(entries) {
+  const locals = [];
+  const centrals = [];
+  let offset = 0;
+  for (const [name, value] of entries) {
+    const fileName = Buffer.from(name);
+    const content = Buffer.from(value);
+    const compressed = deflateRawSync(content);
+    const local = Buffer.alloc(30);
+    local.writeUInt32LE(0x04034b50, 0); local.writeUInt16LE(20, 4); local.writeUInt16LE(8, 8);
+    local.writeUInt32LE(compressed.length, 18); local.writeUInt32LE(content.length, 22);
+    local.writeUInt16LE(fileName.length, 26);
+    locals.push(local, fileName, compressed);
+    const central = Buffer.alloc(46);
+    central.writeUInt32LE(0x02014b50, 0); central.writeUInt16LE(20, 4); central.writeUInt16LE(20, 6);
+    central.writeUInt16LE(8, 10); central.writeUInt32LE(compressed.length, 20);
+    central.writeUInt32LE(content.length, 24); central.writeUInt16LE(fileName.length, 28);
+    central.writeUInt32LE(offset, 42);
+    centrals.push(central, fileName);
+    offset += local.length + fileName.length + compressed.length;
+  }
+  const centralDirectory = Buffer.concat(centrals);
+  const end = Buffer.alloc(22);
+  end.writeUInt32LE(0x06054b50, 0); end.writeUInt16LE(entries.length, 8); end.writeUInt16LE(entries.length, 10);
+  end.writeUInt32LE(centralDirectory.length, 12); end.writeUInt32LE(offset, 16);
+  return Buffer.concat([...locals, centralDirectory, end]);
+}
+
+async function fixture({ scannerName = 'api-change-scan.js', scannerSource = '--startVersion --endVersion --modulePaths --sdkPath --apiModifiedPath --outputPath', resourceMode = 'directory', ideVersion = '26.0.0.821',
+  sdkData = { platformVersion: '26.0.0', apiVersion: '26', releaseType: 'Release' } } = {}) {
+  const root = await mkdtemp(path.join(os.tmpdir(), 'scanner-windows-home-'));
+  const home = path.join(root, 'DevEco Studio');
+  const sdk = path.join(root, 'Harmony SDK');
+  const files = [
+    [path.join(sdk, 'default/sdk-pkg.json'), JSON.stringify({ data: sdkData })],
+    [path.join(home, 'product-info.json'), JSON.stringify({ name: 'DevEco Studio', version: ideVersion })],
+    [path.join(sdk, 'default/openharmony/ets/build-tools/ets-loader/node_modules/typescript/lib/typescript.js'), 'parser'],
+    [path.join(sdk, 'default/hms/ets/api/@hms.test.d.ts'), 'export {};'],
+    [path.join(home, `plugins/harmony/arkanalyzer-apiscan/${scannerName}`), scannerSource],
+    [path.join(home, 'jbr/bin/java.exe'), 'java'],
+    [path.join(home, 'tools/hvigor/bin/hvigorw.bat'), 'hvigor'],
+    [path.join(home, 'tools/ohpm/bin/ohpm.cmd'), 'ohpm'],
+  ];
+  for (const [file, content] of files) {
+    await mkdir(path.dirname(file), { recursive: true });
+    await writeFile(file, content);
+  }
+  if (['directory', 'mixed', 'modern-directory'].includes(resourceMode)) {
+    const resource = path.join(home,
+      `plugins/harmony/arkanalyzer-apiscan/resources/apiChange/${resourceMode === 'directory'
+        ? 'HarmonyOS_26.0.0(26)_Release.json' : 'HarmonyOS_26.0.0_Release.json'}`);
+    await mkdir(path.dirname(resource), { recursive: true });
+    await writeFile(resource, '[]');
+  }
+  if (resourceMode === 'jar' || resourceMode === 'mixed') {
+    const archive = path.join(home, 'plugins/harmony/lib/project-api-change-assistant-26.0.0.361.jar');
+    await mkdir(path.dirname(archive), { recursive: true });
+    await writeFile(archive, zip([
+      ['apiChange/HarmonyOS_26.0.0(26)_Beta1.json', '[]'],
+      ['apiChange/HarmonyOS_26.0.0(26)_Release.json', resourceMode === 'mixed' ? 'invalid duplicate' : '[]'],
+    ]));
+  }
+  return { root, home, sdk };
+}
+
+test('discovers the Windows analyzer when the SDK and DevEco home are separate', async () => {
+  const { home, sdk } = await fixture();
+  const result = await discoverDevEco(sdk, home, { platform: 'win32', env: {} });
+  assert.equal(result.contentsRoot, path.resolve(home));
+  assert.equal(result.ohpm,path.join(home,'tools/ohpm/bin/ohpm.cmd'));
+  assert.equal(result.sdkRoot, path.resolve(sdk));
+  assert.equal(result.java, path.join(home, 'jbr/bin/java.exe'));
+  assert.equal(result.hvigorw, path.join(home, 'tools/hvigor/bin/hvigorw.bat'));
+  assert.equal(result.apiChangeBackend, 'integrated');
+  assert.equal(result.projectApiChangeJar, null);
+});
+
+test('detects a renamed integrated scanner by its CLI contract', async () => {
+  const { home, sdk } = await fixture({ scannerName: 'windows-api-compatibility.js' });
+  const result = await discoverDevEco(sdk, home, { platform: 'win32', env: {} });
+  assert.equal(result.apiChangeBackend, 'integrated');
+  assert.equal(result.apiChangeScan, path.join(home, 'plugins/harmony/arkanalyzer-apiscan/windows-api-compatibility.js'));
+});
+
+test('detects the index backend without treating it as the integrated CLI', async () => {
+  const { home, sdk } = await fixture({
+    scannerName: 'index.js',
+    scannerSource: '--startVersion --endVersion --modulePaths --sdkPath --outputPath '
+      + '--configPath --scanFilePaths --apiModifiedPath --outPath --tmpPath '
+      + '__webpack_require__.s = "./src/collector/api/MainSrc.ts"',
+  });
+  const result = await discoverDevEco(sdk, home, { platform: 'win32', env: {} });
+  assert.equal(result.apiChangeBackend, 'index');
+  assert.equal(result.apiChangeScan, path.join(home, 'plugins/harmony/arkanalyzer-apiscan/index.js'));
+  assert.equal(result.cApiScanJar, null);
+});
+
+test('index family markers do not imply scanFilePaths support; help overrides incidental source strings',async()=>{
+  const scannerSource=`// __webpack_require__.s = "./src/collector/api/MainSrc.ts"
+if(process.argv.includes('--help'))console.log('Usage: index --configPath --apiModifiedPath --outPath --tmpPath');
+else if(process.argv.includes('--scanFilePaths'))throw new Error('unknown option');`;
+  const {sdk,home}=await fixture({scannerSource});
+  const result=await discoverDevEco(sdk,home,{platform:'win32',env:{}});
+  assert.equal(result.apiChangeBackend,'index');assert.equal(result.fileScanSupported,false);
+  assert.equal(result.moduleScanSupported,true);
+});
+
+test('reports unsupported layouts with inspected scanner candidates', async () => {
+  const { home, sdk } = await fixture({ scannerName: 'windows-scan.js', scannerSource: '--unknown-option' });
+  await assert.rejects(discoverDevEco(sdk, home, { platform: 'win32', env: {} }), error => {
+    assert.equal(error.code, 'UNSUPPORTED_DEVECO_SCANNER_LAYOUT');
+    assert.ok(error.details.scannerCandidates.some(candidate => candidate.file.endsWith('windows-scan.js')));
+    assert.equal(error.details.scannerCandidates.at(-1).contract, 'unknown');
+    return true;
+  });
+});
+
+test('probes help output when a bundle contains both CLI marker sets', async () => {
+  const markers = [
+    '--startVersion', '--endVersion', '--modulePaths', '--sdkPath', '--apiModifiedPath', '--outputPath',
+    '--configPath', '--scanFilePaths', '--outPath', '--tmpPath',
+  ].join(' ');
+  const { home, sdk } = await fixture({
+    scannerName: 'windows-bundle.js',
+    scannerSource: `// ${markers}\nif (process.argv.includes('--help')) console.log('--configPath --scanFilePaths --apiModifiedPath --outPath --tmpPath');\n`,
+  });
+  const result = await discoverDevEco(sdk, home, { platform: 'win32', env: {} });
+  assert.equal(result.apiChangeBackend, 'index');
+});
+
+test('uses API change rules packaged only inside the project assistant JAR', async () => {
+  const { root, home, sdk } = await fixture({
+    scannerName: 'index.js',
+    scannerSource: '__webpack_require__.s = "./src/collector/api/MainSrc.ts"',
+    resourceMode: 'jar',
+  });
+  const result = await discoverDevEco(sdk, home, { platform: 'win32', env: {} });
+  assert.equal(result.apiChangeResourceRoot, null);
+  assert.match(result.apiChangeResourceArchive, /project-api-change-assistant-26\.0\.0\.361\.jar$/);
+  const referenceRoot = path.join(root, 'references');
+  await mkdir(referenceRoot);
+  const rules = await loadDevEcoRules(result, referenceRoot,
+    assertUpgradeRange('5.0.0(12)', '26.0.0(26) Beta1'), 'upgrade');
+  assert.deepEqual(rules.errors, []);
+});
+
+test('fills missing directory rule versions from the project assistant JAR', async () => {
+  const { root, home, sdk } = await fixture({ resourceMode: 'mixed' });
+  const result = await discoverDevEco(sdk, home, { platform: 'win32', env: {} });
+  assert.match(result.apiChangeResourceRoot, /resources[/\\]apiChange$/);
+  assert.match(result.apiChangeResourceArchive, /project-api-change-assistant-26\.0\.0\.361\.jar$/);
+  const referenceRoot = path.join(root, 'references');
+  await mkdir(referenceRoot);
+  const rules = await loadDevEcoRules(result, referenceRoot,
+    assertUpgradeRange('5.0.0(12)', '26.0.0(26) Release'), 'upgrade');
+  assert.deepEqual(rules.errors, []);
+  assert.equal(rules.versionNames['26.0.0(26) Release'], 'HarmonyOS_26.0.0_Release');
+});
+
+test('accepts API 26 rule names without a repeated API level', async () => {
+  const { root, home, sdk } = await fixture({ resourceMode: 'modern-directory' });
+  const result = await discoverDevEco(sdk, home, { platform: 'win32', env: {} });
+  const referenceRoot = path.join(root, 'references');
+  await mkdir(referenceRoot);
+  const rules = await loadDevEcoRules(result, referenceRoot,
+    assertUpgradeRange('5.0.0(12)', '26.0.0(26) Release'), 'upgrade');
+  assert.deepEqual(rules.errors, []);
+});
+
+test('newer SDK covers an older target while a real parser remains required', async t => {
+  const historical = await fixture({ sdkData: { platformVersion: '6.1.1', apiVersion: '24', releaseType: 'Release' } });
+  t.after(() => rm(historical.root, { recursive: true, force: true }));
+  const toolchain = await discoverDevEco(historical.sdk, historical.home, { targetVersion: '24' });
+  assert.equal(toolchain.devecoCompatibility.status, 'COMPATIBLE');
+  assert.equal(toolchain.devecoCompatibility.requiredVersion, '6.1.1');
+  assert.doesNotThrow(() => validateTargetCoverage(toolchain, parseVersion('24')));
+  const newer = await fixture();
+  t.after(() => rm(newer.root, { recursive: true, force: true }));
+  const substituted = await discoverDevEco(newer.sdk, newer.home, { targetVersion: '24' });
+  assert.doesNotThrow(()=>validateTargetCoverage(substituted,parseVersion('24')));
+  await assert.rejects(buildSdkCatalog(substituted, parseVersion('24')), { code: 'ARKTS_PARSER_UNAVAILABLE' });
+});
+
+test('a historical IDE is accepted for its matching target instead of requiring IDE 26', async t => {
+  const { root, home, sdk } = await fixture({ ideVersion: '6.1.1.280',
+    sdkData: { platformVersion: '6.1.1', apiVersion: '24', releaseType: 'Release' } });
+  t.after(() => rm(root, { recursive: true, force: true }));
+  const toolchain = await discoverDevEco(sdk, home, { targetVersion: '6.1.1(24)' });
+  assert.equal(toolchain.devecoCompatibility.status, 'COMPATIBLE');
+  validateTargetCoverage(toolchain, parseVersion('24'));
+});
+
+test('missing and damaged product metadata block discovery with environment repair guidance', async t => {
+  const { root, home, sdk } = await fixture();
+  t.after(() => rm(root, { recursive: true, force: true }));
+  const metadata = path.join(home, 'product-info.json');
+  await rm(metadata);
+  await assert.rejects(discoverDevEco(sdk, home), { code: 'DEVECO_VERSION_UNRESOLVED' });
+  await writeFile(metadata, '{broken');
+  await assert.rejects(discoverDevEco(sdk, home), error => {
+    assert.equal(error.code, 'DEVECO_VERSION_UNRESOLVED');
+    assert.equal(error.details.metadataPath, metadata);
+    return true;
+  });
+});
+
+test('both scan modes and rule inspection reject old or unknown IDEs before probing the backend', async t => {
+  for (const [ideVersion, code] of [['6.1.1.280', 'DEVECO_TARGET_NOT_COVERED'], ['invalid', 'DEVECO_VERSION_UNRESOLVED']]) {
+    const { root, home, sdk } = await fixture({ ideVersion, scannerSource:
+      '// --startVersion --endVersion --modulePaths --sdkPath --apiModifiedPath --outputPath --configPath --scanFilePaths --outPath --tmpPath\n'
+      + 'require("node:fs").writeFileSync(require("node:path").join(__dirname, "backend-started"), "started");\n' });
+    t.after(() => rm(root, { recursive: true, force: true }));
+    const output = path.join(root, 'output');
+    for (const mode of ['upgrade', 'deprecated']) {
+      await assert.rejects(execute(['scan', '--project', path.join(root, 'project'), '--sdk', sdk, '--deveco-home', home,
+        '--from', '13', '--to', '26', '--mode', mode, '--output-dir', output]), { code, stage: 'VALIDATE_DEVECO_VERSION' });
+    }
+    await assert.rejects(execute(['inspect-rules', '--mode', 'upgrade', '--sdk', sdk, '--deveco-home', home, '--from', '13', '--to', '26']), { code });
+    const directories=(await readdir(output)).filter(name=>/^\d{14}(?:-\d+)?$/.test(name));
+    assert.equal(directories.length,2);
+    for (const directory of directories) {
+      const files = await readdir(path.join(output, directory));
+      const diagnostics = JSON.parse(await readFile(path.join(output,directory,'.internal','scanner','diagnostics.json'),'utf8'));
+      assert.deepEqual(files.sort(),['.internal',diagnostics.runtime.featureMode].sort());
+      assert.deepEqual(await readdir(path.join(output,directory,diagnostics.runtime.featureMode)),[]);
+      assert.deepEqual(await readdir(path.join(output,directory,'.internal','scanner')),['diagnostics.json']);
+      assert.equal(diagnostics.error.code, code);
+      assert.equal(diagnostics.error.stage, 'VALIDATE_DEVECO_VERSION');
+      assert.equal(diagnostics.error.details.installedVersion, ideVersion);
+    }
+    assert.equal((await readdir(path.join(home, 'plugins/harmony/arkanalyzer-apiscan'))).includes('backend-started'), false);
+  }
+});
+
+test('scanner canonicalizes default and probes an ambiguous backend only once', async t => {
+  const { root, sdk, home } = await fixture();
+  t.after(() => rm(root, { recursive: true, force: true }));
+  const count = path.join(root, 'help-calls.txt');
+  const source = '// --startVersion --endVersion --modulePaths --sdkPath --outputPath --configPath --apiModifiedPath --outPath --tmpPath\n'
+    + `require('node:fs').appendFileSync(${JSON.stringify(count)},'help\\n');\n`
+    + "console.log('--configPath --apiModifiedPath --outPath --tmpPath --scanFilePaths');\n";
+  await writeFile(path.join(home, 'plugins/harmony/arkanalyzer-apiscan/api-change-scan.js'), source);
+  for (const input of [sdk, path.join(sdk, 'default')]) {
+    const toolchain = await discoverDevEco(input, home);
+    assert.equal(toolchain.sdkRoot, sdk);
+    assert.equal(toolchain.sdkLocation.packagePath, path.join(sdk, 'default/sdk-pkg.json'));
+    assert.equal(toolchain.fileScanSupported, true);
+  }
+  assert.equal(await readFile(count, 'utf8'), 'help\n');
+});

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

@@ -0,0 +1,10 @@
+import { createRunOutputDirectory } from '../../core/cli.mjs';
+import { createScanBatch } from '../../../shared/platform/artifact-layout.mjs';
+import { runDevEcoScan } from '../../core/scan-runner.mjs';
+
+export async function runScanInBatch(mode, options) {
+  if (options.batchId) return runDevEcoScan({ ...options, mode });
+  const { directory } = await createRunOutputDirectory(options.outputDirectory);
+  const layout = await createScanBatch(options.outputDirectory, directory, { mode });
+  return runDevEcoScan({ ...options, mode, outputDirectory: directory, batchId: layout.batchId });
+}

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

@@ -0,0 +1,108 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtemp, mkdir, writeFile } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { ensureNativeBuild } from '../native/native.mjs';
+
+test('runs compileNative with the selected module target when ninja is missing', async () => {
+  const root = await mkdtemp(path.join(os.tmpdir(), 'harmony-native-'));
+  const moduleRoot = path.join(root, 'native');
+  await mkdir(path.join(root, 'oh_modules'), { recursive: true });
+  await mkdir(moduleRoot, { recursive: true });
+  const calls = [];
+  await ensureNativeBuild({
+    project: {
+      root,
+      product: { name: 'default' },
+      modules: [{ name: 'native', target: 'default', root: moduleRoot, hasNativeConfig: true }],
+    },
+    toolchain: { hvigorw: '/mock/hvigorw', sdkRoot: '/mock/sdk' },
+    runCommand: async (command, args) => {
+      calls.push({ command, args });
+      await mkdir(path.join(moduleRoot, '.cxx', 'default', 'arm64-v8a'), { recursive: true });
+      await writeFile(path.join(moduleRoot, '.cxx', 'default', 'arm64-v8a', 'build.ninja'), 'rule cc\n');
+      return { code: 0, stdout: '', stderr: '' };
+    },
+  });
+  assert.equal(calls.length, 1);
+  assert.ok(calls[0].args.includes('module=native@default'));
+  assert.ok(calls[0].args.includes('compileNative'));
+});
+
+test('reports a capability error when a native rebuild needs missing Hvigor', async () => {
+  const root = await mkdtemp(path.join(os.tmpdir(), 'harmony-native-no-hvigor-'));
+  const moduleRoot = path.join(root, 'native');
+  await mkdir(path.join(root, 'oh_modules'), { recursive: true });
+  await mkdir(moduleRoot);
+  await assert.rejects(ensureNativeBuild({
+    project: {
+      root, product: { name: 'default' },
+      modules: [{ name: 'native', target: 'default', root: moduleRoot, hasNativeConfig: true }],
+    },
+    toolchain: { hvigorw: null, sdkRoot: '/mock/sdk' },
+  }), { code: 'NATIVE_BUILD_TOOL_UNAVAILABLE' });
+});
+
+test('installs dependencies with ohpm before a native rebuild', async () => {
+  const root = await mkdtemp(path.join(os.tmpdir(), 'harmony-native-ohpm-'));
+  const moduleRoot = path.join(root, 'native');
+  await mkdir(moduleRoot, { recursive: true });
+  const calls = [];
+  const records = await ensureNativeBuild({
+    project: {
+      root, product: { name: 'default' },
+      modules: [{ name: 'native', target: 'default', root: moduleRoot, hasNativeConfig: true }],
+    },
+    toolchain: { hvigorw: '/mock/hvigorw', ohpm: '/mock/ohpm', sdkRoot: '/mock/sdk' },
+    runCommand: async (command, args, cwd, environment, timeoutMs) => {
+      calls.push({ command, args, cwd, timeoutMs });
+      if (command === '/mock/ohpm') {
+        await mkdir(path.join(root, 'oh_modules'), { recursive: true });
+        return { code: 0, stdout: 'installed', stderr: '' };
+      }
+      await mkdir(path.join(moduleRoot, '.cxx', 'default', 'arm64-v8a'), { recursive: true });
+      await writeFile(path.join(moduleRoot, '.cxx', 'default', 'arm64-v8a', 'build.ninja'), 'rule cc\n');
+      return { code: 0, stdout: '', stderr: '' };
+    },
+  });
+  assert.equal(calls[0].command, '/mock/ohpm');
+  assert.deepEqual(calls[0].args, ['install']);
+  assert.equal(calls[0].cwd, root);
+  assert.ok(calls[0].timeoutMs >= 60_000);
+  assert.equal(calls[1].command, '/mock/hvigorw');
+  assert.equal(records.length, 1);
+  assert.equal(records[0].rebuilt, true);
+});
+
+test('reports OHPM_INSTALL_FAILED when dependency installation fails', async () => {
+  const root = await mkdtemp(path.join(os.tmpdir(), 'harmony-native-ohpm-fail-'));
+  const moduleRoot = path.join(root, 'native');
+  await mkdir(moduleRoot, { recursive: true });
+  await assert.rejects(ensureNativeBuild({
+    project: {
+      root, product: { name: 'default' },
+      modules: [{ name: 'native', target: 'default', root: moduleRoot, hasNativeConfig: true }],
+    },
+    toolchain: { hvigorw: '/mock/hvigorw', ohpm: '/mock/ohpm', sdkRoot: '/mock/sdk' },
+    runCommand: async () => ({ code: 1, stdout: '', stderr: 'install failed' }),
+  }), error => {
+    assert.equal(error.code, 'OHPM_INSTALL_FAILED');
+    assert.match(error.message, /ohpm install failed for native module native/);
+    assert.equal(error.details.stderr, 'install failed');
+    return true;
+  });
+});
+
+test('reports OHPM_UNAVAILABLE when dependencies are missing without ohpm', async () => {
+  const root = await mkdtemp(path.join(os.tmpdir(), 'harmony-native-no-ohpm-'));
+  const moduleRoot = path.join(root, 'native');
+  await mkdir(moduleRoot, { recursive: true });
+  await assert.rejects(ensureNativeBuild({
+    project: {
+      root, product: { name: 'default' },
+      modules: [{ name: 'native', target: 'default', root: moduleRoot, hasNativeConfig: true }],
+    },
+    toolchain: { hvigorw: '/mock/hvigorw', ohpm: null, sdkRoot: '/mock/sdk' },
+  }), { code: 'OHPM_UNAVAILABLE' });
+});

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

@@ -0,0 +1,42 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtemp, mkdir, writeFile } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { loadProject, locationInsideScanDirs } from '../core/project.mjs';
+
+test('loads full module context but restricts emitted locations to scan dirs', async () => {
+  const root = await mkdtemp(path.join(os.tmpdir(), 'harmony-scan-project-'));
+  await writeFile(path.join(root, 'build-profile.json5'), `{
+    app: { products: [{ name: 'default', compatibleSdkVersion: '12' }] },
+    modules: [{ name: 'entry', srcPath: './entry' }, { name: 'feature', srcPath: './feature' }],
+  }`);
+  for (const module of ['entry', 'feature']) {
+    await mkdir(path.join(root, module, 'src', 'main', 'ets'), { recursive: true });
+    await writeFile(path.join(root, module, 'src', 'main', 'module.json5'), `{ module: { name: '${module}', type: 'har' } }`);
+    await writeFile(path.join(root, module, 'src', 'main', 'ets', 'A.ets'), 'const value = 1;\n');
+  }
+  const project = await loadProject(root, 'default', ['entry']);
+  assert.equal(project.model, 'STAGE');
+  assert.deepEqual(project.modules.map((item) => item.name), ['entry', 'feature']);
+  assert.deepEqual(project.selectedModules.map((item) => item.name), ['entry']);
+  assert.equal(locationInsideScanDirs(project, 'entry/src/main/ets/A.ets:1'), true);
+  assert.equal(locationInsideScanDirs(project, 'feature/src/main/ets/A.ets:1'), false);
+  assert.equal(locationInsideScanDirs(project, 'entry/src/main/ets/Missing.ets:1'), false);
+});
+
+test('dependency, build and test directories never enter source discovery or result scope', async () => {
+  const root = await mkdtemp(path.join(os.tmpdir(), 'harmony-excluded-source-'));
+  await writeFile(path.join(root, 'build-profile.json5'), '{app:{products:[{name:"default"}]},modules:[{name:"entry",srcPath:"entry"}]}');
+  await mkdir(path.join(root, 'entry/src/main'), { recursive: true });
+  await writeFile(path.join(root, 'entry/src/main/module.json5'), '{module:{type:"entry"}}');
+  for (const directory of ['entry/src/main/ets', 'entry/oh_modules', 'entry/build', 'entry/src/ohosTest', 'node_modules']) {
+    await mkdir(path.join(root, directory), { recursive: true });
+    await writeFile(path.join(root, directory, 'A.ets'), 'oldGlobal();');
+  }
+  await writeFile(path.join(root, 'entry', 'BuildProfile.ets'), 'generatedBuildProfile();');
+  const project = await loadProject(root, 'default');
+  assert.equal(project.sourceFiles.length, 1);
+  assert.equal(locationInsideScanDirs(project, 'entry/oh_modules/A.ets:1'), false);
+  assert.equal(locationInsideScanDirs(project, 'entry/build/A.ets:1'), false);
+});

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

@@ -0,0 +1,190 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdir, mkdtemp, writeFile, realpath } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { existsSync } from 'node:fs';
+import {
+  auditDeprecationRules,
+  applyBehaviorBaseline,
+  documentedNoAdaptation,
+  documentedNoAdaptationEvidence,
+} from '../core/rules.mjs';
+
+test('excludes API 12 behavior and UX rules without affecting other rule types', () => {
+  const makeRule = (ruleId, changedInSdk, changeType) => ({
+    ruleId, changedInSdk, changeType, sourceReference: `${ruleId}.md:1`, title: ruleId,
+  });
+  const result = applyBehaviorBaseline([
+    makeRule('behavior-12', '5.0.0(12) Release', 'API Behavior Change'),
+    makeRule('ux-12', '5.0.0(12) Beta3', 'UX Interaction Behavior Change'),
+    makeRule('definition-12', '5.0.0(12) Release', 'API Definition Change'),
+    makeRule('deprecated-12', '5.0.0(12) Release', 'Deprecated API'),
+    makeRule('behavior-13', '5.0.1(13) Beta3', 'API Behavior Change'),
+  ]);
+  assert.deepEqual(result.rules.map(rule => rule.ruleId), [
+    'definition-12', 'deprecated-12', 'behavior-13',
+  ]);
+  assert.deepEqual(result.audit, {
+    apiLevel: 12,
+    policy: 'ALREADY_ADAPTED',
+    reason: 'BEHAVIOR_BASELINE_ALREADY_ADAPTED',
+    excludedRuleCount: 2,
+  });
+  assert.deepEqual(result.excluded.map(item => [item.ruleId, item.reason]), [
+    ['behavior-12', 'BEHAVIOR_BASELINE_ALREADY_ADAPTED'],
+    ['ux-12', 'BEHAVIOR_BASELINE_ALREADY_ADAPTED'],
+  ]);
+});
+
+test('filters only sections whose overall guidance explicitly says no adaptation', () => {
+  assert.equal(documentedNoAdaptation(`### 默认效果变更
+
+**适配指导**
+
+默认效果变更，无需适配，但应注意变更后的默认效果是否符合开发者预期。`), true);
+  assert.equal(documentedNoAdaptation(`### Bugfix
+
+**变更影响**
+
+此变更不涉及应用适配。`), true);
+  assert.equal(documentedNoAdaptation(`### 混合变更
+
+1. 接口A涉及应用适配。
+2. 接口B不涉及应用适配。
+
+**适配指导**
+
+接口A需要修改，接口B无需适配。`), false);
+  assert.equal(documentedNoAdaptation(`### 条件变更
+
+**适配指导**
+
+若存在继承派生则需要修改，否则无需适配。`), false);
+  assert.equal(documentedNoAdaptation(`### 仅建议关注
+
+**适配指导**
+
+默认行为变更，应注意变更后的行为是否符合预期，可按需恢复旧效果。`), false);
+});
+
+test('records structured evidence for an unconditional official no-adaptation statement', () => {
+  assert.deepEqual(documentedNoAdaptationEvidence(`### 默认布局效果变更
+
+**变更影响**
+
+此变更涉及应用适配。
+
+**适配指导**
+
+默认行为变更，应用无需适配。`), {
+    sectionField: '适配指导',
+    statement: '默认行为变更，应用无需适配。',
+  });
+  assert.deepEqual(documentedNoAdaptationEvidence(`### Bugfix
+
+**变更影响**
+
+该变更不涉及应用适配。`), {
+    sectionField: '变更影响',
+    statement: '该变更不涉及应用适配。',
+  });
+  assert.deepEqual(documentedNoAdaptationEvidence(`### 系统接口补齐
+
+**适配指导**
+
+本变更不涉及应用适配。`), {
+    sectionField: '适配指导',
+    statement: '本变更不涉及应用适配。',
+  });
+  assert.equal(documentedNoAdaptationEvidence(`### 混合变更
+
+**适配指导**
+
+接口A需要修改，接口B无需适配。`), null);
+  assert.equal(documentedNoAdaptationEvidence(`### 条件变更
+
+**适配指导**
+
+若存在继承派生则需要修改，否则无需适配。`), null);
+  assert.equal(documentedNoAdaptationEvidence(`### 需评估的UX变更
+
+**变更影响**
+
+此变更不涉及应用适配。
+
+**适配指导**
+
+UX规格变更，无需适配。`), null);
+});
+
+const parserPath = process.env.HARMONYOS_TYPESCRIPT || '/Applications/DevEco-Studio.app/Contents/sdk/default/openharmony/ets/build-tools/ets-loader/node_modules/typescript/lib/typescript.js';
+test('audits declarations when the Windows parser normalizes source file separators', async () => {
+  const parserFile = 'D:/SDK/api/@ohos.legacy.d.ts';
+  const filesystemFile = 'D:\\SDK\\api\\@ohos.legacy.d.ts';
+  const text = '/** @deprecated since 26 */\ndeclare function legacy(): void;';
+  const declaration = {
+    symbolId: 'api-legacy',
+    relativePath: 'api/@ohos.legacy.d.ts',
+    file: parserFile,
+    line: 2,
+    start: text.indexOf('declare'),
+    name: 'legacy',
+    owner: '',
+    kind: 'method',
+    deprecatedSince: 26,
+    replacementApi: null,
+    declaration: 'declare function legacy(): void;',
+  };
+  const catalog = {
+    declarations: [declaration],
+    sourceFiles: new Map([[filesystemFile, { fileName: parserFile, text }]]),
+  };
+  const rule = {
+    ruleId: 'deprecated-legacy',
+    changeOperation: 'API_DEPRECATED',
+    affectedApis: [{
+      implementLanguage: 'typeScript',
+      completePath: '/interface/sdk-js/api/@ohos.legacy.d.ts',
+      className: 'unnamed',
+      interfaceName: 'legacy',
+      interfaceType: 'method',
+    }],
+  };
+
+  const result = await auditDeprecationRules({}, [rule], catalog);
+
+  assert.equal(result.targetSdkTagged, 1);
+  assert.match(rule.replacementDeclaration, /@deprecated since 26/);
+});
+
+test('enriches deprecated rules with the target SDK useinstead declaration', { skip: !existsSync(parserPath) }, async () => {
+  const sdkRoot = await mkdtemp(path.join(os.tmpdir(), 'scanner-deprecated-sdk-'));
+  const declarationFile = path.join(sdkRoot, 'default', 'openharmony', 'ets', 'component', 'common.d.ts');
+  await mkdir(path.dirname(declarationFile), { recursive: true });
+  await writeFile(declarationFile, `/**
+ * Returns the context.
+ * @deprecated since 18
+ * @useinstead ohos.arkui.UIContext.UIContext#getHostContext
+ */
+declare function getContext(component?: Object): Context;
+`);
+  const rule = {
+    ruleId: 'deprecated-get-context',
+    changeOperation: 'API_DEPRECATED',
+    affectedApis: [{
+      implementLanguage: 'typeScript',
+      completePath: '/interface/sdk-js/api/@internal/component/ets/common.d.ts',
+      interfaceName: 'getContext',
+      methodDefinition: 'declare function getContext(component?: Object): Context;',
+    }],
+  };
+
+  const result = await auditDeprecationRules({ sdkRoot, parserPath }, [rule]);
+
+  assert.equal(result.targetSdkTagged, 1);
+  assert.equal(result.replacementCount, 1);
+  assert.equal(rule.replacementApi, 'ohos.arkui.UIContext.UIContext#getHostContext');
+  assert.equal(rule.replacementSource, `${await realpath(declarationFile)}:6`);
+  assert.match(rule.replacementDeclaration, /@useinstead[\s\S]*declare function getContext/);
+});