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

package/node_modules/@hmos-library-adapter/executer/shared/skills/harmonyos-api-upgrade-adapter/scripts/scanner/deprecated/arkts-deprecations.mjs

@@ -0,0 +1,363 @@
+import { existsSync, readFileSync, realpathSync } from 'node:fs';
+import path from 'node:path';
+import { parseJson5 } from '../../shared/format/json5.mjs';
+import { sha256, portableRelative } from '../../shared/io/fs-utils.mjs';
+import { catalogEntry, declarationEvidence, deprecatedDocUrl } from '../core/sdk-deprecations.mjs';
+import { hyperlink } from '../../shared/format/csv.mjs';
+import { canonicalHarmonyVersion as canonicalVersion } from '../../shared/platform/version.mjs';
+import { normalizeComparablePath } from '../../shared/platform/paths.mjs';
+import { isArkTsSource } from '../../shared/platform/source-types.mjs';
+
+function realFile(file) {
+  return existsSync(file) ? realpathSync.native(file) : file;
+}
+
+export function compilerPathIdentity(file, platform = process.platform) {
+  return normalizeComparablePath(file, platform);
+}
+
+export function projectModuleForFile(project, file, platform = process.platform) {
+  const api = platform === 'win32' ? path.win32 : path.posix;
+  return project.modules.find((module) => {
+    const relation = api.relative(module.root, file);
+    return relation !== '' && relation !== '..'
+      && !relation.startsWith(`..${api.sep}`) && !api.isAbsolute(relation);
+  });
+}
+
+export function createArkTsProgram(project, catalog, { overlays = new Map(), compilerOptions = {}, builder = false } = {}) {
+  const { ts, toolchain } = catalog;
+  const options = { noEmit: true, skipLibCheck: true, target: ts.ScriptTarget.ES2021,
+    module: ts.ModuleKind.ESNext, moduleResolution: ts.ModuleResolutionKind.NodeJs, allowNonTsExtensions: true, etsAnnotationsEnable: true, ets: catalog.etsOptions, ...compilerOptions };
+  const host = ts.createCompilerHost(options);
+  host.getCanonicalFileName = file => compilerPathIdentity(file);
+  const overlayFiles = new Map([...overlays].map(([file, text]) => [host.getCanonicalFileName(file), { file, text }]));
+  const originalExists = host.fileExists.bind(host);
+  host.fileExists = file => overlayFiles.has(host.getCanonicalFileName(file)) || originalExists(file);
+  const canonicalFiles = new Map([...project.sourceFiles, ...catalog.sourceFiles.keys()]
+    .map(file => [host.getCanonicalFileName(file), file]));
+  const sdkSourceFiles = new Map([...catalog.sourceFiles]
+    .map(([file, sourceFile]) => [host.getCanonicalFileName(file), sourceFile]));
+  const packageCache = new Map();
+  const manifestHashes = new Map();
+  const unresolvedImports = [];
+  function packageJson(directory) {
+    if (!packageCache.has(directory)) {
+      const file = path.join(directory, 'oh-package.json5');
+      const text = existsSync(file) ? readFileSync(file, 'utf8') : null;
+      if (text !== null) manifestHashes.set(file, sha256(text));
+      packageCache.set(directory, text !== null ? parseJson5(text) : null);
+    }
+    return packageCache.get(directory);
+  }
+  function resolveFile(candidate) {
+    for (const suffix of ['', '.ets', '.ts', '.d.ets', '.d.ts']) {
+      const file = candidate + suffix;
+      if (isArkTsSource(file) && host.fileExists(file) && !requireDirectory(file)) {
+        const actual = realFile(file);
+        if (!isArkTsSource(actual)) continue;
+        return canonicalFiles.get(host.getCanonicalFileName(actual)) ?? actual;
+      }
+    }
+    const pkg = packageJson(candidate);
+    for (const main of [pkg?.types, pkg?.main, 'Index.ets', 'index.ets', 'index.d.ts', 'index.ts'].filter(Boolean)) {
+      const file = path.join(candidate, main);
+      if (isArkTsSource(file) && host.fileExists(file) && !requireDirectory(file)) {
+        const actual = realFile(file);
+        if (!isArkTsSource(actual)) continue;
+        return canonicalFiles.get(host.getCanonicalFileName(actual)) ?? actual;
+      }
+    }
+    return null;
+  }
+  // statSync is avoided in the hot path except for existing candidates.
+  function requireDirectory(file) {
+    try { return ts.sys.directoryExists(file); } catch { return false; }
+  }
+  function resolveModule(name, containing) {
+    if (/^@(kit|ohos|hms|arkts|system)\./.test(name)) {
+      for (const family of ['openharmony', 'hms']) {
+        const category = name.startsWith('@kit.') ? 'kits' : name.startsWith('@arkts.') ? 'arkts' : 'api';
+        const modulePath = name.startsWith('@ohos.inner.') ? name.slice('@ohos.inner.'.length).replaceAll('.', '/') : name;
+        const etsRoot = toolchain.sdkFamilies?.[family]
+          ?? path.join(toolchain.sdkRoot, 'default', family, 'ets');
+        const file = resolveFile(path.join(etsRoot, category, modulePath));
+        if (file) return file;
+      }
+      return null;
+    }
+    if (name.startsWith('.')) return resolveFile(path.resolve(path.dirname(containing), name));
+    let directory = path.dirname(containing);
+    while (directory !== path.dirname(directory)) {
+      const pkg = packageJson(directory);
+      const dependency = pkg?.dependencies?.[name] ?? pkg?.devDependencies?.[name];
+      if (typeof dependency === 'string' && dependency.startsWith('file:')) {
+        const local = resolveFile(path.resolve(directory, dependency.slice(5)));
+        if (local) return local;
+      }
+      const installed = resolveFile(path.join(directory, 'oh_modules', name));
+      if (installed) return installed;
+      directory = path.dirname(directory);
+    }
+    const module = project.modules.find(item => item.name === name || packageJson(item.root)?.name === name);
+    const resolved = module ? resolveFile(module.root) : ts.resolveModuleName(name, containing, options, host).resolvedModule?.resolvedFileName;
+    if (!resolved || !isArkTsSource(resolved)) return null;
+    const actual = realFile(resolved);
+    return isArkTsSource(actual) ? canonicalFiles.get(host.getCanonicalFileName(actual)) ?? actual : null;
+  }
+  const getSourceFile = host.getSourceFile.bind(host);
+  host.getSourceFile = (file, languageVersion, onError) => {
+    if (!isArkTsSource(file)) return undefined;
+    const identity = host.getCanonicalFileName(file);
+    const overlay = overlayFiles.get(identity);
+    if (overlay) return ts.createSourceFile(overlay.file, overlay.text, languageVersion, true,
+      overlay.file.endsWith('.ets') ? ts.ScriptKind.ETS : ts.ScriptKind.TS, options);
+    file = canonicalFiles.get(identity) ?? file;
+    const sdkFile = sdkSourceFiles.get(identity);
+    if (sdkFile) return sdkFile;
+    if (existsSync(file)) return ts.createSourceFile(file, readFileSync(file, 'utf8'), languageVersion, true, path.extname(file).toLowerCase() === '.ets' ? ts.ScriptKind.ETS : ts.ScriptKind.TS, options);
+    return getSourceFile(file, languageVersion, onError);
+  };
+  host.resolveModuleNames = (names, containing) => names.map(name => {
+    const file = resolveModule(name, containing);
+    if (!file) {
+      unresolvedImports.push({ file: containing, module: name, reason: 'MODULE_NOT_RESOLVED' });
+      return undefined;
+    }
+    return { resolvedFileName: file, extension: file.endsWith('.d.ets') ? ts.Extension.Dets : file.endsWith('.ets') ? ts.Extension.Ets : file.endsWith('.d.ts') ? ts.Extension.Dts : ts.Extension.Ts };
+  });
+  const roots = [...new Set([...project.sourceFiles, ...overlays.keys()])].filter(isArkTsSource);
+  const globals = [...catalog.sourceFiles].filter(([file, sf]) => isArkTsSource(file) && file.includes(`${path.sep}component${path.sep}`) && !ts.isExternalModule(sf)).map(([file]) => file);
+  if (builder) {
+    const originalSource = host.getSourceFile;
+    host.getSourceFile = (...args) => {
+      const source = originalSource(...args);
+      if (source) source.version = sha256(source.text);
+      return source;
+    };
+  }
+  const builderProgram = builder ? ts.createSemanticDiagnosticsBuilderProgram([...roots, ...globals], options, host) : null;
+  const program = builderProgram?.getProgram() ?? ts.createProgram([...roots, ...globals], options, host);
+  return { program, builderProgram, checker: program.getTypeChecker(), unresolvedImports, roots, manifestHashes,
+    sdkSourceFileIdentities: new Set(sdkSourceFiles.keys()), resolveModule };
+}
+
+// Follow only declarations and exported names actually used by project code.
+// Merely loading an SDK barrel (or a global component library) does not make all
+// of its exports relevant to the project's type evidence.
+export function classifySdkImportImpact({ program, checker, roots, unresolvedImports,
+  sdkSourceFileIdentities, resolveModule }, catalog) {
+  const { ts } = catalog;
+  const needed = new Set();
+  const visitedNodes = new Set();
+  const visitedExports = new Set();
+  const importKey = (file, module) => `${compilerPathIdentity(file)}\0${module}`;
+  const unresolvedKeys = new Set(unresolvedImports.map(item => importKey(item.file, item.module)));
+  const sourceFor = file => program.getSourceFile(file)
+    ?? program.getSourceFiles().find(source => compilerPathIdentity(source.fileName) === compilerPathIdentity(file));
+  function followExport(file, name) {
+    const key = `${compilerPathIdentity(file)}\0${name}`;
+    if (visitedExports.has(key)) return;
+    visitedExports.add(key);
+    const source = sourceFor(file);
+    if (!source) return;
+    for (const statement of source.statements) {
+      if (!ts.isExportDeclaration(statement) || !statement.moduleSpecifier) continue;
+      const module = statement.moduleSpecifier.text;
+      const elements = statement.exportClause?.elements;
+      const selected = elements?.filter(item => name === '*' || item.name.text === name);
+      if (elements && !selected.length) continue;
+      const resolved = resolveModule(module, source.fileName);
+      if (!resolved) {
+        needed.add(importKey(source.fileName, module));
+      } else if (!elements) followExport(resolved, name);
+      else for (const item of selected) followExport(resolved, item.propertyName?.text ?? item.name.text);
+    }
+  }
+  function declaration(node) {
+    if (!node || visitedNodes.has(node)) return;
+    visitedNodes.add(node);
+    const source = node.getSourceFile?.();
+    if (!source) return;
+    if (ts.isImportSpecifier(node) || ts.isNamespaceImport(node) || ts.isImportClause(node)) {
+      let owner = node;
+      while (owner && !ts.isImportDeclaration(owner)) owner = owner.parent;
+      if (owner?.moduleSpecifier) {
+        const module = owner.moduleSpecifier.text;
+        const resolved = resolveModule(module, source.fileName);
+        if (!resolved) needed.add(importKey(source.fileName, module));
+        else followExport(resolved, ts.isNamespaceImport(node) ? '*' : node.propertyName?.text ?? node.name?.text ?? 'default');
+      }
+    }
+    if (ts.isExportSpecifier(node)) {
+      const owner = node.parent?.parent;
+      if (owner?.moduleSpecifier) {
+        const module = owner.moduleSpecifier.text;
+        const resolved = resolveModule(module, source.fileName);
+        if (!resolved) needed.add(importKey(source.fileName, module));
+        else followExport(resolved, node.propertyName?.text ?? node.name.text);
+      }
+    }
+    if (sdkSourceFileIdentities.has(compilerPathIdentity(source.fileName))) {
+      function visit(child) {
+        if (ts.isIdentifier(child) || ts.isStringLiteral(child)) symbol(checker.getSymbolAtLocation(child));
+        ts.forEachChild(child, visit);
+      }
+      visit(node);
+    }
+  }
+  function symbol(value) {
+    for (const node of value?.declarations ?? []) declaration(node);
+    if (value?.flags & ts.SymbolFlags.Alias) {
+      const target = checker.getAliasedSymbol(value);
+      if (target !== value) for (const node of target?.declarations ?? []) declaration(node);
+    }
+  }
+  for (const root of roots) {
+    const source = sourceFor(root);
+    if (!source) continue;
+    function visit(node) {
+      if (ts.isImportDeclaration(node)) return;
+      if (ts.isExportDeclaration(node)) {
+        if (node.moduleSpecifier) {
+          const resolved = resolveModule(node.moduleSpecifier.text, source.fileName);
+          if (resolved) {
+            if (node.exportClause?.elements) for (const exported of node.exportClause.elements) followExport(resolved, exported.propertyName?.text ?? exported.name.text);
+            else followExport(resolved, '*');
+          }
+        }
+        return;
+      }
+      if (ts.isIdentifier(node) || ts.isStringLiteral(node)) symbol(checker.getSymbolAtLocation(node));
+      if (ts.isCallExpression(node) || ts.isNewExpression(node)) declaration(checker.getResolvedSignature(node)?.declaration);
+      ts.forEachChild(node, visit);
+    }
+    visit(source);
+  }
+  return unresolvedImports.map(item => {
+    const sdk = sdkSourceFileIdentities.has(compilerPathIdentity(item.file));
+    const system = /^@(kit|ohos|hms|arkts|system)\./.test(item.module);
+    const affected = !sdk ? system : needed.has(importKey(item.file, item.module));
+    return { ...item, blocking: affected,
+      reason: sdk && !affected ? 'UNUSED_SDK_IMPORT_NOT_RESOLVED' : item.reason,
+      impactEvidence: sdk ? { usedDeclarationAnalysis: true, requiredImport: affected,
+        inspectedMissingImport: unresolvedKeys.has(importKey(item.file, item.module)) } : undefined };
+  });
+}
+
+function actualSymbol(ts, checker, node) {
+  let symbol = checker.getSymbolAtLocation(node);
+  if (symbol?.flags & ts.SymbolFlags.Alias) symbol = checker.getAliasedSymbol(symbol);
+  return symbol;
+}
+
+function symbolEntries(catalog, symbol) {
+  return symbol?.declarations?.map(node => catalogEntry(catalog, node)).filter(Boolean) ?? [];
+}
+
+const PLATFORM_BY_LEVEL = 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']]);
+
+export async function scanArkTsDeprecations({ project, catalog, documentRules = [] }) {
+  const { ts } = catalog;
+  const context = createArkTsProgram(project, catalog);
+  const { program, checker, roots, manifestHashes } = context;
+  const active = new Set(catalog.deprecatedEntries.map(entry => entry.symbolId));
+  const unresolved = [];
+  const findings = [];
+  const seen = new Set();
+  const isCallLike = node => ts.isCallExpression(node) || ts.isNewExpression(node) || ts.isEtsComponentExpression(node);
+  function emit(node, entry, related = [], call = null) {
+    if (!active.has(entry.symbolId)) return;
+    const sf = node.getSourceFile();
+    const start = node.getStart(sf);
+    const position = sf.getLineAndCharacterOfPosition(start);
+    const module = projectModuleForFile(project, sf.fileName);
+    const relative = module ? `${module.name}/${portableRelative(module.root, sf.fileName)}` : portableRelative(project.root, sf.fileName);
+    const occurrenceId = `occurrence-${sha256([relative, start, node.end, entry.symbolId].join('\0')).slice(0, 24)}`;
+    if (seen.has(occurrenceId)) return;
+    seen.add(occurrenceId);
+    const references = documentRules.filter(rule => rule.sdkSymbolIds?.includes(entry.symbolId)).map(rule => ({ ruleId: rule.ruleId, sourceReference: rule.sourceReference, url: rule.url || null }));
+    const platform = PLATFORM_BY_LEVEL.get(entry.deprecatedSince);
+    findings.push({
+      'Api Definition': entry.declaration, Language: 'ArkTS',
+      'Changed in SDK': platform ? canonicalVersion(`${platform}(${entry.deprecatedSince})`) : '',
+      'Affected Versions': 'N/A (compile-time)', Title: hyperlink(deprecatedDocUrl(entry, references), `${entry.qualifiedName}：API 废弃`),
+      'Code Location': `${relative}:${position.line + 1}`, Fixed: 'Unfixed',
+      'Change Type': 'Deprecated API', 'Rule ID': `sdk-deprecated-${entry.symbolId.slice(4)}`,
+      'Change Operation': 'API_DEPRECATED', 'Source Reference': `${entry.file}:${entry.line}`,
+      'Replacement API': entry.replacementApi ?? '', 'Replacement Source': `${entry.file}:${entry.line}`,
+      'API Symbol ID': entry.symbolId, Column: position.character + 1, 'Deprecated Since': entry.deprecatedSince,
+      'Detection Source': 'SDK_STATE', 'Source Scope': 'PROJECT',
+      includedInCsv: true, disposition: 'REQUIRES_REVIEW', filterReason: null, applicabilityProof: null,
+      occurrenceId, sourceSymbol: node.text, sourceFileHash: sha256(sf.text), sourceRange: { start, end: node.end },
+      callRange: call ? { start: call.getStart(sf), end: call.end } : null,
+      sdkEvidence: declarationEvidence(entry, catalog),
+      relatedDeclarations: related.map(item => declarationEvidence(item, catalog)), documentReferences: references,
+    });
+  }
+  for (const file of roots) {
+    const sf = program.getSourceFile(file);
+    if (!sf) { unresolved.push({ file, reason: 'SOURCE_NOT_PARSED' }); continue; }
+    unresolved.push(...sf.parseDiagnostics.map(d => ({ file, reason: 'SOURCE_PARSE_ERROR', start: d.start, message: ts.flattenDiagnosticMessageText(d.messageText, ' ') })));
+    function visit(node) {
+      if (ts.isIdentifier(node) || ts.isStringLiteral(node)) {
+        const parent = node.parent;
+        const declarationName = parent.name === node && !ts.isPropertyAccessExpression(parent) && !ts.isPropertyAssignment(parent) && !ts.isShorthandPropertyAssignment(parent);
+        const importName = ts.isImportSpecifier(parent) || ts.isImportClause(parent) || ts.isNamespaceImport(parent) || ts.isExportSpecifier(parent);
+        if (!declarationName && !importName) {
+          let entries = symbolEntries(catalog, actualSymbol(ts, checker, node));
+          let callee = node;
+          if (ts.isPropertyAccessExpression(parent) && parent.name === node) callee = parent;
+          if (ts.isElementAccessExpression(parent) && parent.argumentExpression === node) callee = parent;
+          const call = callee.parent && isCallLike(callee.parent) && callee.parent.expression === callee ? callee.parent : null;
+          const receiverCall = (ts.isPropertyAccessExpression(parent) || ts.isElementAccessExpression(parent)) && parent.expression === node && parent.parent && isCallLike(parent.parent) && parent.parent.expression === parent ? parent.parent : null;
+          if (call) {
+            const signatureEntry = catalogEntry(catalog, checker.getResolvedSignature(call)?.declaration);
+            if (ts.isElementAccessExpression(callee) && !signatureEntry && !ts.isStringLiteral(node)) {
+              const receiver = checker.getTypeAtLocation(callee.expression);
+              if (symbolEntries(catalog, receiver.symbol ?? receiver.aliasSymbol).length && !checker.getIndexInfoOfType(receiver, ts.IndexKind.String)) unresolved.push({ file, start: node.getStart(sf), api: call.getText(sf), reason: 'SDK_DYNAMIC_MEMBER_NOT_RESOLVED' });
+            }
+            if (!signatureEntry && entries.some(entry => entry.kind === 'method')) unresolved.push({ file, start: node.getStart(sf), api: call.getText(sf), reason: 'SDK_CALL_SIGNATURE_NOT_RESOLVED' });
+            if (ts.isNewExpression(call)) {
+              const typeEntry = entries.find(entry => ['class', 'struct', 'interface'].includes(entry.kind));
+              entries = typeEntry && active.has(typeEntry.symbolId) ? [typeEntry] : signatureEntry ? [signatureEntry] : [];
+              if (entries[0]) emit(node, entries[0], signatureEntry ? [signatureEntry] : [], call);
+              entries = [];
+            } else entries = signatureEntry ? [signatureEntry] : entries.filter(entry => entry.kind !== 'method');
+          }
+          if (ts.isPropertyAssignment(parent) && parent.name === node) {
+            const object = parent.parent;
+            const contextual = checker.getContextualType(object)?.getProperty(node.text);
+            entries = symbolEntries(catalog, contextual);
+            // ArkUI struct initializers are not regular TS constructor parameter objects.
+            if (!entries.length && isCallLike(object.parent)) {
+              const component = actualSymbol(ts, checker, object.parent.expression);
+              const componentEntry = symbolEntries(catalog, component).find(entry => entry.kind === 'struct');
+              if (componentEntry) entries = catalog.declarations.filter(entry => entry.file === componentEntry.file && entry.owner === componentEntry.qualifiedName && entry.name === node.text);
+            }
+          }
+          for (const entry of entries) emit(node, entry, [], call ?? receiverCall);
+          if (!entries.length && ts.isPropertyAccessExpression(parent) && parent.name === node && !checker.getSymbolAtLocation(node)) {
+            let base = parent.expression;
+            while (ts.isPropertyAccessExpression(base)) base = base.expression;
+            const receiverType = checker.getTypeAtLocation(parent.expression);
+            const sdkType = symbolEntries(catalog, receiverType.symbol ?? receiverType.aliasSymbol).length > 0;
+            const indexed = checker.getIndexInfoOfType(receiverType, ts.IndexKind.String);
+            if (!indexed && (sdkType || symbolEntries(catalog, actualSymbol(ts, checker, base)).length)) unresolved.push({ file, start: node.getStart(sf), api: parent.getText(sf), reason: 'SDK_MEMBER_NOT_RESOLVED' });
+          }
+        }
+      }
+      ts.forEachChild(node, visit);
+    }
+    visit(sf);
+  }
+  // Triggered module resolution includes SDK and dependency declarations, not just roots.
+  const importImpact = classifySdkImportImpact(context, catalog);
+  unresolved.push(...importImpact.filter(item => item.blocking));
+  const resolutionWarnings = importImpact.filter(item => !item.blocking);
+  const uniqueUnresolved = [...new Map(unresolved.map(item => [JSON.stringify(item), item])).values()];
+  findings.sort((a, b) => a['Code Location'].localeCompare(b['Code Location'], undefined, { numeric: true }) || a.Column - b.Column || a['API Symbol ID'].localeCompare(b['API Symbol ID']));
+  const analyzedFiles = [...program.getSourceFiles().map(sf => ({ file: sf.fileName, hash: sha256(sf.text) })), ...[...manifestHashes].map(([file, hash]) => ({ file, hash }))];
+  return { findings, unresolved: uniqueUnresolved, resolutionWarnings, analyzedFiles, coverage: { status: uniqueUnresolved.length ? 'INCOMPLETE' : 'COMPLETE', scannedFileCount: roots.length, findingCount: findings.length, unresolvedCount: uniqueUnresolved.length, projectImportWarningCount: resolutionWarnings.length, sdkSnapshot: catalog.snapshot,
+    analysisSnapshot: sha256(analyzedFiles.map(item => `${item.file}\0${item.hash}`).sort().join('\n')) } };
+}

