@colin4k1024/tsp 2.4.0 → 2.4.2

package/scripts/gitnexus-preflight.js

@@ -0,0 +1,187 @@
+#!/usr/bin/env node
+'use strict'
+
+const { spawnSync } = require('child_process')
+
+const MIN_NODE_MAJOR = 20
+const PACKAGE_NAME = 'gitnexus'
+const NPM_METADATA_TIMEOUT_MS = 8000
+
+function run(command, args, options = {}) {
+  return spawnSync(command, args, {
+    encoding: 'utf8',
+    ...options,
+  })
+}
+
+function summarizeCommandFailure(result) {
+  if (result.error) {
+    return result.error.message
+  }
+
+  return `${result.stdout || ''}${result.stderr || ''}`
+    .split(/\r?\n/)
+    .map((line) => line.trim())
+    .filter(Boolean)
+    .slice(0, 4)
+    .join(' | ')
+}
+
+function parseNodeVersion(text) {
+  const match = String(text || '').trim().match(/^v?(\d+)\.(\d+)\.(\d+)/)
+  if (!match) {
+    return null
+  }
+
+  return {
+    major: Number(match[1]),
+    minor: Number(match[2]),
+    patch: Number(match[3]),
+    raw: `${match[1]}.${match[2]}.${match[3]}`,
+  }
+}
+
+function isNodeSupported(version) {
+  return Boolean(version && version.major >= MIN_NODE_MAJOR)
+}
+
+function detectCommand(command) {
+  const result = run(command, ['--version'])
+  if (result.error || result.status !== 0) {
+    return {
+      ok: false,
+      command,
+      output: result.error ? result.error.message : `${result.stdout || ''}${result.stderr || ''}`.trim(),
+    }
+  }
+
+  return {
+    ok: true,
+    command,
+    output: `${result.stdout || ''}${result.stderr || ''}`.trim(),
+  }
+}
+
+function parsePackageMetadata(rawJson) {
+  if (!rawJson) {
+    return null
+  }
+
+  const parsed = JSON.parse(rawJson)
+  return {
+    version: parsed.version || '(unknown)',
+    license: parsed.license || '(unknown)',
+    engines: parsed.engines || {},
+  }
+}
+
+function loadPackageMetadata() {
+  if (process.env.GITNEXUS_PREFLIGHT_NPM_VIEW_JSON) {
+    return {
+      ok: true,
+      source: 'env',
+      metadata: parsePackageMetadata(process.env.GITNEXUS_PREFLIGHT_NPM_VIEW_JSON),
+    }
+  }
+
+  const result = run('npm', ['view', PACKAGE_NAME, 'version', 'license', 'engines', '--json'], {
+    timeout: NPM_METADATA_TIMEOUT_MS,
+  })
+  if (result.error || result.status !== 0) {
+    return {
+      ok: false,
+      source: 'npm',
+      warning: summarizeCommandFailure(result),
+    }
+  }
+
+  try {
+    return {
+      ok: true,
+      source: 'npm',
+      metadata: parsePackageMetadata(result.stdout),
+    }
+  } catch (error) {
+    return {
+      ok: false,
+      source: 'npm',
+      warning: `Failed to parse npm metadata: ${error.message || error}`,
+    }
+  }
+}
+
+function main() {
+  console.log('GitNexus preflight check')
+  console.log('========================')
+
+  const nodeVersion = parseNodeVersion(process.env.GITNEXUS_PREFLIGHT_NODE_VERSION || process.version)
+  const npm = detectCommand('npm')
+  const npx = detectCommand('npx')
+  const packageInfo = loadPackageMetadata()
+  const warnings = []
+
+  let hasFailure = false
+
+  if (!nodeVersion) {
+    hasFailure = true
+    console.log(`- Node: unable to detect version (requires Node >= ${MIN_NODE_MAJOR})`)
+  } else if (!isNodeSupported(nodeVersion)) {
+    hasFailure = true
+    console.log(`- Node: ${nodeVersion.raw} (requires Node >= ${MIN_NODE_MAJOR})`)
+  } else {
+    console.log(`- Node: ${nodeVersion.raw} (ok)`)
+  }
+
+  if (!npm.ok) {
+    hasFailure = true
+    console.log('- npm: missing or unavailable')
+  } else {
+    console.log(`- npm: ${npm.output || 'available'} (ok)`)
+  }
+
+  if (!npx.ok) {
+    hasFailure = true
+    console.log('- npx: missing or unavailable')
+  } else {
+    console.log(`- npx: ${npx.output || 'available'} (ok)`)
+  }
+
+  if (packageInfo.ok && packageInfo.metadata) {
+    const engine = packageInfo.metadata.engines.node || '(not declared)'
+    console.log(`- GitNexus package: ${packageInfo.metadata.version} (license ${packageInfo.metadata.license}, node ${engine})`)
+  } else {
+    warnings.push(`Could not read npm metadata for ${PACKAGE_NAME}; continue only after checking the upstream license and engine manually.`)
+    if (packageInfo.warning) {
+      warnings.push(packageInfo.warning)
+    }
+    console.log('- GitNexus package: metadata unavailable (warning)')
+  }
+
+  if (warnings.length) {
+    console.log('\nWarnings:')
+    for (const warning of warnings) {
+      console.log(`- ${warning}`)
+    }
+  }
+
+  console.log('\nControlled integration boundaries:')
+  console.log('- GitNexus is optional and is not installed by TSP.')
+  console.log('- Review the upstream license before use; current npm metadata may report PolyForm-Noncommercial-1.0.0.')
+  console.log('- Do not run `gitnexus setup` automatically; it writes global editor/MCP configuration.')
+  console.log('- Do not run `gitnexus analyze` without `--skip-agents-md` in TSP-managed repositories.')
+
+  if (hasFailure) {
+    console.log('\nFix the failed checks before enabling GitNexus for a project.')
+    process.exit(1)
+  }
+
+  console.log('\nRecommended next commands:')
+  console.log('- npx --yes gitnexus@latest analyze --skip-agents-md')
+  console.log('- npx --yes gitnexus@latest status')
+  console.log('- npx --yes gitnexus@latest list')
+
+  console.log('\nManual MCP command:')
+  console.log('- npx --yes gitnexus@latest mcp')
+}
+
+main()

