@ohos-cpf/3rdloop 0.0.1

package/vendor/Server/Skills/rn-lib-update-doc/scripts/detect-readme-format.cjs

@@ -0,0 +1,105 @@
+#!/usr/bin/env node
+/**
+ * Detect README documentation template format.
+ * Usage: node detect-readme-format.js <lib-root> [--expect 0.4.2] [--file README.md]
+ */
+const fs = require('fs');
+const path = require('path');
+
+const args = process.argv.slice(2);
+const libRoot = args.find((a) => !a.startsWith('--'));
+const expectIdx = args.indexOf('--expect');
+const expect = expectIdx >= 0 ? String(args[expectIdx + 1]).replace(/^v/, '') : '0.4.2';
+const fileIdx = args.indexOf('--file');
+const fileName = fileIdx >= 0 ? args[fileIdx + 1] : 'README.md';
+
+if (!libRoot) {
+  console.error('Usage: node detect-readme-format.js <lib-root> [--expect 0.4.2] [--file README.md]');
+  process.exit(1);
+}
+
+const readmePath = path.join(libRoot, fileName);
+if (!fs.existsSync(readmePath)) {
+  console.log(JSON.stringify({
+    path: readmePath,
+    exists: false,
+    kind: 'missing',
+    matchesExpect: false,
+    expect,
+    needsUsageDocsMigration: true,
+    isV041: false,
+    isExternalLink: false,
+  }, null, 2));
+  process.exit(0);
+}
+
+const text = fs.readFileSync(readmePath, 'utf8');
+const head = text.slice(0, 2500);
+const firstLine = (text.split(/\r?\n/).find((l) => l.trim()) || '').trim();
+
+const versionMatch =
+  firstLine.match(/文档模板\s*[：:]\s*v?(\d+\.\d+\.\d+)/i) ||
+  firstLine.match(/模板版本\s*[：:]\s*v?(\d+\.\d+\.\d+)/i) ||
+  firstLine.match(/Template version\s*[：:]\s*v?(\d+\.\d+\.\d+)/i) ||
+  firstLine.match(/Document template\s*[：:]\s*v?(\d+\.\d+\.\d+)/i);
+
+const declaredVersion = versionMatch ? versionMatch[1] : null;
+
+const hasNpmAddressCol = /\|[^|\n]*npm地址[^|\n]*\|/i.test(head) || /\|\s*npm Address\s*\|/i.test(head);
+const hasVersionNpmCol = /三方库版本（npm地址）/.test(head) || /Version\s*\(npm/i.test(head);
+const hasSourceCol = /源码地址/.test(head) || /\|\s*Source\s*\|/i.test(head) || /源码地址/.test(head);
+const hasDocUrlSection = /##\s*Documentation URL/i.test(text) || /Documentation URL/.test(head);
+const linkHeavy =
+  hasDocUrlSection &&
+  !/##\s*简介/.test(text) &&
+  !/##\s*下载安装/.test(text) &&
+  !/##\s*1\.\s*安装/.test(text) &&
+  (text.match(/https?:\/\//g) || []).length <= 8 &&
+  text.length < 1500;
+
+const hasIntro = /##\s*简介/.test(text) || /##\s*Introduction/i.test(text);
+const hasInstall = /##\s*下载安装/.test(text) || /##\s*Installation/i.test(text);
+const hasUsageGuide = /##\s*使用说明/.test(text) || /##\s*Usage Guide/i.test(text);
+const numberedInstall = /##\s*1\.\s*(安装|Installation)/i.test(text);
+
+let kind = 'unknown';
+if (linkHeavy || (hasDocUrlSection && !hasIntro && !numberedInstall)) {
+  kind = 'external_link';
+} else if (declaredVersion === '0.4.2' || (hasVersionNpmCol && hasSourceCol && hasUsageGuide)) {
+  kind = 'v0.4.2';
+} else if (declaredVersion === '0.4.1' || (hasIntro && hasInstall && hasNpmAddressCol && !hasVersionNpmCol)) {
+  kind = 'v0.4.1';
+} else if (declaredVersion === '0.4.0' || numberedInstall) {
+  kind = 'v0.4.0';
+} else if (declaredVersion) {
+  kind = `v${declaredVersion}`;
+}
+
+const matchesExpect = kind === `v${expect}`;
+const isV041 = kind === 'v0.4.1';
+const isExternalLink = kind === 'external_link';
+const needsUsageDocsMigration = !matchesExpect && !isV041;
+
+const result = {
+  path: readmePath,
+  exists: true,
+  kind,
+  declaredVersion,
+  matchesExpect,
+  expect,
+  isV041,
+  isExternalLink,
+  needsUsageDocsMigration,
+  signals: {
+    hasVersionNpmCol,
+    hasNpmAddressCol,
+    hasSourceCol,
+    hasIntro,
+    hasInstall,
+    hasUsageGuide,
+    numberedInstall,
+    hasDocUrlSection,
+  },
+};
+
+console.log(JSON.stringify(result, null, 2));

package/vendor/Server/Skills/rn-lib-update-doc/scripts/find-usage-doc.cjs

@@ -0,0 +1,90 @@
+#!/usr/bin/env node
+/**
+ * Locate zh/en docs for a library inside usage-docs (local or remote URLs).
+ * Usage: node find-usage-doc.js --lib-path <lib-root> [--usage-docs <path>]
+ */
+const fs = require('fs');
+const path = require('path');
+
+function parseArgs(argv) {
+  const out = {};
+  for (let i = 0; i < argv.length; i++) {
+    if (argv[i] === '--lib-path') out.libPath = argv[++i];
+    else if (argv[i] === '--usage-docs') out.usageDocs = argv[++i];
+  }
+  return out;
+}
+
+function readConfig() {
+  const cfgPath = path.resolve(__dirname, '..', 'config.json');
+  if (!fs.existsSync(cfgPath)) return {};
+  return JSON.parse(fs.readFileSync(cfgPath, 'utf8'));
+}
+
+function candidateNames(libRoot) {
+  const names = [];
+  const pkgPath = path.join(libRoot, 'package.json');
+  if (fs.existsSync(pkgPath)) {
+    const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+    if (pkg.harmony && pkg.harmony.alias) names.push(pkg.harmony.alias);
+    if (pkg.name) {
+      names.push(pkg.name.includes('/') ? pkg.name.split('/').pop() : pkg.name);
+    }
+  }
+  const base = path.basename(libRoot);
+  names.push(base);
+  if (base.startsWith('rntpc_')) names.push(base.slice('rntpc_'.length));
+  return [...new Set(names.filter(Boolean))];
+}
+
+const args = parseArgs(process.argv.slice(2));
+if (!args.libPath) {
+  console.error('Usage: node find-usage-doc.js --lib-path <lib-root> [--usage-docs <path>]');
+  process.exit(1);
+}
+
+const cfg = readConfig();
+const usageDocs =
+  args.usageDocs ||
+  (cfg.usageDocsPath && fs.existsSync(cfg.usageDocsPath) ? cfg.usageDocsPath : null);
+const remote = cfg.remoteUsageDocs || 'https://gitcode.com/CPF-RN/usage-docs';
+const branch = cfg.remoteDefaultBranch || 'master';
+const candidates = candidateNames(path.resolve(args.libPath));
+
+const hits = [];
+if (usageDocs) {
+  for (const name of candidates) {
+    const zh = path.join(usageDocs, 'zh-cn', `${name}.md`);
+    const en = path.join(usageDocs, 'en', `${name}.md`);
+    if (fs.existsSync(zh) || fs.existsSync(en)) {
+      hits.push({
+        name,
+        zh: fs.existsSync(zh) ? zh : null,
+        en: fs.existsSync(en) ? en : null,
+      });
+    }
+  }
+}
+
+const remoteUrls = candidates.map((name) => ({
+  name,
+  zh: `${remote.replace(/\/$/, '')}/raw/${branch}/zh-cn/${name}.md`,
+  en: `${remote.replace(/\/$/, '')}/raw/${branch}/en/${name}.md`,
+}));
+
+const result = {
+  libPath: path.resolve(args.libPath),
+  usageDocsPath: usageDocs,
+  hasLocal: Boolean(usageDocs),
+  candidates,
+  localHits: hits,
+  preferredLocal: hits[0] || null,
+  remoteUrls,
+  preferredRemote: remoteUrls[0] || null,
+};
+
+console.log(JSON.stringify(result, null, 2));
+if (usageDocs && hits.length === 0) {
+  console.error('[find-usage-doc] No local doc matched candidates; try remoteUrls or check alias.');
+  process.exitCode = 2;
+}

package/vendor/Server/Skills/rn-lib-update-doc/scripts/link-verify.cjs

@@ -0,0 +1,213 @@
+/**
+ * HTTP link verification for rn-lib-update-doc.
+ * Replaces must be validated — do not assume org rename alone makes URLs work.
+ */
+const { execSync } = require('child_process');
+
+const DEFAULT_TIMEOUT_SEC = 15;
+const STRICT_HOSTS = [/gitcode\.com/i];
+const SOFT_PASS_HOSTS = [/npmjs\.com/i, /registry\.npmjs\.org/i];
+
+function isStrictUrl(url) {
+  return STRICT_HOSTS.some((re) => re.test(url));
+}
+
+function isSoftPassHost(url) {
+  return SOFT_PASS_HOSTS.some((re) => re.test(url));
+}
+
+function verifyUrlSync(url, options = {}) {
+  if (!url || !/^https?:\/\//i.test(url)) {
+    return { url, ok: false, status: 0, error: 'invalid-url', strict: false };
+  }
+  if (options.skipVerify) {
+    return { url, ok: true, status: null, skipped: true, strict: isStrictUrl(url) };
+  }
+
+  const timeout = options.timeoutSec || DEFAULT_TIMEOUT_SEC;
+  const escaped = url.replace(/'/g, "'\\''");
+  const ua = 'Mozilla/5.0 (compatible; rn-lib-update-doc/1.0)';
+
+  try {
+    const code = execSync(
+      `curl -s -o /dev/null -w '%{http_code}' -L --max-time ${timeout} -A '${ua}' '${escaped}'`,
+      { encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] },
+    ).trim();
+    const status = parseInt(code, 10);
+    let ok = !Number.isNaN(status) && status >= 200 && status < 400;
+    const strict = isStrictUrl(url);
+
+    if (!ok && isSoftPassHost(url) && (status === 403 || status === 401)) {
+      return {
+        url,
+        ok: true,
+        status,
+        softPass: true,
+        strict: false,
+        note: 'external-registry-bot-blocked',
+      };
+    }
+
+    return {
+      url,
+      ok,
+      status,
+      strict,
+      error: ok ? undefined : `http-${status}`,
+    };
+  } catch (err) {
+    return { url, ok: false, status: 0, strict: isStrictUrl(url), error: String(err.message || err) };
+  }
+}
+
+/** Extract http(s) URLs from markdown / plain text. */
+function extractHttpUrls(text) {
+  if (!text) return [];
+  const re = /https?:\/\/[^\s)<>"']+/g;
+  const found = text.match(re) || [];
+  return [...new Set(found.map((u) => u.replace(/[.,;:!?)]+$/, '')))];
+}
+
+function normalizeRepoWebUrl(url) {
+  if (!url) return null;
+  return url
+    .replace(/^git\+/, '')
+    .replace(/^git@gitcode\.com:/, 'https://gitcode.com/')
+    .replace(/\.git$/, '')
+    .replace(/\/$/, '');
+}
+
+function verifyUrls(urls, options = {}) {
+  const results = [];
+  const seen = new Set();
+  for (const url of urls) {
+    if (!url || seen.has(url)) continue;
+    seen.add(url);
+    results.push(verifyUrlSync(url, options));
+  }
+  return results;
+}
+
+function summarizeVerification(results) {
+  const failed = results.filter((r) => !r.ok && !r.skipped);
+  const strictFailed = failed.filter((r) => r.strict !== false);
+  const softPassed = results.filter((r) => r.softPass);
+  return {
+    total: results.length,
+    passed: results.filter((r) => r.ok).length,
+    failed: failed.length,
+    strictFailed: strictFailed.length,
+    softPassed: softPassed.length,
+    failures: failed,
+    strictFailures: strictFailed,
+    ok: strictFailed.length === 0,
+  };
+}
+
+/**
+ * Try multiple repo base candidates; return first that responds HTTP 2xx/3xx.
+ */
+function resolveVerifiedLibRepoBase(libRoot, registry, options = {}) {
+  const { execSync: exec } = require('child_process');
+  const readJson = (p) => {
+    try {
+      return JSON.parse(require('fs').readFileSync(p, 'utf8'));
+    } catch {
+      return null;
+    }
+  };
+
+  const pkg = readJson(require('path').join(libRoot, 'package.json'));
+  const candidates = [];
+
+  if (pkg?.repository?.url) {
+    const u = normalizeRepoWebUrl(
+      pkg.repository.url.replace(/openharmony-sig/gi, registry.defaultLibOrg),
+    );
+    if (u) candidates.push(u);
+  }
+
+  try {
+    const remote = exec('git remote get-url origin', {
+      cwd: libRoot,
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'ignore'],
+    }).trim();
+    const u = normalizeRepoWebUrl(
+      remote.replace(/openharmony-sig/gi, registry.defaultLibOrg),
+    );
+    if (u) candidates.push(u);
+  } catch {
+    /* no remote */
+  }
+
+  const base = require('path').basename(libRoot);
+  const aliasNames = new Set();
+  if (pkg?.harmony?.alias) {
+    const a = pkg.harmony.alias;
+    aliasNames.add(a.includes('/') ? a.split('/').pop() : a);
+  }
+  if (pkg?.name) aliasNames.add(pkg.name.includes('/') ? pkg.name.split('/').pop() : pkg.name);
+  aliasNames.add(base);
+  if (base.startsWith('rntpc_')) aliasNames.add(base.slice('rntpc_'.length));
+
+  for (const alias of aliasNames) {
+    const repoName = registry.libRepoNamePattern.replace('{alias}', alias);
+    candidates.push(`https://gitcode.com/${registry.defaultLibOrg}/${repoName}`);
+    if (base.startsWith('rntpc_')) {
+      candidates.push(`https://gitcode.com/${registry.defaultLibOrg}/${base}`);
+    }
+  }
+
+  const unique = [...new Set(candidates.filter(Boolean))];
+  const tried = [];
+
+  for (const candidate of unique) {
+    const check = verifyUrlSync(candidate, options);
+    tried.push({ candidate, ...check });
+    if (check.ok) {
+      return { libRepoBase: candidate, verified: true, tried };
+    }
+  }
+
+  return {
+    libRepoBase: unique[0] || `https://gitcode.com/${registry.defaultLibOrg}/${base}`,
+    verified: false,
+    tried,
+  };
+}
+
+/**
+ * Migrate openharmony-sig GitCode URL to CPF-RN only when target URL is reachable.
+ */
+function migrateGitcodeOrgUrlIfVerified(url, registry, options = {}) {
+  const deprecated = registry.deprecatedOrgPatterns.find((p) =>
+    new RegExp(p.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), 'i').test(url),
+  );
+  if (!deprecated) return { url, migrated: false, verified: verifyUrlSync(url, options) };
+
+  const target = url.replace(/openharmony-sig/gi, registry.defaultLibOrg);
+  const check = verifyUrlSync(target, options);
+  if (check.ok) {
+    return { url: target, migrated: true, from: url, verified: check };
+  }
+  return {
+    url,
+    migrated: false,
+    from: url,
+    attempted: target,
+    verified: check,
+    keepOriginal: true,
+    error: 'target-not-reachable',
+  };
+}
+
+module.exports = {
+  verifyUrlSync,
+  extractHttpUrls,
+  verifyUrls,
+  summarizeVerification,
+  resolveVerifiedLibRepoBase,
+  migrateGitcodeOrgUrlIfVerified,
+  normalizeRepoWebUrl,
+};

