openxiangda 1.0.174 → 1.0.176

package/lib/content-cache.js

@@ -0,0 +1,97 @@
+const fs = require('fs');
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+const CACHE_SCHEMA_VERSION = 'openxiangda_content_cache_v1';
+const MAX_CACHE_BYTES = 2 * 1024 * 1024;
+
+function resolveCacheRoot(cwd) {
+  const root = spawnSync('git', ['rev-parse', '--show-toplevel'], {
+    cwd,
+    encoding: 'utf8',
+    stdio: ['ignore', 'pipe', 'ignore'],
+  });
+  const common = spawnSync('git', ['rev-parse', '--git-common-dir'], {
+    cwd,
+    encoding: 'utf8',
+    stdio: ['ignore', 'pipe', 'ignore'],
+  });
+  if (root.status !== 0 || common.status !== 0) return null;
+  const workspaceRoot = String(root.stdout || '').trim();
+  const commonPath = String(common.stdout || '').trim();
+  if (!workspaceRoot || !commonPath) return null;
+  const commonDir = path.isAbsolute(commonPath)
+    ? commonPath
+    : path.resolve(workspaceRoot, commonPath);
+  return path.join(commonDir, 'openxiangda', 'cache', 'v1');
+}
+
+function normalizeSegment(value, label) {
+  const segment = String(value || '').trim();
+  if (!/^[a-z0-9][a-z0-9._-]*$/i.test(segment)) {
+    throw new Error(`invalid content cache ${label}`);
+  }
+  return segment;
+}
+
+function cacheFile(cwd, namespace, key) {
+  const root = resolveCacheRoot(cwd);
+  if (!root) return null;
+  return path.join(
+    root,
+    normalizeSegment(namespace, 'namespace'),
+    `${normalizeSegment(key, 'key')}.json`
+  );
+}
+
+function readContentCache(options = {}) {
+  const file = cacheFile(
+    path.resolve(options.cwd || process.cwd()),
+    options.namespace,
+    options.key
+  );
+  if (!file || !fs.existsSync(file)) return null;
+  try {
+    const stat = fs.statSync(file);
+    if (!stat.isFile() || stat.size <= 0 || stat.size > MAX_CACHE_BYTES) {
+      return null;
+    }
+    const record = JSON.parse(fs.readFileSync(file, 'utf8'));
+    if (
+      record?.schemaVersion !== CACHE_SCHEMA_VERSION ||
+      record?.namespace !== options.namespace ||
+      record?.key !== options.key
+    ) {
+      return null;
+    }
+    return record.value;
+  } catch {
+    return null;
+  }
+}
+
+function writeContentCache(options = {}) {
+  const cwd = path.resolve(options.cwd || process.cwd());
+  const file = cacheFile(cwd, options.namespace, options.key);
+  if (!file) return null;
+  const record = {
+    schemaVersion: CACHE_SCHEMA_VERSION,
+    namespace: options.namespace,
+    key: options.key,
+    value: options.value,
+    createdAt: new Date().toISOString(),
+  };
+  const content = `${JSON.stringify(record)}\n`;
+  if (Buffer.byteLength(content, 'utf8') > MAX_CACHE_BYTES) return null;
+  fs.mkdirSync(path.dirname(file), { recursive: true, mode: 0o700 });
+  const temporary = `${file}.${process.pid}.${Date.now()}.tmp`;
+  fs.writeFileSync(temporary, content, { mode: 0o600 });
+  fs.renameSync(temporary, file);
+  return file;
+}
+
+module.exports = {
+  CACHE_SCHEMA_VERSION,
+  readContentCache,
+  writeContentCache,
+};

package/lib/dependency-capsule.js