package/scripts/install-apply.js

@@ -192,6 +192,9 @@ function printHumanPlan(plan, dryRun, knownRisks = []) {
     }
   }
   console.log(`Operations: ${plan.operations.length}`);
+  if (Array.isArray(plan.externalInstalls) && plan.externalInstalls.length > 0) {
+    console.log(`External installs: ${plan.externalInstalls.length}`);
+  }
 
   if (plan.warnings.length > 0) {
     console.log('\nWarnings:');
@@ -210,6 +213,12 @@ function printHumanPlan(plan, dryRun, knownRisks = []) {
   for (const operation of plan.operations) {
     console.log(`- ${operation.sourceRelativePath} -> ${operation.destinationPath}`);
   }
+  if (Array.isArray(plan.externalInstalls) && plan.externalInstalls.length > 0) {
+    console.log('\nPlanned external installs:');
+    for (const externalInstall of plan.externalInstalls) {
+      console.log(`- ${externalInstall.id}: ${externalInstall.description || externalInstall.script}`);
+    }
+  }
 
   if (!dryRun) {
     console.log(`\nDone. Install-state written to ${plan.installStatePath}`);

package/scripts/install-open-design.js

@@ -0,0 +1,206 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+const DEFAULT_REPO_URL = 'https://github.com/nexu-io/open-design.git';
+const DEFAULT_INSTALL_DIR = path.join(os.homedir(), '.tsp', 'open-design');
+const DEFAULT_REF = 'main';
+
+function parseArgs(argv) {
+  const parsed = {
+    installDir: process.env.TSP_OPEN_DESIGN_HOME || process.env.OPEN_DESIGN_HOME || DEFAULT_INSTALL_DIR,
+    repoUrl: process.env.TSP_OPEN_DESIGN_REPO || DEFAULT_REPO_URL,
+    ref: process.env.TSP_OPEN_DESIGN_REF || DEFAULT_REF,
+    skipDeps: process.env.TSP_OPEN_DESIGN_SKIP_DEPS === '1',
+    dryRun: false,
+  };
+
+  for (let index = 2; index < argv.length; index += 1) {
+    const arg = argv[index];
+    if (arg === '--dir') {
+      parsed.installDir = argv[index + 1] || parsed.installDir;
+      index += 1;
+      continue;
+    }
+    if (arg === '--repo') {
+      parsed.repoUrl = argv[index + 1] || parsed.repoUrl;
+      index += 1;
+      continue;
+    }
+    if (arg === '--ref') {
+      parsed.ref = argv[index + 1] || parsed.ref;
+      index += 1;
+      continue;
+    }
+    if (arg === '--skip-deps') {
+      parsed.skipDeps = true;
+      continue;
+    }
+    if (arg === '--dry-run') {
+      parsed.dryRun = true;
+      continue;
+    }
+    if (arg === '--help' || arg === '-h') {
+      parsed.help = true;
+      continue;
+    }
+    throw new Error(`Unknown argument: ${arg}`);
+  }
+
+  parsed.installDir = path.resolve(parsed.installDir);
+  return parsed;
+}
+
+function printHelp() {
+  console.log(`
+Install or update Open Design for TSP.
+
+Usage:
+  node scripts/install-open-design.js [--dir <path>] [--repo <url>] [--ref <git-ref>] [--skip-deps] [--dry-run]
+
+Environment:
+  TSP_OPEN_DESIGN_HOME       Override install directory. Default: ~/.tsp/open-design
+  TSP_OPEN_DESIGN_REPO       Override upstream repository URL.
+  TSP_OPEN_DESIGN_REF        Override git ref. Default: main
+  TSP_OPEN_DESIGN_SKIP_DEPS  Set to 1 to skip pnpm dependency install.
+`);
+}
+
+function commandExists(command) {
+  const result = spawnSync(command, ['--version'], {
+    encoding: 'utf8',
+    stdio: ['ignore', 'ignore', 'ignore'],
+  });
+  return result.status === 0;
+}
+
+function run(command, args, options = {}) {
+  const printable = [command, ...args].join(' ');
+  if (options.dryRun) {
+    console.log(`[dry-run] ${printable}`);
+    return;
+  }
+
+  const result = spawnSync(command, args, {
+    cwd: options.cwd || process.cwd(),
+    encoding: 'utf8',
+    stdio: options.quiet ? ['ignore', 'pipe', 'pipe'] : 'inherit',
+  });
+
+  if (result.status !== 0) {
+    const stderr = result.stderr ? `\n${result.stderr.trim()}` : '';
+    throw new Error(`Command failed: ${printable}${stderr}`);
+  }
+}
+
+function readGitRemote(installDir) {
+  const result = spawnSync('git', ['-C', installDir, 'remote', 'get-url', 'origin'], {
+    encoding: 'utf8',
+    stdio: ['ignore', 'pipe', 'ignore'],
+  });
+  return result.status === 0 ? result.stdout.trim() : null;
+}
+
+function isOpenDesignRemote(remoteUrl, expectedRepoUrl) {
+  const normalized = String(remoteUrl || '').replace(/\.git$/, '');
+  const expected = String(expectedRepoUrl || '').replace(/\.git$/, '');
+  return normalized === expected || normalized.endsWith('/nexu-io/open-design');
+}
+
+function ensureOpenDesignCheckout(options) {
+  const gitDir = path.join(options.installDir, '.git');
+  if (!fs.existsSync(options.installDir)) {
+    console.log(`Installing Open Design into ${options.installDir}`);
+    if (!options.dryRun) {
+      fs.mkdirSync(path.dirname(options.installDir), { recursive: true });
+    }
+    run('git', [
+      'clone',
+      '--depth',
+      '1',
+      '--branch',
+      options.ref,
+      options.repoUrl,
+      options.installDir,
+    ], { dryRun: options.dryRun });
+    return;
+  }
+
+  if (!fs.existsSync(gitDir)) {
+    throw new Error(`Open Design install path exists but is not a git checkout: ${options.installDir}`);
+  }
+
+  const remoteUrl = readGitRemote(options.installDir);
+  if (!isOpenDesignRemote(remoteUrl, options.repoUrl)) {
+    throw new Error(
+      `Refusing to update ${options.installDir}; origin is ${remoteUrl || '(unknown)'}, expected ${options.repoUrl}`
+    );
+  }
+
+  console.log(`Updating Open Design at ${options.installDir}`);
+  run('git', ['-C', options.installDir, 'fetch', '--depth', '1', 'origin', options.ref], {
+    dryRun: options.dryRun,
+  });
+  run('git', ['-C', options.installDir, 'checkout', 'FETCH_HEAD'], {
+    dryRun: options.dryRun,
+  });
+}
+
+function installDependencies(options) {
+  if (options.skipDeps) {
+    console.log('Skipping Open Design dependency install because --skip-deps or TSP_OPEN_DESIGN_SKIP_DEPS=1 is set.');
+    return;
+  }
+
+  if (!commandExists('corepack')) {
+    console.warn(
+      'Open Design source is installed, but corepack/pnpm is not available. '
+      + 'Install Node 24 with corepack, then run `corepack enable && pnpm install` in the Open Design directory.'
+    );
+    return;
+  }
+
+  run('corepack', ['enable'], {
+    cwd: options.installDir,
+    dryRun: options.dryRun,
+  });
+
+  if (!commandExists('pnpm')) {
+    console.warn(
+      'Open Design source is installed, but pnpm is still not available after `corepack enable`. '
+      + 'Run `corepack prepare pnpm@10.33.2 --activate && pnpm install` in the Open Design directory.'
+    );
+    return;
+  }
+
+  run('pnpm', ['install'], {
+    cwd: options.installDir,
+    dryRun: options.dryRun,
+  });
+}
+
+function main() {
+  try {
+    const options = parseArgs(process.argv);
+    if (options.help) {
+      printHelp();
+      return;
+    }
+
+    if (!commandExists('git')) {
+      throw new Error('git is required to install Open Design');
+    }
+
+    ensureOpenDesignCheckout(options);
+    installDependencies(options);
+    console.log(`Open Design ready: ${options.installDir}`);
+  } catch (error) {
+    console.error(`Error: ${error.message}`);
+    process.exit(1);
+  }
+}
+
+main();

package/scripts/install-plan.js

@@ -183,6 +183,23 @@ function printPlan(plan) {
       );
     }
   }
+
+  const externalInstalls = plan.selectedModules
+    .map(module => ({ module, externalInstall: module.externalInstall }))
+    .filter(({ externalInstall }) => externalInstall && typeof externalInstall === 'object' && !Array.isArray(externalInstall))
+    .filter(({ externalInstall }) => {
+      const profiles = Array.isArray(externalInstall.profiles)
+        ? externalInstall.profiles.map(value => String(value).trim()).filter(Boolean)
+        : [];
+      return profiles.length === 0 || profiles.includes(plan.profileId);
+    });
+  if (externalInstalls.length > 0) {
+    console.log('');
+    console.log(`External install plan (${externalInstalls.length}):`);
+    for (const { module, externalInstall } of externalInstalls) {
+      console.log(`- ${externalInstall.id || module.id}: ${externalInstall.description || externalInstall.script}`);
+    }
+  }
 }
 
 function main() {

package/scripts/lib/install/apply.js

@@ -2,6 +2,7 @@
 
 const fs = require('fs');
 const path = require('path');
+const { spawnSync } = require('child_process');
 
 const { writeInstallState } = require('../install-state');
 const { writeInstallAuditManifest } = require('../install-audit-manifest');
@@ -176,6 +177,32 @@ function buildMergedSettings(plan) {
   };
 }
 