package/vendor/Server/Skills/rn-lib-update-doc/scripts/normalize-changelog.cjs

@@ -0,0 +1,73 @@
+#!/usr/bin/env node
+/**
+ * Check CHANGELOG.md against Keep a Changelog conventions.
+ *
+ * Usage:
+ *   node normalize-changelog.js --lib-path <lib-root>
+ */
+const fs = require('fs');
+const path = require('path');
+
+function parseArgs(argv) {
+  const out = {};
+  for (let i = 0; i < argv.length; i++) {
+    if (argv[i] === '--lib-path') out.libPath = argv[++i];
+  }
+  return out;
+}
+
+function main() {
+  const args = parseArgs(process.argv.slice(2));
+  if (!args.libPath) {
+    console.error('Usage: node normalize-changelog.js --lib-path <lib-root>');
+    process.exit(1);
+  }
+
+  const filePath = path.join(path.resolve(args.libPath), 'CHANGELOG.md');
+  const report = { file: 'CHANGELOG.md', exists: fs.existsSync(filePath), ok: true, issues: [] };
+
+  if (!report.exists) {
+    report.ok = false;
+    report.issues.push('CHANGELOG.md missing');
+    console.log(JSON.stringify(report, null, 2));
+    process.exitCode = 2;
+    return;
+  }
+
+  const content = fs.readFileSync(filePath, 'utf8');
+
+  if (!/Keep a Changelog/i.test(content)) {
+    report.issues.push('missing Keep a Changelog reference in header');
+    report.ok = false;
+  }
+  if (!/^## \[Unreleased\]/m.test(content)) {
+    report.issues.push('missing ## [Unreleased] section');
+    report.ok = false;
+  }
+  if (!/^## \[\d/m.test(content)) {
+    report.issues.push('missing version sections like ## [x.y.z]');
+    report.ok = false;
+  }
+
+  const versionBlocks = content.split(/^## \[/m).slice(1);
+  for (const block of versionBlocks) {
+    const header = block.split('\n')[0];
+    if (/^Unreleased\]/i.test(header)) continue;
+    const body = block.slice(header.length);
+    const hasCategory = /### (Added|Changed|Fixed|Deprecated|Removed|Security)/.test(body);
+    if (!hasCategory) {
+      report.issues.push(`version [${header.replace(/\].*$/, '')}] missing Added/Changed/Fixed/Deprecated categories`);
+      report.ok = false;
+    }
+  }
+
+  if (/^## 鸿蒙化Log|^### v\d|^## ReleaseLog/m.test(content)) {
+    report.issues.push('legacy headings detected (鸿蒙化Log / ReleaseLog / vX.Y.Z without brackets)');
+    report.ok = false;
+  }
+
+  console.log(JSON.stringify(report, null, 2));
+  if (!report.ok) process.exitCode = 2;
+}
+
+main();