package/node_modules/@hmos-library-adapter/executer/shared/skills/harmonyos-api-upgrade-adapter/scripts/scanner/deprecated/build-log.mjs

@@ -0,0 +1,72 @@
+import { readFile } from 'node:fs/promises';
+import path from 'node:path';
+import { sha256 } from '../../shared/io/fs-utils.mjs';
+import { deprecatedDocUrl } from '../core/sdk-deprecations.mjs';
+import { hyperlink } from '../../shared/format/csv.mjs';
+import { relativePathInside, comparableCodeLocation } from '../../shared/platform/paths.mjs';
+
+export function parseDeprecatedBuildLog(text) {
+  const diagnostics = [];
+  let location = null;
+  const lines = text.replace(/\x1b\[[0-9;]*m/g, '').split(/\r?\n/);
+  for (const [index, line] of lines.entries()) {
+    const match = line.match(/File:\s*(.+?):(\d+):(\d+)/);
+    if (match) location = { file: match[1].replaceAll('\\', '/'), line: Number(match[2]), column: Number(match[3]) };
+    const deprecated = line.match(/'([^']+)' has been deprecated\./);
+    if (deprecated) diagnostics.push({ ...location, symbol: deprecated[1], logLine: index + 1, located: location !== null });
+    if (/^(?:>|WARN:|ERROR:)/.test(line) && !match && !deprecated) location = null;
+  }
+  return [...new Map(diagnostics.map(item => [[item.file, item.line, item.column, item.symbol].join('\0'), item])).values()];
+}
+
+export async function importDeprecatedBuildLog({ project, catalog, logPath = null, evidencePath = null }) {
+  if (!logPath && evidencePath) throw new Error('--build-evidence requires --build-log');
+  if (!logPath) return { findings: [], warnings: [], audit: null };
+  const text = await readFile(logPath, 'utf8');
+  const diagnostics = parseDeprecatedBuildLog(text);
+  if (!evidencePath) return { findings: [], warnings: ['编译日志缺少配套快照证据，仅用于对比，不导入主CSV'], audit: {
+    status: 'UNVERIFIED_LOG', logHash: sha256(text), diagnostics, importedCount: 0,
+  } };
+  const evidence = JSON.parse(await readFile(evidencePath, 'utf8'));
+  const expected = { schemaVersion: 1, logHash: sha256(text), sourceSnapshot: project.sourceSnapshot,
+    buildProfileHash: project.buildProfileHash, sdkSnapshot: catalog.snapshot, targetSdk: catalog.coverage.targetSdk, product: project.product.name, nonIncremental: true, status: 'PASSED' };
+  const errors = Object.entries(expected).filter(([key, value]) => evidence[key] !== value).map(([key]) => key);
+  const platform = catalog.platform ?? process.platform;
+  const api = platform === 'win32' ? path.win32 : path;
+  if (typeof evidence.projectRoot !== 'string' || !api.isAbsolute(evidence.projectRoot)) errors.push('projectRoot');
+  if (errors.length) {
+    const error = new Error(`Build evidence does not match this scan: ${errors.join(', ')}`);
+    error.code = 'BUILD_EVIDENCE_MISMATCH'; error.details = errors; throw error;
+  }
+  const findings = [];
+  const records = [];
+  for (const diagnostic of diagnostics) {
+    const relative = diagnostic.file ? relativePathInside(evidence.projectRoot, diagnostic.file, platform) : null;
+    if (!relative || relative.split('/').includes('..')) { records.push({ ...diagnostic, reason: 'UNMAPPED_LOCATION' }); continue; }
+    if (!relative.split('/').includes('oh_modules')) { records.push({ ...diagnostic, reason: 'PROJECT_DIAGNOSTIC_RECONCILIATION_ONLY' }); continue; }
+    const binding = evidence.apiBindings?.find(item => comparableCodeLocation(item.file, null, platform) === comparableCodeLocation(relative, null, platform)
+      && item.line === diagnostic.line && item.column === diagnostic.column && item.symbol === diagnostic.symbol);
+    const entry = binding ? catalog.deprecatedEntries.find(item => item.symbolId === binding.symbolId) : null;
+    if (binding && (!entry || entry.name !== diagnostic.symbol)) {
+      const error = new Error(`Invalid SDK symbol binding in build evidence: ${relative}:${diagnostic.line}`);
+      error.code = 'BUILD_API_BINDING_MISMATCH'; throw error;
+    }
+    const occurrenceId = `compiler-${sha256([relative, diagnostic.line, diagnostic.column, diagnostic.symbol].join('\0')).slice(0, 24)}`;
+    findings.push({
+      'Api Definition': entry?.declaration ?? `${diagnostic.symbol} (compiler deprecation warning)`, Language: 'ArkTS',
+      'Changed in SDK': '', 'Affected Versions': 'N/A (compile-time)', Title: hyperlink(deprecatedDocUrl(entry), `${diagnostic.symbol}：第三方依赖废弃告警`),
+      'Code Location': `${relative}:${diagnostic.line}`, Fixed: 'Unfixed', 'Change Type': 'Deprecated API',
+      'Rule ID': entry ? `sdk-deprecated-${entry.symbolId.slice(4)}` : occurrenceId, 'Change Operation': 'API_DEPRECATED',
+      'Source Reference': `${path.resolve(logPath)}:${diagnostic.logLine}`,
+      'Replacement API': entry?.replacementApi ?? '', 'Replacement Source': entry ? `${entry.file}:${entry.line}` : '',
+      'API Symbol ID': entry?.symbolId ?? '', Column: diagnostic.column, 'Deprecated Since': entry?.deprecatedSince ?? '',
+      'Detection Source': 'BUILD_LOG', 'Source Scope': 'DEPENDENCY',
+      includedInCsv: true, disposition: 'REQUIRES_REVIEW', filterReason: null, applicabilityProof: null,
+      occurrenceId, evidenceStatus: entry ? 'SDK_BOUND' : 'COMPILER_ONLY', autoEditAllowed: false,
+      sdkEvidence: entry ? { ...entry, sdkSnapshot: catalog.snapshot, targetSdk: catalog.coverage.targetSdk } : null,
+      compilerEvidence: { ...diagnostic, logHash: evidence.logHash },
+    });
+    records.push({ ...diagnostic, reason: entry ? 'IMPORTED_SDK_BOUND_DEPENDENCY' : 'IMPORTED_DEPENDENCY_REQUIRES_CONFIRMATION' });
+  }
+  return { findings, warnings: [], audit: { status: 'VERIFIED_LOG', importedCount: findings.length, logHash: evidence.logHash, diagnostics: records } };
+}

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