+function runExternalInstall(externalInstall) {
+  const args = [];
+  if (externalInstall.scriptPath) {
+    args.push(externalInstall.scriptPath);
+  } else if (externalInstall.script) {
+    args.push(externalInstall.script);
+  }
+  if (Array.isArray(externalInstall.args)) {
+    args.push(...externalInstall.args);
+  }
+
+  const command = externalInstall.command || 'node';
+  const label = externalInstall.id || externalInstall.moduleId || command;
+  console.log(`Running external install: ${label}`);
+
+  const result = spawnSync(command, args, {
+    cwd: externalInstall.cwd || process.cwd(),
+    encoding: 'utf8',
+    stdio: 'inherit',
+  });
+
+  if (result.status !== 0) {
+    throw new Error(`External install failed: ${label}`);
+  }
+}
+
 function applyInstallPlan(plan) {
   const mergedSettingsPlan = buildMergedSettings(plan);
 
@@ -199,6 +226,10 @@ function applyInstallPlan(plan) {
     );
   }
 
+  for (const externalInstall of Array.isArray(plan.externalInstalls) ? plan.externalInstalls : []) {
+    runExternalInstall(externalInstall);
+  }
+
   writeInstallState(plan.installStatePath, plan.statePreview);
   const { installManifestPath } = writeInstallAuditManifest(plan);
 

