@ohos-cpf/3rdloop 0.0.1

package/vendor/Server/Skills/rnoh-lib-rnt-search/scripts/analyze-demo-deps.cjs

@@ -0,0 +1,267 @@
+#!/usr/bin/env node
+/**
+ * Analyze demo source files: extract file list, external dependencies,
+ * target library references, and entry file info.
+ *
+ * Usage: node analyze-demo-deps.cjs <demoPath> [--lib-name <packageName>] [--alias <harmony.alias>]
+ *
+ * Output: JSON with:
+ *   - files: relative file paths (.ts/.tsx/.js/.jsx)
+ *   - externalDeps: non-relative, non-builtin package names
+ *   - libReferences: how demo imports the target library
+ *   - entryFiles: App.tsx / index.tsx paths + displayName
+ *   - nativeFiles: .ets/.cpp/.h files (not migrated, flagged for shell adaptation)
+ *   - hardcodedTitles: hardcoded library-specific titles found in shared components (e.g., Navigation.tsx)
+ *
+ * Exit codes: 0 = success, 1 = error
+ */
+const fs = require('fs');
+const path = require('path');
+
+const args = process.argv.slice(2);
+const demoPath = args[0];
+if (!demoPath) {
+  console.error('Usage: node analyze-demo-deps.cjs <demoPath> [--lib-name <packageName>] [--alias <harmony.alias>]');
+  process.exit(1);
+}
+
+let libName = '';
+let alias = '';
+for (let i = 1; i < args.length; i++) {
+  if (args[i] === '--lib-name' && args[i + 1]) { libName = args[++i]; }
+  else if (args[i] === '--alias' && args[i + 1]) { alias = args[++i]; }
+}
+
+if (!fs.existsSync(demoPath) || !fs.statSync(demoPath).isDirectory()) {
+  console.error(`Demo path not found or not a directory: ${demoPath}`);
+  process.exit(1);
+}
+
+const JS_EXTENSIONS = new Set(['.ts', '.tsx', '.js', '.jsx']);
+const NATIVE_EXTENSIONS = new Set(['.ets', '.cpp', '.h', '.c', '.cc']);
+const EXCLUDE_DIRS = new Set([
+  'node_modules', 'build', '__tests__', '.cxx', 'oh_modules',
+  '.git', '.hg', 'dist', 'coverage', '.cache',
+]);
+
+// Node.js builtin modules (subset; covers common ones)
+const BUILTIN_MODULES = new Set([
+  'fs', 'path', 'util', 'os', 'url', 'http', 'https', 'crypto', 'stream',
+  'buffer', 'events', 'child_process', 'net', 'tls', 'dns', 'zlib',
+  'querystring', 'assert', 'process', 'timers', 'worker_threads',
+  'assert/strict', 'util/types', 'path/posix', 'path/win32',
+]);
+
+const REACT_CORE = new Set(['react', 'react-native', 'react/jsx-runtime', 'react-native/Libraries/*']);
+
+function walk(dir, files, nativeFiles, base = dir) {
+  const entries = fs.readdirSync(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (entry.isDirectory()) {
+      if (EXCLUDE_DIRS.has(entry.name)) continue;
+      walk(path.join(dir, entry.name), files, nativeFiles, base);
+    } else if (entry.isFile()) {
+      const ext = path.extname(entry.name).toLowerCase();
+      const full = path.join(dir, entry.name);
+      const rel = path.relative(base, full);
+      if (JS_EXTENSIONS.has(ext)) {
+        files.push(rel);
+      } else if (NATIVE_EXTENSIONS.has(ext)) {
+        nativeFiles.push(rel);
+      }
+    }
+  }
+}
+
+/**
+ * Extract import/require module specifiers from source code.
+ * Supports:
+ *   - ES: import X from 'mod'; import { X } from 'mod'; import * as X from 'mod';
+ *         import 'mod'; export * from 'mod'; export { X } from 'mod';
+ *   - CommonJS: require('mod'); require.resolve('mod');
+ * Returns array of { kind, module, names? }
+ */
+function extractImports(source) {
+  const refs = [];
+  // ES import / export ... from 'mod'
+  const esFromRegex = /(?:import|export)\s+(?:([^'";]+?)\s+from\s+)?['"]([^'"]+)['"]/g;
+  let m;
+  while ((m = esFromRegex.exec(source)) !== null) {
+    const clause = m[1] || '';
+    const mod = m[2];
+    if (!mod) continue;
+    const names = parseImportClause(clause);
+    refs.push({ kind: names.default || names.named.length > 0 ? names.kind : 'side-effect', module: mod, names });
+  }
+  // Side-effect import: import 'mod';
+  const sideEffectRegex = /import\s+['"]([^'"]+)['"]/g;
+  while ((m = sideEffectRegex.exec(source)) !== null) {
+    refs.push({ kind: 'side-effect', module: m[1], names: { default: null, named: [], kind: 'side-effect' } });
+  }
+  // CommonJS require('mod')
+  const requireRegex = /require\(\s*['"]([^'"]+)['"]\s*\)/g;
+  while ((m = requireRegex.exec(source)) !== null) {
+    refs.push({ kind: 'cjs', module: m[1], names: { default: null, named: [], kind: 'cjs' } });
+  }
+  return refs;
+}
+
+function parseImportClause(clause) {
+  const result = { default: null, named: [], namespace: null, kind: 'named' };
+  if (!clause) return result;
+  const trimmed = clause.trim();
+
+  // namespace: * as X
+  const nsMatch = trimmed.match(/\*\s+as\s+(\w+)/);
+  if (nsMatch) {
+    result.namespace = nsMatch[1];
+    result.kind = 'namespace';
+  }
+
+  // Extract named imports from { X, Y as Z, ... } (handles multi-line and spaces)
+  const namedMatch = trimmed.match(/\{([^}]*)\}/);
+  if (namedMatch) {
+    const inner = namedMatch[1];
+    if (inner.trim()) {
+      for (const item of inner.split(',')) {
+        const itemName = item.trim().split(/\s+as\s+/)[0].trim();
+        if (itemName) result.named.push(itemName);
+      }
+    }
+  }
+
+  // Extract default import: everything outside braces and namespace alias
+  let defaultPart = trimmed
+    .replace(/\{[^}]*\}/, '')   // remove { ... }
+    .replace(/\*\s+as\s+\w+/, '') // remove * as X
+    .replace(/^[\s,]+|[\s,]+$/g, ''); // trim leading/trailing commas and whitespace
+  if (defaultPart && defaultPart !== '*') {
+    result.default = defaultPart.split(/\s+as\s+/)[0].trim();
+    if (result.kind === 'namespace' || result.named.length > 0) {
+      result.kind = 'mixed';
+    } else {
+      result.kind = 'default';
+    }
+  }
+
+  return result;
+}
+
+function isRelative(mod) {
+  return mod.startsWith('./') || mod.startsWith('../') || mod === '.' || mod === '..';
+}
+
+function isBuiltin(mod) {
+  const base = mod.split('/')[0];
+  return BUILTIN_MODULES.has(base) || BUILTIN_MODULES.has(mod);
+}
+
+function isReactCore(mod) {
+  const base = mod.split('/')[0];
+  return REACT_CORE.has(base) || REACT_CORE.has(mod);
+}
+
+function isTargetLib(mod) {
+  if (!libName && !alias) return false;
+  const base = mod.split('/')[0];
+  if (alias && (mod === alias || base === alias)) return true;
+  if (libName && (mod === libName || base === libName)) return true;
+  // also handle scoped: @scope/pkg
+  if (libName && mod.startsWith(libName + '/')) return true;
+  if (alias && mod.startsWith(alias + '/')) return true;
+  return false;
+}
+
+function classifyDep(mod) {
+  if (isRelative(mod)) return 'relative';
+  if (isBuiltin(mod)) return 'builtin';
+  if (isReactCore(mod)) return 'react-core';
+  if (isTargetLib(mod)) return 'target-lib';
+  const base = mod.split('/')[0];
+  if (base.startsWith('@react-native-oh') || base.startsWith('@rnoh') || mod.includes('react-native-harmony')) {
+    return 'rnoh';
+  }
+  if (base.startsWith('react-native') || base.startsWith('@react-native') || base.startsWith('@react-native-community')) {
+    return 'rn-general';
+  }
+  return 'third-party';
+}
+
+// Main
+const files = [];
+const nativeFiles = [];
+walk(demoPath, files, nativeFiles);
+
+const externalDeps = new Set();
+const libReferences = [];
+const entryFiles = { app: null, index: null, displayName: null, title: null };
+const hardcodedTitles = [];
+const navigationFiles = [];
+
+// Match hardcoded tester titles like "RN Svg Capi Tester", "RN Camera Tester"
+const TITLE_REGEX = /RN\s+\w+(?:\s+\w+)*\s+(?:Capi\s+)?Tester/i;
+
+for (const rel of files) {
+  const full = path.join(demoPath, rel);
+  const source = fs.readFileSync(full, 'utf8');
+  const refs = extractImports(source);
+
+  for (const ref of refs) {
+    const cat = classifyDep(ref.module);
+    if (cat === 'relative' || cat === 'builtin' || cat === 'react-core') continue;
+    if (cat === 'target-lib') {
+      libReferences.push({
+        file: rel,
+        kind: ref.kind,
+        module: ref.module,
+        names: ref.names.named,
+        default: ref.names.default,
+        namespace: ref.names.namespace,
+      });
+      continue;
+    }
+    // For external deps, strip subpath (keep scope/pkg)
+    const base = ref.module.startsWith('@')
+      ? ref.module.split('/').slice(0, 2).join('/')
+      : ref.module.split('/')[0];
+    externalDeps.add(base);
+  }
+
+  // Detect entry files
+  const baseName = path.basename(rel);
+  if (baseName === 'App.tsx' || baseName === 'App.ts' || baseName === 'App.jsx' || baseName === 'App.js') {
+    if (!entryFiles.app) entryFiles.app = rel;
+    // Extract displayName: matches both App.displayName = 'xxx' and export const displayName = 'xxx'
+    const dnMatch = source.match(/\bdisplayName\s*=\s*['"]([^'"]+)['"]/);
+    if (dnMatch) entryFiles.displayName = dnMatch[1];
+    const titleMatch = source.match(/\btitle\s*[:=]\s*['"]([^'"]+)['"]/);
+    if (titleMatch && !entryFiles.title) entryFiles.title = titleMatch[1];
+  }
+  if ((baseName === 'index.tsx' || baseName === 'index.ts' || baseName === 'index.jsx' || baseName === 'index.js') && !entryFiles.index) {
+    entryFiles.index = rel;
+  }
+
+  // Detect Navigation files and hardcoded tester titles
+  if (baseName === 'Navigation.tsx' || baseName === 'Navigation.ts') {
+    navigationFiles.push(rel);
+  }
+  const titleMatch = source.match(TITLE_REGEX);
+  if (titleMatch) {
+    hardcodedTitles.push({ file: rel, text: titleMatch[0], line: source.substring(0, titleMatch.index).split('\n').length });
+  }
+}
+
+const result = {
+  demoPath: path.resolve(demoPath),
+  files,
+  fileCount: files.length,
+  nativeFiles,
+  nativeFileCount: nativeFiles.length,
+  externalDeps: [...externalDeps].sort(),
+  libReferences,
+  entryFiles,
+  navigationFiles,
+  hardcodedTitles,
+};
+
+console.log(JSON.stringify(result, null, 2));