@@ -0,0 +1,246 @@
+const crypto = require('crypto');
+const fs = require('fs');
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+const CAPSULE_SCHEMA = 'openxiangda_dependency_capsule_v1';
+const LOCKFILES = [
+  ['pnpm-lock.yaml', 'pnpm'],
+  ['package-lock.json', 'npm'],
+  ['npm-shrinkwrap.json', 'npm'],
+  ['yarn.lock', 'yarn'],
+];
+
+function sha256(value) {
+  return crypto.createHash('sha256').update(value).digest('hex');
+}
+
+function gitCommonDir(cwd) {
+  const result = spawnSync('git', ['rev-parse', '--git-common-dir'], {
+    cwd,
+    encoding: 'utf8',
+  });
+  if (result.status !== 0) {
+    throw new Error(
+      `DEPENDENCY_CAPSULE_GIT_REQUIRED: ${String(result.stderr || result.stdout).trim()}`
+    );
+  }
+  const value = String(result.stdout || '').trim();
+  return path.resolve(cwd, value);
+}
+
+function resolveDependencyContract(cwd) {
+  const packageFile = path.join(cwd, 'package.json');
+  if (!fs.existsSync(packageFile)) {
+    throw new Error('DEPENDENCY_CAPSULE_PACKAGE_REQUIRED: 缺少 package.json');
+  }
+  const lock = LOCKFILES.find(([name]) => fs.existsSync(path.join(cwd, name)));
+  if (!lock) {
+    throw new Error(
+      'DEPENDENCY_CAPSULE_LOCKFILE_REQUIRED: 缺少 pnpm-lock.yaml/package-lock.json/yarn.lock'
+    );
+  }
+  const [lockfile, packageManager] = lock;
+  const packageJson = fs.readFileSync(packageFile);
+  const lockContent = fs.readFileSync(path.join(cwd, lockfile));
+  const fingerprint = sha256(
+    Buffer.concat([
+      Buffer.from(`${CAPSULE_SCHEMA}\0${process.platform}\0${process.arch}\0${process.versions.node}\0`),
+      packageJson,
+      Buffer.from('\0'),
+      lockContent,
+    ])
+  );
+  return {
+    schemaVersion: CAPSULE_SCHEMA,
+    fingerprint,
+    packageManager,
+    lockfile,
+    packageFile,
+  };
+}
+
+function installCommand(contract) {
+  if (contract.packageManager === 'pnpm') {
+    return ['pnpm', ['install', '--frozen-lockfile', '--ignore-scripts=false']];
+  }
+  if (contract.packageManager === 'yarn') {
+    return ['yarn', ['install', '--immutable']];
+  }
+  return ['npm', ['ci', '--no-audit', '--no-fund']];
+}
+
+function buildDependencyCapsulePlan(options = {}) {
+  const cwd = path.resolve(options.cwd || process.cwd());
+  const contract = resolveDependencyContract(cwd);
+  const commonDir = gitCommonDir(cwd);
+  const capsuleDir = path.join(
+    commonDir,
+    'openxiangda',
+    'dependencies',
+    contract.fingerprint
+  );
+  const capsuleNodeModules = path.join(capsuleDir, 'node_modules');
+  const markerFile = path.join(capsuleDir, 'capsule.json');
+  const workspaceNodeModules = path.join(cwd, 'node_modules');
+  let marker = null;
+  try {
+    marker = JSON.parse(fs.readFileSync(markerFile, 'utf8'));
+  } catch {
+    marker = null;
+  }
+  const capsuleReady = Boolean(
+    marker?.schemaVersion === CAPSULE_SCHEMA &&
+      marker?.fingerprint === contract.fingerprint &&
+      fs.existsSync(capsuleNodeModules)
+  );
+  const currentTarget = fs.existsSync(workspaceNodeModules)
+    ? fs.realpathSync(workspaceNodeModules)
+    : null;
+  const linked = Boolean(
+    capsuleReady &&
+      currentTarget &&
+      currentTarget === fs.realpathSync(capsuleNodeModules)
+  );
+  const [command, args] = installCommand(contract);
+  return {
+    ...contract,
+    cwd,
+    commonDir,
+    capsuleDir,
+    capsuleNodeModules,
+    markerFile,
+    workspaceNodeModules,
+    capsuleReady,
+    linked,
+    command,
+    args,
+  };
+}
+
+function copyDependencyInputs(plan) {
+  fs.mkdirSync(plan.capsuleDir, { recursive: true, mode: 0o700 });
+  fs.copyFileSync(plan.packageFile, path.join(plan.capsuleDir, 'package.json'));
+  fs.copyFileSync(
+    path.join(plan.cwd, plan.lockfile),
+    path.join(plan.capsuleDir, plan.lockfile)
+  );
+}
+
+function acquireInstallLock(plan) {
+  const lockDir = `${plan.capsuleDir}.lock`;
+  try {
+    fs.mkdirSync(lockDir, { recursive: false, mode: 0o700 });
+  } catch (error) {
+    if (error.code === 'EEXIST') {
+      const busy = new Error(
+        `DEPENDENCY_CAPSULE_BUSY: 另一个任务正在准备 ${plan.fingerprint.slice(0, 12)}；稍后重试`
+      );
+      busy.code = 'DEPENDENCY_CAPSULE_BUSY';
+      throw busy;
+    }
+    throw error;
+  }
+  return () => fs.rmSync(lockDir, { recursive: true, force: true });
+}
+
+function writeMarker(plan) {
+  const marker = {
+    schemaVersion: CAPSULE_SCHEMA,
+    fingerprint: plan.fingerprint,
+    packageManager: plan.packageManager,
+    lockfile: plan.lockfile,
+    node: process.versions.node,
+    platform: process.platform,
+    arch: process.arch,
+    preparedAt: new Date().toISOString(),
+  };
+  const temporary = `${plan.markerFile}.${process.pid}.tmp`;
+  fs.writeFileSync(temporary, `${JSON.stringify(marker, null, 2)}\n`, {
+    mode: 0o600,
+  });
+  fs.renameSync(temporary, plan.markerFile);
+}
+
+function linkWorkspaceNodeModules(plan, options = {}) {
+  if (plan.linked) return 'already-linked';
+  if (fs.existsSync(plan.workspaceNodeModules)) {
+    const stats = fs.lstatSync(plan.workspaceNodeModules);
+    if (!stats.isSymbolicLink() && !options.force) {
+      const error = new Error(
+        'DEPENDENCY_CAPSULE_LOCAL_NODE_MODULES: 当前 node_modules 不是 capsule 链接；使用 --force 前请确认没有正在运行的构建'
+      );
+      error.code = 'DEPENDENCY_CAPSULE_LOCAL_NODE_MODULES';
+      throw error;
+    }
+    fs.rmSync(plan.workspaceNodeModules, { recursive: true, force: true });
+  }
+  fs.symlinkSync(plan.capsuleNodeModules, plan.workspaceNodeModules, 'junction');
+  return 'linked';
+}
+
+function prepareDependencyCapsule(options = {}) {
+  let plan = buildDependencyCapsulePlan(options);
+  if (options.check) {
+    return {
+      ready: plan.capsuleReady && plan.linked,
+      capsuleReady: plan.capsuleReady,
+      linked: plan.linked,
+      fingerprint: plan.fingerprint,
+      packageManager: plan.packageManager,
+      lockfile: plan.lockfile,
+      recommendedCommand: plan.capsuleReady
+        ? 'openxiangda workspace prepare --force'
+        : 'openxiangda workspace prepare',
+    };
+  }
+  if (!plan.capsuleReady) {
+    fs.mkdirSync(path.dirname(plan.capsuleDir), { recursive: true, mode: 0o700 });
+    const releaseLock = acquireInstallLock(plan);
+    try {
+      copyDependencyInputs(plan);
+      const result = spawnSync(plan.command, plan.args, {
+        cwd: plan.capsuleDir,
+        encoding: 'utf8',
+        stdio: options.quiet ? 'pipe' : 'inherit',
+        env: {
+          ...process.env,
+          CI: process.env.CI || 'true',
+        },
+      });
+      if (result.status !== 0) {
+        fs.rmSync(plan.capsuleDir, { recursive: true, force: true });
+        const error = new Error(
+          `DEPENDENCY_CAPSULE_INSTALL_FAILED: ${plan.command} ${plan.args.join(' ')}`
+        );
+        error.code = 'DEPENDENCY_CAPSULE_INSTALL_FAILED';
+        throw error;
+      }
+      if (!fs.existsSync(plan.capsuleNodeModules)) {
+        throw new Error('DEPENDENCY_CAPSULE_INSTALL_EMPTY: 安装完成但 node_modules 不存在');
+      }
+      writeMarker(plan);
+    } finally {
+      releaseLock();
+    }
+    plan = buildDependencyCapsulePlan(options);
+  }
+  const action = linkWorkspaceNodeModules(plan, options);
+  return {
+    ready: true,
+    capsuleReady: true,
+    linked: true,
+    action,
+    fingerprint: plan.fingerprint,
+    packageManager: plan.packageManager,
+    lockfile: plan.lockfile,
+    capsuleDir: plan.capsuleDir,
+  };
+}
+
+module.exports = {
+  CAPSULE_SCHEMA,
+  buildDependencyCapsulePlan,
+  prepareDependencyCapsule,
+  resolveDependencyContract,
+};