package/scripts/lib/install-executor.js

@@ -133,6 +133,56 @@ function createStatePreview(options) {
   return createInstallState(options);
 }
 
+function resolveExternalInstalls(selectedModules, options = {}) {
+  const profileId = options.profileId || null;
+  const sourceRoot = options.sourceRoot || getSourceRoot();
+  const target = options.target || null;
+  const installs = [];
+
+  for (const module of selectedModules) {
+    const externalInstall = module && module.externalInstall;
+    if (!externalInstall || typeof externalInstall !== 'object' || Array.isArray(externalInstall)) {
+      continue;
+    }
+
+    const profileFilter = Array.isArray(externalInstall.profiles)
+      ? externalInstall.profiles.map(value => String(value).trim()).filter(Boolean)
+      : [];
+    if (profileFilter.length > 0 && (!profileId || !profileFilter.includes(profileId))) {
+      continue;
+    }
+
+    const command = typeof externalInstall.command === 'string' && externalInstall.command.trim()
+      ? externalInstall.command.trim()
+      : 'node';
+    const script = typeof externalInstall.script === 'string' && externalInstall.script.trim()
+      ? externalInstall.script.trim()
+      : null;
+    const args = Array.isArray(externalInstall.args)
+      ? externalInstall.args.map(value => String(value))
+      : [];
+
+    if (!script) {
+      throw new Error(`Install module ${module.id} has externalInstall but no script`);
+    }
+
+    installs.push({
+      id: externalInstall.id || module.id,
+      moduleId: module.id,
+      description: externalInstall.description || '',
+      command,
+      script,
+      scriptPath: path.join(sourceRoot, script),
+      args,
+      cwd: sourceRoot,
+      target,
+      profileId,
+    });
+  }
+
+  return installs;
+}
+
 function applyInstallPlan(plan) {
   const { applyInstallPlan: applyPlan } = require('./install/apply');
   return applyPlan(plan);
@@ -617,6 +667,11 @@ function createManifestInstallPlan(options = {}) {
   });
   const adapter = getInstallTargetAdapter(target);
   const operations = plan.operations.flatMap(operation => materializeScaffoldOperation(sourceRoot, operation));