package/vendor/Server/Skills/rnoh-lib-rnt-search/scripts/detect-rnoh-version.cjs

@@ -0,0 +1,174 @@
+#!/usr/bin/env node
+/**
+ * Detect RNOH framework version from a given path.
+ *
+ * Priority:
+ *   1. Git branch name (e.g., br_rnoh0.82 -> 0.82)
+ *   2. example/package.json react-native-harmony version
+ *   3. harmony subdirs oh-package.json5 (RNOH deps)
+ *   4. package.json peerDependencies react-native version
+ *
+ * Usage: node detect-rnoh-version.cjs <path> [--list-branches]
+ *
+ * Output (without --list-branches):
+ *   JSON { path, version, source, branch?, raw }
+ *
+ * Output (with --list-branches):
+ *   JSON { path, branches: [{ branch, version }] }
+ *
+ * Exit codes: 0 = version detected, 1 = cannot determine or error
+ */
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+
+const args = process.argv.slice(2);
+const targetPath = args.find((a) => !a.startsWith('--'));
+const listBranches = args.includes('--list-branches');
+
+if (!targetPath) {
+  console.error('Usage: node detect-rnoh-version.cjs <path> [--list-branches]');
+  process.exit(1);
+}
+
+if (!fs.existsSync(targetPath)) {
+  console.error(`Path not found: ${targetPath}`);
+  process.exit(1);
+}
+
+const resolved = path.resolve(targetPath);
+
+function parseVersionFromBranch(branch) {
+  if (!branch || branch === 'HEAD') return null;
+  const match =
+    branch.match(/rnoh?[\-_]?0?(\d+\.\d+)/i) ||
+    branch.match(/0?(\d+\.\d+)/);
+  return match ? match[1] : null;
+}
+
+function detectFromGitBranch(dir) {
+  try {
+    const branch = execSync(`git -C "${dir}" rev-parse --abbrev-ref HEAD 2>/dev/null`, {
+      encoding: 'utf8',
+      stdio: 'pipe',
+    }).trim();
+    const version = parseVersionFromBranch(branch);
+    return { version, source: 'git-branch', branch: branch || null, raw: branch || '' };
+  } catch {
+    return null;
+  }
+}
+
+function listGitBranches(dir) {
+  try {
+    const out = execSync(`git -C "${dir}" branch -a 2>/dev/null`, {
+      encoding: 'utf8',
+      stdio: 'pipe',
+    }).trim();
+    return out
+      .split('\n')
+      .map((b) => b.replace(/^\*\s*/, '').trim())
+      .filter(Boolean)
+      .filter((b) => !b.includes('->'))
+      .map((b) => b.replace(/^remotes\/origin\//, ''));
+  } catch {
+    return [];
+  }
+}
+
+function detectFromExamplePackageJson(dir) {
+  const pkgPath = path.join(dir, 'example', 'package.json');
+  if (!fs.existsSync(pkgPath)) return null;
+  try {
+    const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+    const deps = { ...(pkg.dependencies || {}), ...(pkg.devDependencies || {}) };
+    const rnh = deps['react-native-harmony'];
+    if (rnh) {
+      const m = rnh.match(/(\d+\.\d+)\.\d+/);
+      if (m) return { version: m[1], source: 'example/package.json (react-native-harmony)', raw: rnh };
+    }
+    const rn = deps['react-native'];
+    if (rn) {
+      const m = rn.match(/^(\d+\.\d+)/);
+      if (m) return { version: m[1], source: 'example/package.json (react-native)', raw: rn };
+    }
+  } catch {}
+  return null;
+}
+
+function detectFromOhPackage(dir) {
+  const harmonyDir = path.join(dir, 'harmony');
+  if (!fs.existsSync(harmonyDir)) return null;
+  try {
+    for (const sub of fs.readdirSync(harmonyDir, { withFileTypes: true })) {
+      if (!sub.isDirectory() || sub.name === 'react_native_openharmony') continue;
+      const ohPkgPath = path.join(harmonyDir, sub.name, 'oh-package.json5');
+      if (!fs.existsSync(ohPkgPath)) continue;
+      const content = fs.readFileSync(ohPkgPath, 'utf8');
+      const clean = content
+        .replace(/\/\/.*$/gm, '')
+        .replace(/\/\*[\s\S]*?\*\//g, '')
+        .replace(/,\s*([}\]])/g, '$1');
+      const pkg = JSON.parse(clean);
+      const deps = { ...(pkg.dependencies || {}), ...(pkg.devDependencies || {}) };
+      for (const [name, ver] of Object.entries(deps)) {
+        if (name.includes('react-native-harmony') || name.includes('react-native-openharmony')) {
+          const m = String(ver).match(/(\d+\.\d+)\.\d+/);
+          if (m) return { version: m[1], source: `harmony/${sub.name}/oh-package.json5`, raw: `${name}@${ver}` };
+        }
+      }
+    }
+  } catch {}
+  return null;
+}
+
+function detectFromRootPackageJson(dir) {
+  const pkgPath = path.join(dir, 'package.json');
+  if (!fs.existsSync(pkgPath)) return null;
+  try {
+    const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+    const peer = pkg.peerDependencies || {};
+    const rn = peer['react-native'];
+    if (rn) {
+      const m = rn.match(/(\d+\.\d+)/);
+      if (m) return { version: m[1], source: 'package.json (peerDependencies react-native)', raw: rn };
+    }
+  } catch {}
+  return null;
+}
+
+if (listBranches) {
+  const branches = listGitBranches(resolved);
+  const branchInfo = branches.map((b) => ({
+    branch: b,
+    version: parseVersionFromBranch(b),
+  }));
+  console.log(JSON.stringify({ path: resolved, branches: branchInfo }, null, 2));
+  process.exit(0);
+}
+
+const detected =
+  detectFromGitBranch(resolved) ||
+  detectFromExamplePackageJson(resolved) ||
+  detectFromOhPackage(resolved) ||
+  detectFromRootPackageJson(resolved);
+
+if (!detected || !detected.version) {
+  console.log(
+    JSON.stringify(
+      {
+        path: resolved,
+        version: null,
+        source: detected ? detected.source : null,
+        branch: detected ? detected.branch : null,
+        message:
+          'Cannot determine RNOH version from git branch, package.json, or oh-package.json5',
+      },
+      null,
+      2,
+    ),
+  );
+  process.exit(1);
+}
+
+console.log(JSON.stringify({ path: resolved, ...detected }, null, 2));

package/vendor/Server/Skills/rnoh-lib-rnt-search/scripts/find-rnt-demo.sh

@@ -0,0 +1,111 @@
+#!/usr/bin/env bash
+# @tool find-rnt-demo
+# @description 在 rnt 工程中扫描定位目标 RN 三方库的 demo 目录。基于 read-lib-meta.cjs 生成的候选名，
+#              遍历 {rnt-root}/*/rn-tester/examples/ 匹配 demo，支持大小写不敏感兜底。
+# @param lib-path: string - 目标 RN 三方库根目录（含 package.json）
+# @param rnt-path: string - rnt 工程根目录
+# @param demo-path: string - 用户已明确的 demo 目录（提供时跳过扫描）
+
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+LIB_PATH=""
+RNT_PATH=""
+DEMO_PATH=""
+
+usage() {
+  cat <<'EOF'
+Usage: find-rnt-demo.sh --lib-path <lib-root> --rnt-path <rnt-root> [--demo-path <explicit-demo-dir>]
+
+Find the rnt tester demo directory for a target library.
+
+Output: one demo path per line (absolute).
+Exit codes:
+  0 = exactly one match found
+  1 = no match found
+  2 = multiple matches found (auto-select first; user can override via --demo-path)
+EOF
+}
+
+log() { printf '[find-rnt-demo] %s\n' "$*" >&2; }
+
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    --lib-path) LIB_PATH="${2:-}"; shift 2 ;;
+    --rnt-path) RNT_PATH="${2:-}"; shift 2 ;;
+    --demo-path) DEMO_PATH="${2:-}"; shift 2 ;;
+    --help|-h) usage; exit 0 ;;
+    *) echo "Unknown argument: $1" >&2; exit 1 ;;
+  esac
+done
+
+[[ -n "$LIB_PATH" ]] || { echo "--lib-path is required" >&2; exit 1; }
+[[ -d "$LIB_PATH" ]] || { echo "Library path not found: $LIB_PATH" >&2; exit 1; }
+
+# If user provided explicit demo path, validate and return it.
+if [[ -n "$DEMO_PATH" ]]; then
+  [[ -d "$DEMO_PATH" ]] || { echo "Demo path not found: $DEMO_PATH" >&2; exit 1; }
+  cd "$DEMO_PATH" && pwd
+  exit 0
+fi
+
+[[ -n "$RNT_PATH" ]] || { echo "--rnt-path is required when --demo-path is omitted" >&2; exit 1; }
+[[ -d "$RNT_PATH" ]] || { echo "RNT path not found: $RNT_PATH" >&2; exit 1; }
+
+LIB_PATH="$(cd "$LIB_PATH" && pwd)"
+RNT_PATH="$(cd "$RNT_PATH" && pwd)"
+
+# Read library metadata to get candidate search names.
+META_JSON="$(node "$SCRIPT_DIR/read-lib-meta.cjs" "$LIB_PATH")"
+SEARCH_NAMES=()
+while IFS= read -r line; do
+  [[ -n "$line" ]] && SEARCH_NAMES+=("$line")
+done < <(printf '%s' "$META_JSON" | python3 -c 'import json,sys; d=json.load(sys.stdin); print("\n".join(d["searchNames"]))')
+
+log "Search names: ${SEARCH_NAMES[*]}"
+
+matches=()
+for sub in "$RNT_PATH"/*; do
+  [[ -d "$sub" ]] || continue
+  examples_root="$sub/rn-tester/examples"
+  [[ -d "$examples_root" ]] || continue
+
+  # Direct match: {examples-root}/{candidate-name}/
+  for name in "${SEARCH_NAMES[@]}"; do
+    candidate="$examples_root/$name"
+    if [[ -d "$candidate" ]]; then
+      matches+=("$(cd "$candidate" && pwd)")
+    fi
+  done
+
+  # Case-insensitive fallback: compare directory names with scoped package tail.
+  while IFS= read -r demo_dir; do
+    demo_name="$(basename "$demo_dir")"
+    for name in "${SEARCH_NAMES[@]}"; do
+      if [[ "$(printf '%s' "$demo_name" | tr '[:upper:]' '[:lower:]')" == "$(printf '%s' "$name" | tr '[:upper:]' '[:lower:]')" ]]; then
+        matches+=("$(cd "$demo_dir" && pwd)")
+      fi
+    done
+  done < <(find "$examples_root" -mindepth 1 -maxdepth 1 -type d 2>/dev/null)
+done
+
+# Deduplicate
+deduped="$(printf '%s\n' "${matches[@]}" | awk '!seen[$0]++')"
+match_count="$(printf '%s\n' "$deduped" | grep -c . || true)"
+
+if [[ "$match_count" -eq 0 ]]; then
+  log "No demo found under $RNT_PATH/*/rn-tester/examples/"
+  log "Searched candidates: ${SEARCH_NAMES[*]}"
+  log "Hint: manually browse $RNT_PATH/*/rn-tester/examples/ for similar names, or provide --demo-path explicitly."
+  exit 1
+fi
+
+if [[ "$match_count" -eq 1 ]]; then
+  printf '%s\n' "$deduped"
+  exit 0
+fi
+
+# Multiple matches: print all and exit 2
+printf '%s\n' "$deduped"
+log "Multiple demo directories found; auto-selected first match."
+exit 2