@@ -0,0 +1,95 @@
+import { readdir, stat } from 'node:fs/promises';
+import path from 'node:path';
+import { exists, listFiles } from '../../shared/io/fs-utils.mjs';
+import { runProcess } from '../../shared/platform/process.mjs';
+
+async function findNinja(directory) {
+  if (!(await exists(directory))) return [];
+  const results = [];
+  async function visit(current) {
+    const entries = await readdir(current, { withFileTypes: true });
+    entries.sort((left, right) => left.name.localeCompare(right.name));
+    for (const entry of entries) {
+      const target = path.join(current, entry.name);
+      if (entry.isDirectory()) await visit(target);
+      else if (entry.isFile() && entry.name === 'build.ninja') results.push(target);
+    }
+  }
+  await visit(directory);
+  return results;
+}
+
+async function run(command, args, cwd, environment = process.env, timeoutMs = null) {
+  const result = await runProcess(command, args, { cwd, env: environment, timeoutMs });
+  if (result.error) throw new Error(result.error);
+  return { code: result.exitCode, stdout: result.stdout, stderr: result.stderr, error: result.error };
+}
+
+async function nativeBuildIsStale(moduleRoot, ninjaFiles) {
+  if (ninjaFiles.length === 0) return true;
+  const inputs = await listFiles(moduleRoot, (file) => {
+    const normalized = file.split(path.sep).join('/');
+    if (normalized.includes('/.cxx/') || normalized.includes('/build/') || normalized.includes('/oh_modules/')) return false;
+    return /\.(?:c|cc|cpp|cxx|h|hpp)$/i.test(file)
+      || ['CMakeLists.txt', 'build-profile.json5', 'module.json5'].includes(path.basename(file));
+  });
+  const inputTimes = await Promise.all(inputs.map(async (file) => (await stat(file)).mtimeMs));
+  const ninjaTimes = await Promise.all(ninjaFiles.map(async (file) => (await stat(file)).mtimeMs));
+  const newestInput = Math.max(0, ...inputTimes);
+  return ninjaTimes.some((time) => time < newestInput);
+}
+
+export async function ensureNativeBuild({ project, toolchain, mode = 'auto', runCommand = run }) {
+  const nativeModules = (project.selectedModules ?? project.modules).filter((module) => module.hasNativeConfig);
+  const records = [];
+  for (const module of nativeModules) {
+    let ninjaFiles = await findNinja(path.join(module.root, '.cxx'));
+    let stale = await nativeBuildIsStale(module.root, ninjaFiles);
+    let rebuilt = false;
+    if (stale && mode === 'auto') {
+      if (!toolchain.hvigorw) {
+        const error = new Error(`Hvigor is unavailable for native module ${module.name}`);
+        error.code = 'NATIVE_BUILD_TOOL_UNAVAILABLE';
+        throw error;
+      }
+      if (!(await exists(path.join(project.root, 'oh_modules')))) {
+        if (!toolchain.ohpm) {
+          const error = new Error(`oh_modules is missing and ohpm is unavailable for native module ${module.name}; run ohpm install manually`);
+          error.code = 'OHPM_UNAVAILABLE';
+          throw error;
+        }
+        const install = await runCommand(toolchain.ohpm, ['install'], project.root,
+          { ...process.env, DEVECO_SDK_HOME: toolchain.sdkRoot }, 10 * 60_000);
+        if (install.code !== 0) {
+          const error = new Error(`ohpm install failed for native module ${module.name}`);
+          error.code = 'OHPM_INSTALL_FAILED';
+          error.details = {
+            stdout: String(install.stdout ?? '').slice(-8000),
+            stderr: String(install.stderr ?? '').slice(-8000),
+          };
+          throw error;
+        }
+      }
+      const result = await runCommand(toolchain.hvigorw, [
+        '--mode', 'module',
+        '-p', `module=${module.name}@${module.target}`,
+        '-p', `product=${project.product.name}`,
+        'compileNative', '--analyze=normal', '--no-daemon',
+      ], project.root, { ...process.env, DEVECO_SDK_HOME: toolchain.sdkRoot });
+      if (result.code !== 0) {
+        const error = new Error(`Hvigor native build failed for ${module.name}`);
+        error.code = 'NATIVE_BUILD_FAILED';
+        error.details = { stdout: result.stdout.slice(-8000), stderr: result.stderr.slice(-8000) };
+        throw error;
+      }
+      rebuilt = true;
+      ninjaFiles = await findNinja(path.join(module.root, '.cxx'));
+      stale = await nativeBuildIsStale(module.root, ninjaFiles);
+    }
+    if (ninjaFiles.length === 0 || stale) {
+      throw new Error(`build.ninja is missing or stale for native module ${module.name}`);
+    }
+    records.push({ module: module.name, ninjaFiles, rebuilt });
+  }
+  return records;
+}

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