+  const externalInstalls = resolveExternalInstalls(plan.selectedModules, {
+    profileId: plan.profileId,
+    sourceRoot,
+    target,
+  });
   const source = {
     repoVersion: getPackageVersion(sourceRoot),
     repoCommit: getRepoCommit(sourceRoot),
@@ -667,6 +722,7 @@ function createManifestInstallPlan(options = {}) {
     skippedModuleIds: plan.skippedModuleIds,
     excludedModuleIds: plan.excludedModuleIds,
     operations,
+    externalInstalls,
     statePreview,
   };
 }

package/scripts/lib/team-skills-data.json

@@ -66,10 +66,10 @@
         "默认以 `karpathy-guidelines` 的方式先暴露歧义、范围边界与更简单路径，不在入口阶段静默替用户补全高风险假设。",
         "检查现有证据是否齐备：PRD、delivery-plan、arch-design、handoff、execute-log、test-plan、launch-acceptance、deployment-context、release-plan、closeout-summary，以及 `docs/memory/project-context.md`。",
         "若任务边界清晰、影响面小、风险低，优先推荐 `/quick`；否则继续沿 `/team-*` 主链推进。",
-        "若是既有项目（brownfield）且现状上下文不足，优先建议执行 `/update-codemaps` 并启用 `doc-architecture`，把现有模块、集成点、关键数据流和历史包袱回落到 `delivery-plan.md` / `arch-design.md`。",
+        "若是既有项目（brownfield）且现状上下文不足，优先建议执行 `/update-codemaps` 并启用 `doc-architecture`，需要轻量结构证据时选择 Graphify，需要跨模块影响面或 MCP 证据时选择 GitNexus，再把现有模块、集成点、关键数据流和历史包袱回落到 `delivery-plan.md` / `arch-design.md`。",
         "若需求规模较大或涉及多角色并行，实现前先要求把计划切成可独立验收、可独立 handoff 的 story-sized execution units，并确认 `artifact:persist` 已创建对应任务目录与关键 artifact，再进入 `/team-execute`。",
         "若缺少 PRD 或需求边界，推荐 `/team-intake`；若缺少 challenge、design review 或 implementation-readiness，推荐 `/team-plan`；若 readiness proof 与 handoff 齐备，推荐 `/team-execute`；若已完成实现与自测，推荐 `/team-review`；若已获得放行，推荐 `/team-release`；若发布观察窗口结束，推荐 `/team-closeout`。",