package/lib/integration-bundle.js

@@ -0,0 +1,204 @@
+const fs = require('fs');
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+const TASK_RESULT_SCHEMA_VERSION = 'openxiangda_task_result_v1';
+const INTEGRATION_BUNDLE_SCHEMA_VERSION = 'openxiangda_integration_bundle_v1';
+
+function runGit(cwd, args, options = {}) {
+  const result = spawnSync('git', args, {
+    cwd,
+    encoding: 'utf8',
+    stdio: ['ignore', 'pipe', 'pipe'],
+  });
+  if (result.status !== 0 && !options.allowFailure) {
+    const error = new Error(
+      String(result.stderr || result.stdout || `git ${args.join(' ')} failed`).trim()
+    );
+    error.code = 'INTEGRATION_GIT_FAILED';
+    throw error;
+  }
+  return {
+    ok: result.status === 0,
+    stdout: String(result.stdout || '').trim(),
+    stderr: String(result.stderr || '').trim(),
+  };
+}
+
+function gitCommonStateDir(cwd) {
+  const root = runGit(cwd, ['rev-parse', '--show-toplevel']).stdout;
+  const common = runGit(cwd, ['rev-parse', '--git-common-dir']).stdout;
+  const commonDir = path.isAbsolute(common) ? common : path.resolve(root, common);
+  return path.join(commonDir, 'openxiangda');
+}
+
+function taskResultFile(cwd, changeId) {
+  return path.join(
+    gitCommonStateDir(cwd),
+    'task-results',
+    `${normalizeChangeId(changeId)}.json`
+  );
+}
+
+function normalizeChangeId(value) {
+  const changeId = String(value || '').trim();
+  if (!/^[a-z0-9][a-z0-9._-]*$/i.test(changeId)) {
+    const error = new Error(`INTEGRATION_CHANGE_ID_INVALID: ${value || '(empty)'}`);
+    error.code = 'INTEGRATION_CHANGE_ID_INVALID';
+    throw error;
+  }
+  return changeId.toLowerCase();
+}
+
+function recordIntegrationTaskResult(options = {}) {
+  const cwd = path.resolve(options.cwd || process.cwd());
+  const changeId = normalizeChangeId(options.changeId);
+  const dirty = runGit(cwd, ['status', '--porcelain']).stdout;
+  if (dirty) {
+    const error = new Error(
+      'INTEGRATION_TASK_RESULT_DIRTY: 请先提交该任务的实现、测试和 SDD 记录，再生成 task result'
+    );
+    error.code = 'INTEGRATION_TASK_RESULT_DIRTY';
+    throw error;
+  }
+  const commit = runGit(cwd, ['rev-parse', 'HEAD']).stdout;
+  const treeHash = runGit(cwd, ['rev-parse', 'HEAD^{tree}']).stdout;
+  const branch = runGit(cwd, ['branch', '--show-current']).stdout;
+  if (!branch) {
+    const error = new Error(
+      'INTEGRATION_TASK_BRANCH_REQUIRED: detached HEAD 不能生成可合并任务结果'
+    );
+    error.code = 'INTEGRATION_TASK_BRANCH_REQUIRED';
+    throw error;
+  }
+  const result = {
+    schemaVersion: TASK_RESULT_SCHEMA_VERSION,
+    changeId,
+    commit,
+    treeHash,
+    branch,
+    targets: options.targets || {},
+    changedFiles: Array.from(
+      new Set((options.changedFiles || []).map(String).filter(Boolean))
+    ).sort(),
+    recordedAt: new Date().toISOString(),
+  };
+  const file = taskResultFile(cwd, changeId);
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  fs.writeFileSync(file, `${JSON.stringify(result, null, 2)}\n`, {
+    mode: 0o600,
+  });
+  return { ...result, file };
+}
+
+function readIntegrationTaskResult(cwd, changeId) {
+  const file = taskResultFile(cwd, changeId);
+  if (!fs.existsSync(file)) return null;
+  try {
+    const value = JSON.parse(fs.readFileSync(file, 'utf8'));
+    return value?.schemaVersion === TASK_RESULT_SCHEMA_VERSION
+      ? { ...value, file }
+      : null;
+  } catch {
+    return null;
+  }
+}
+
+function commitIsAncestor(cwd, commit, descendant = 'HEAD') {
+  return runGit(
+    cwd,
+    ['merge-base', '--is-ancestor', String(commit), String(descendant)],
+    { allowFailure: true }
+  ).ok;
+}
+
+function collectIntegrationTaskResults(options = {}) {
+  const cwd = path.resolve(options.cwd || process.cwd());
+  const changeIds = Array.from(
+    new Set((options.changeIds || []).map(normalizeChangeId))
+  ).sort();
+  const results = changeIds.map(changeId => {
+    const result = readIntegrationTaskResult(cwd, changeId);
+    if (!result) {
+      const error = new Error(
+        `INTEGRATION_TASK_RESULT_REQUIRED: ${changeId} 缺少 task result；请在任务提交后运行 openxiangda sdd ready ${changeId}`
+      );
+      error.code = 'INTEGRATION_TASK_RESULT_REQUIRED';
+      error.changeId = changeId;
+      throw error;
+    }
+    if (!commitIsAncestor(cwd, result.commit, 'HEAD')) {
+      const error = new Error(
+        `INTEGRATION_TASK_COMMIT_NOT_MERGED: ${changeId}@${String(result.commit).slice(0, 12)} 尚未合并到当前主线 HEAD`
+      );
+      error.code = 'INTEGRATION_TASK_COMMIT_NOT_MERGED';
+      error.changeId = changeId;
+      error.commit = result.commit;
+      throw error;
+    }
+    return result;
+  });
+  return {
+    schemaVersion: INTEGRATION_BUNDLE_SCHEMA_VERSION,
+    requiredChanges: changeIds,
+    requiredCommits: results.map(result => ({
+      changeId: result.changeId,
+      commit: result.commit,
+      treeHash: result.treeHash,
+      sourceBranch: result.branch,
+    })),
+    verifiedAgainst: runGit(cwd, ['rev-parse', 'HEAD']).stdout,
+    createdAt: new Date().toISOString(),
+  };
+}
+
+function inspectIntegrationBundleCommits(integration, options = {}) {
+  const cwd = path.resolve(options.cwd || process.cwd());
+  const required = Array.isArray(integration?.requiredCommits)
+    ? integration.requiredCommits
+    : [];
+  return {
+    schemaVersion:
+      integration?.schemaVersion || INTEGRATION_BUNDLE_SCHEMA_VERSION,
+    valid: required.length > 0,
+    requiredCommits: required.map(item => ({
+      ...item,
+      mergedIntoHead: commitIsAncestor(cwd, item.commit, 'HEAD'),
+    })),
+    checkedHead: runGit(cwd, ['rev-parse', 'HEAD']).stdout,
+    checkedAt: new Date().toISOString(),
+  };
+}
+
+function assertIntegrationBundleCommits(integration, options = {}) {
+  const inspection = inspectIntegrationBundleCommits(integration, options);
+  if (!inspection.valid) {
+    const error = new Error(
+      'INTEGRATION_BUNDLE_REQUIRED: mainline bundle 缺少 requiredCommits，禁止发布可能遗漏任务的主线'
+    );
+    error.code = 'INTEGRATION_BUNDLE_REQUIRED';
+    throw error;
+  }
+  const missing = inspection.requiredCommits.filter(item => !item.mergedIntoHead);
+  if (missing.length > 0) {
+    const error = new Error(
+      `INTEGRATION_TASK_COMMIT_NOT_MERGED: ${missing
+        .map(item => `${item.changeId}@${String(item.commit).slice(0, 12)}`)
+        .join(', ')} 尚未合并到当前主线 HEAD`
+    );
+    error.code = 'INTEGRATION_TASK_COMMIT_NOT_MERGED';
+    error.missing = missing;
+    throw error;
+  }
+  return inspection;
+}
+
+module.exports = {
+  INTEGRATION_BUNDLE_SCHEMA_VERSION,
+  TASK_RESULT_SCHEMA_VERSION,
+  assertIntegrationBundleCommits,
+  collectIntegrationTaskResults,
+  inspectIntegrationBundleCommits,
+  readIntegrationTaskResult,
+  recordIntegrationTaskResult,
+};