@@ -0,0 +1,16 @@
+{
+  "name": "@local/harmonyos-api-scanner",
+  "version": "4.0.0",
+  "private": true,
+  "type": "module",
+  "bin": {
+    "harmony-api-scan": "./bin/harmony-api-scan.mjs"
+  },
+  "scripts": {
+    "test": "node --test",
+    "inspect-rules": "node ./bin/harmony-api-scan.mjs inspect-rules"
+  },
+  "engines": {
+    "node": ">=20"
+  }
+}

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

@@ -0,0 +1,94 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtemp, mkdir, readFile, writeFile, readdir, realpath, rm, symlink } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { batchArtifactPaths, createScanBatch, ensureBatchDirectory } from '../../shared/platform/artifact-layout.mjs';
+
+async function fixture(t) {
+  const root = await mkdtemp(path.join(os.tmpdir(), '批次 中文 space-'));
+  t.after(() => rm(root, { recursive: true, force: true }));
+  const directory = path.join(root, '20261027172821-2');
+  await mkdir(directory);
+  return { root, directory };
+}
+
+for (const mode of ['upgrade', 'deprecated']) {
+  test(`${mode} creates only layout4 and binds original/adapted CSVs to one random ID`, async t => {
+    const { root, directory } = await fixture(t);
+    const batch = await createScanBatch(root, directory, { mode });
+    assert.equal(batch.schemaVersion, 4);
+    assert.equal(batch.deliveryDirectory, path.join(directory, mode));
+    const stem = mode === 'upgrade' ? `scan-results-${batch.batchId}` : `apiChange_${path.basename(directory)}`;
+    assert.equal(batch.rawCsv, path.join(directory, mode, `${stem}.csv`));
+    assert.equal(batch.adaptedCsv, path.join(directory, mode, `adapted-results-${batch.batchId}.csv`));
+    assert.equal(batch.scanJson, path.join(directory, '.internal', 'scanner', `${stem}.scan.json`));
+    const metadata = JSON.parse(await readFile(batch.batchMetadataPath, 'utf8'));
+    assert.equal(metadata.schemaVersion, 4);
+    assert.equal(metadata.batchId, batch.batchId);
+    assert.equal(metadata.mode, mode);
+    assert.deepEqual((await readdir(directory)).sort(), ['.internal', mode].sort());
+    const original = Buffer.from('\ufeffTitle,Fixed\r\n"重复,调用",Unfixed\r\n"重复,调用",Unfixed\r\n');
+    await writeFile(batch.rawCsv, original);
+    await writeFile(batch.adaptedCsv, '独立评估\r\n');
+    assert.deepEqual(await readFile(batch.rawCsv), original);
+    const variant = path.join(directory, mode.toUpperCase());
+    let sameDirectory = false;
+    try { sameDirectory = await realpath(variant) === await realpath(batch.deliveryDirectory); }
+    catch (error) { if (error.code !== 'ENOENT') throw error; }
+    if (sameDirectory) await ensureBatchDirectory(batch, variant);
+    assert.equal(batchArtifactPaths(directory, batch.batchId, mode).adaptedCsv, batch.adaptedCsv);
+  });
+
+  test(`${mode} supports drive and UNC paths and rejects invalid batch identities`, () => {
+    for (const directory of ['D:\\中文 工程\\20261027172821-2', '\\\\server\\共享\\20261027172821-2']) {
+      const batch = batchArtifactPaths(directory, 'abcdef012345', mode);
+      assert.equal(batch.deliveryDirectory, path.win32.join(directory, mode));
+      assert.equal(batch.adaptedCsv, path.win32.join(directory, mode, 'adapted-results-abcdef012345.csv'));
+      assert.equal(batch.batchMetadataPath, path.win32.join(directory, '.internal', 'scan-batch.json'));
+    }
+    assert.throws(() => batchArtifactPaths('20261027172821', '../outside', mode), { code: 'SCAN_BATCH_INVALID' });
+    assert.throws(() => batchArtifactPaths('20261027172821', 'abcdef012345', 'other'), { code: 'SCAN_BATCH_INVALID' });
+    if (mode === 'deprecated') assert.throws(() => batchArtifactPaths('invalid-stamp', 'abcdef012345', mode), { code: 'SCAN_BATCH_INVALID' });
+  });
+
+  test(`${mode} resolves concurrent ID collisions and stops after the collision budget`, async t => {
+    const { root, directory } = await fixture(t);
+    const second = path.join(root, '20261027172822');
+    await mkdir(second);
+    let a = 0, b = 0;
+    const batches = await Promise.all([
+      createScanBatch(root, directory, { mode, idFactory: () => a++ ? 'bbbbbbbbbbbb' : 'aaaaaaaaaaaa' }),
+      createScanBatch(root, second, { mode, idFactory: () => b++ ? 'cccccccccccc' : 'aaaaaaaaaaaa' }),
+    ]);
+    assert.notEqual(batches[0].batchId, batches[1].batchId);
+    const third = path.join(root, '20261027172823');
+    await mkdir(third);
+    let calls = 0;
+    await assert.rejects(createScanBatch(root, third, { mode, idFactory: () => { calls++; return 'aaaaaaaaaaaa'; } }), { code: 'SCAN_BATCH_COLLISION' });
+    assert.equal(calls, 32);
+  });
+
+  test(`${mode} creation rejects linked feature and internal directories outside the batch`, async t => {
+    const { root, directory } = await fixture(t);
+    const outside = await mkdtemp(path.join(os.tmpdir(), 'outside-batch-'));
+    t.after(() => rm(outside, { recursive: true, force: true }));
+    for (const name of [mode, '.internal']) {
+      await rm(path.join(directory, '.internal'), { recursive: true, force: true });
+      const link = path.join(directory, name);
+      await symlink(outside, link, process.platform === 'win32' ? 'junction' : 'dir');
+      await assert.rejects(createScanBatch(root, directory, { mode }), { code: 'SCAN_BATCH_INVALID' });
+      await rm(link, { recursive: true });
+      assert.deepEqual(await readdir(outside), []);
+    }
+  });
+}
+
+test('a linked batch registry cannot publish outside the chosen output root', async t => {
+  const { root, directory } = await fixture(t);
+  const outside = await mkdtemp(path.join(os.tmpdir(), 'outside-registry-'));
+  t.after(() => rm(outside, { recursive: true, force: true }));
+  await symlink(outside, path.join(root, '.batch-ids'), process.platform === 'win32' ? 'junction' : 'dir');
+  await assert.rejects(createScanBatch(root, directory), { code: 'SCAN_BATCH_INVALID' });
+  assert.deepEqual(await readdir(outside), []);
+});