-        "若是既有项目且上下文不足，提示先补齐 brownfield / doc-architecture 类上下文，再进入计划或执行。",
+        "若是既有项目且上下文不足，提示先补齐 brownfield / doc-architecture 类上下文；必要时用 Graphify 或 GitNexus 补图谱证据，再进入计划或执行。",
         "输出结构化建议：推荐命令、原因、阻塞项、降级路径，并说明是否需要先运行 `npm run workflow:readiness`。"
       ]
     },
@@ -136,7 +136,7 @@
         "默认把 `karpathy-guidelines` 作为计划收口护栏：要求显式写出假设、更简单备选路径、当前不做项，以及为什么本轮范围已经足够。",
         "按任务特征装配动态讨论分组，先讨论再收敛，避免未经质疑直接进入计划冻结。",
         "若启用 `doc-architecture`，补齐 Service Catalog、Communication Matrix、NFR Summary，并明确其 artifact 回落位置。",
-        "若是既有项目（brownfield），先梳理现有模块边界、外部依赖、历史约束和缺失文档；必要时运行 `/update-codemaps`，再把 brownfield snapshot 回落到 `delivery-plan.md` 与 `arch-design.md`。",
+        "若是既有项目（brownfield），先梳理现有模块边界、外部依赖、历史约束和缺失文档；必要时运行 `/update-codemaps`，需要轻量结构证据时选择 Graphify，需要跨模块影响面或 MCP 证据时选择 GitNexus，再把 brownfield snapshot 回落到 `delivery-plan.md` 与 `arch-design.md`。",
         "若为企业内部应用，锁定应用等级、技术架构等级、关键组件偏离和资产入口要求，并判断是否必须输出 ADR。",
         "为本次任务显式装配 shared 能力、ECC 增强与可选 enterprise overlay 组合，并说明哪些私有 overlay 能力、runbook 或 overlay 仅按场景启用。",
         "若存在多参数、多角色、多配置或多终端组合，提前判断是否需要 `pairwise-test-design` 压缩测试矩阵。",
@@ -468,7 +468,7 @@
     },
     {
       "name": "update-codemaps",
-      "summary": "扫描代码结构并生成 token-lean codemaps，适合作为 brownfield 项目的现状快照与主链前置上下文。",
+      "summary": "扫描代码结构并生成 token-lean codemaps，适合作为 brownfield 项目的现状快照与 Graphify / GitNexus 图谱分析前置上下文。",
       "primary_role": "doc-updater",
       "inputs": [
         "代码仓结构",
@@ -478,13 +478,14 @@
       "outputs": [
         "docs/CODEMAPS/ 下的结构化 codemap",
         ".reports/codemap-diff.txt 差异摘要",
-        "可供 `/team-help` / `/team-plan` 消费的 brownfield context"
+        "可供 `/team-help` / `/team-plan` 消费的 brownfield context",
+        "可供 Graphify / GitNexus 继续深挖的结构化问题清单"
       ],
       "steps": [
         "先识别仓库类型、源码目录、入口文件和主要依赖边界。",
         "为 architecture/backend/frontend/data/dependencies 生成 token-lean 文档，不写实现细节噪音。",
         "若已有 codemap，先比较变更比例；超过阈值时要求人工确认再覆盖。",
-        "把结果作为 brownfield context snapshot 的辅助输入，回落到 `delivery-plan.md` / `arch-design.md`，不要形成平行事实源。"
+        "把结果作为 brownfield context snapshot 的辅助输入；若需要图谱证据，再选择 Graphify 或 GitNexus，并把结论回落到 `delivery-plan.md` / `arch-design.md`，不要形成平行事实源。"
       ]
     },
     {