package/lib/policy.js

@@ -0,0 +1,97 @@
+const fs = require('fs');
+const path = require('path');
+
+const POLICY_FILE = path.join(
+  __dirname,
+  '..',
+  'policy',
+  'openxiangda-policy.json'
+);
+const POLICY_MARKER_PREFIX = 'OpenXiangda-Policy-Version:';
+const POLICY_MARKER_FILES = [
+  'README.md',
+  'openxiangda-skills/SKILL.md',
+  'templates/openxiangda-react-spa/AGENTS.md',
+  'templates/sy-lowcode-app-workspace/AGENTS.md',
+];
+
+function loadEngineeringPolicy() {
+  const policy = JSON.parse(fs.readFileSync(POLICY_FILE, 'utf8'));
+  validateEngineeringPolicy(policy);
+  return policy;
+}
+
+function validateEngineeringPolicy(policy) {
+  const errors = [];
+  if (policy?.schemaVersion !== 'openxiangda_engineering_policy_v1') {
+    errors.push('schemaVersion 必须是 openxiangda_engineering_policy_v1');
+  }
+  if (!Number.isSafeInteger(policy?.policyVersion) || policy.policyVersion < 1) {
+    errors.push('policyVersion 必须是正整数');
+  }
+  if (policy?.sdd?.verifyIsReadOnly !== true) {
+    errors.push('sdd.verifyIsReadOnly 必须为 true');
+  }
+  if (policy?.git?.requireRemoteMainlineContainment !== true) {
+    errors.push('git.requireRemoteMainlineContainment 必须为 true');
+  }
+  if (policy?.release?.unsupportedGenericMode !== 'fail-closed') {
+    errors.push('release.unsupportedGenericMode 必须为 fail-closed');
+  }
+  const ttl = Number(policy?.ownership?.defaultTtlSeconds);
+  if (!Number.isSafeInteger(ttl) || ttl < 300 || ttl > 86400) {
+    errors.push('ownership.defaultTtlSeconds 必须在 300-86400 之间');
+  }
+  if (errors.length > 0) {
+    const error = new Error(`OPENXIANGDA_POLICY_INVALID: ${errors.join('; ')}`);
+    error.code = 'OPENXIANGDA_POLICY_INVALID';
+    error.errors = errors;
+    throw error;
+  }
+  return policy;
+}
+
+function checkEngineeringPolicyMarkers(options = {}) {
+  const root = path.resolve(options.root || path.join(__dirname, '..'));
+  const policy = loadEngineeringPolicy();
+  const expected = `${POLICY_MARKER_PREFIX} ${policy.policyVersion}`;
+  const files = POLICY_MARKER_FILES.map(relativePath => {
+    const file = path.join(root, relativePath);
+    const exists = fs.existsSync(file);
+    const content = exists ? fs.readFileSync(file, 'utf8') : '';
+    return {
+      file: relativePath,
+      exists,
+      synchronized: exists && content.includes(expected),
+    };
+  });
+  return {
+    valid: files.every(item => item.synchronized),
+    policyVersion: policy.policyVersion,
+    expectedMarker: expected,
+    files,
+  };
+}
+
+function renderEngineeringPolicyMarkdown(policy = loadEngineeringPolicy()) {
+  return [
+    `<!-- ${POLICY_MARKER_PREFIX} ${policy.policyVersion} -->`,
+    `Policy v${policy.policyVersion}:`,
+    '',
+    `- 风险按 ${policy.risk.classifyBy.join('、')} 分级；目录只作信号。`,
+    '- SDD verify 只读；Markdown 是按需派生视图。',
+    '- 平台仓库直接开发权威 master；应用任务可用独立 worktree，但只从干净、已推送的权威主线发布。',
+    `- 原子 child：${policy.release.atomicChildren.join(', ')}。`,
+    `- 尚无 staged child 的通用资源必须 ${policy.release.unsupportedGenericMode}；维护直发必须显式选择并展示影响范围。`,
+    `- 激活后的副作用进入 ${policy.release.postCommitMode}。`,
+  ].join('\n');
+}
+
+module.exports = {
+  POLICY_FILE,
+  POLICY_MARKER_FILES,
+  checkEngineeringPolicyMarkers,
+  loadEngineeringPolicy,
+  renderEngineeringPolicyMarkdown,
+  validateEngineeringPolicy,
+};