Dbs Content System

#!/usr/bin/env node

const fs = require("fs");
const path = require("path");

const root = path.resolve(process.cwd());
const unitRoot = path.join(root, "02-内容单元库");
const assemblyRoot = path.join(root, "06-选题装配");

const typeDirs = {
  QST: "问题单元",
  CON: "概念单元",
  OPI: "观点单元",
  CAS: "案例单元",
  SOL: "方案单元",
};

function fail(message) {
  console.error(message);
  process.exit(1);
}

function parseArgs(argv) {
  const result = {};
  for (let i = 0; i < argv.length; i += 1) {
    const arg = argv[i];
    if (!arg.startsWith("--")) continue;
    const key = arg.slice(2);
    const next = argv[i + 1];
    if (!next || next.startsWith("--")) result[key] = true;
    else {
      result[key] = next;
      i += 1;
    }
  }
  return result;
}

function ensureDir(dir) {
  fs.mkdirSync(dir, { recursive: true });
}

function slugFromTitle(title) {
  return title.replace(/[\\/:*?"<>|]/g, " ").replace(/\s+/g, " ").trim() || "未命名选题";
}

function splitList(value) {
  return String(value || "")
    .split(",")
    .map((item) => item.trim())
    .filter(Boolean);
}

function readFrontmatter(content) {
  const match = content.match(/^---\n([\s\S]*?)\n---\n?/);
  return match ? match[1] : "";
}

function readBody(content) {
  const match = content.match(/^---\n[\s\S]*?\n---\n?([\s\S]*)$/);
  return match ? match[1] : content;
}

function getField(frontmatter, field) {
  const match = frontmatter.match(new RegExp(`^${field}:\\s*(.+)$`, "m"));
  return match ? match[1].trim() : "";
}

function getListField(frontmatter, field) {
  const match = frontmatter.match(new RegExp(`^${field}:\\n((?:\\s+-\\s+.+\\n?)*)`, "m"));
  if (!match) return [];
  return match[1]
    .split("\n")
    .map((line) => line.trim().replace(/^- /, "").trim())
    .filter(Boolean);
}

function getRelationshipTargets(frontmatter) {
  return [...frontmatter.matchAll(/^\s*target:\s*(.+)$/gm)]
    .map((match) => match[1].trim())
    .filter(Boolean);
}

function getSection(body, heading) {
  const match = body.match(new RegExp(`## ${heading}\\n\\n([\\s\\S]*?)(?=\\n## |$)`));
  return match ? match[1].trim() : "";
}

function summarizeUnit(unit) {
  if (unit.prefix === "QST") return unit.fieldValue("question_text") || unit.section("核心内容");
  if (unit.prefix === "CON") return unit.fieldValue("concept_definition") || unit.section("核心内容");
  if (unit.prefix === "OPI") return unit.fieldValue("core_claim") || unit.section("核心内容");
  if (unit.prefix === "CAS") return unit.fieldValue("case_summary") || unit.section("核心内容");
  if (unit.prefix === "SOL") return unit.fieldValue("solution_summary") || unit.section("核心内容");
  return unit.section("核心内容");
}

function oneLine(text) {
  return String(text || "").replace(/\s+/g, " ").trim();
}

function tokenize(text) {
  const normalized = String(text || "").toLowerCase().trim();
  const parts = normalized
    .replace(/[^\p{Script=Han}a-z0-9]+/gu, " ")
    .split(/\s+/)
    .map((item) => item.trim())
    .filter(Boolean);

  const tokens = new Set();
  for (const part of parts) {
    if (part.length >= 2) tokens.add(part);
    if (/^\p{Script=Han}+$/u.test(part)) {
      for (let size = 2; size <= 3; size += 1) {
        if (part.length < size) continue;
        for (let i = 0; i <= part.length - size; i += 1) {
          tokens.add(part.slice(i, i + size));
        }
      }
    }
  }

  return [...tokens];
}

function normalizeAssemblyTitle(title) {
  return String(title || "")
    .replace(/（[^）]*）/g, " ")
    .replace(/\([^)]*\)/g, " ")
    .replace(/自动推荐版|结构化重组版|调试/g, " ")
    .replace(/\s+/g, " ")
    .trim();
}

function expandIntentTokens(title, query) {
  const source = `${normalizeAssemblyTitle(title)} ${query || ""}`;
  const extras = [];

  if (/年轻人/.test(source) && /赚钱|变现|收入/.test(source)) {
    extras.push("兴趣", "变现", "需求", "生意", "具体业务", "老板思维", "生产型兴趣");
  }

  if (/赚钱|变现|收入/.test(source) && !/被动收入|系统赚钱/.test(source)) {
    extras.push("需求", "变现", "生意");
  }

  if (/兴趣/.test(source) && /赚钱|变现/.test(source)) {
    extras.push("生产型兴趣", "具体业务", "能力");
  }

  if (/创业|生意/.test(source)) {
    extras.push("需求", "具体生意", "从右到左");
  }

  return tokenize(extras.join(" "));
}

function findUnitFile(ref) {
  const normalized = ref.replace(/^\[\[|\]\]$/g, "").replace(/\.md$/i, "");
  for (const dir of Object.values(typeDirs)) {
    const direct = path.join(unitRoot, dir, `${normalized}.md`);
    if (fs.existsSync(direct)) return direct;
  }

  if (!normalized.includes("_")) {
    for (const dir of Object.values(typeDirs)) {
      const fullDir = path.join(unitRoot, dir);
      if (!fs.existsSync(fullDir)) continue;
      for (const entry of fs.readdirSync(fullDir)) {
        if (!entry.endsWith(".md")) continue;
        if (!entry.startsWith(`${normalized}_`)) continue;
        return path.join(fullDir, entry);
      }
    }
  }

  fail(`找不到内容单元：${ref}`);
}

function loadUnit(ref) {
  const filePath = findUnitFile(ref);
  const content = fs.readFileSync(filePath, "utf8");
  const frontmatter = readFrontmatter(content);
  const body = readBody(content);
  const id = getField(frontmatter, "id");
  const title = getField(frontmatter, "title");
  const prefix = id.split("-")[0];
  const basename = path.basename(filePath, ".md");
  return {
    id,
    prefix,
    title,
    basename,
    filePath,
    fieldValue(field) {
      return getField(frontmatter, field);
    },
    listField(field) {
      return getListField(frontmatter, field);
    },
    relationshipTargets() {
      return getRelationshipTargets(frontmatter);
    },
    section(heading) {
      return getSection(body, heading);
    },
    summary: summarizeUnit({
      prefix,
      fieldValue: (field) => getField(frontmatter, field),
      section: (heading) => getSection(body, heading),
    }),
  };
}

function loadAllUnits() {
  const units = [];
  for (const dir of Object.values(typeDirs)) {
    const fullDir = path.join(unitRoot, dir);
    if (!fs.existsSync(fullDir)) continue;
    for (const entry of fs.readdirSync(fullDir)) {
      if (!entry.endsWith(".md")) continue;
      units.push(loadUnit(path.basename(entry, ".md")));
    }
  }
  return units;
}

function buildIntentProfile(title, query) {
  const source = `${normalizeAssemblyTitle(title)} ${query || ""}`;
  return {
    money: /赚钱|变现|收入|生意/.test(source),
    young: /年轻人/.test(source),
    interest: /兴趣|爱好/.test(source) || (/年轻人/.test(source) && /赚钱|变现|收入/.test(source)),
    demand: /需求|老板思维|创业|生意|业务/.test(source) || (/赚钱|变现|收入/.test(source) && /年轻人|创业|生意/.test(source)),
    business: /生意|业务|创业/.test(source) || /赚钱|变现|收入/.test(source),
    passive: /被动收入|系统赚钱/.test(source),
    stability: /稳定|反脆弱/.test(source),
  };
}

function unitText(unit) {
  return [
    unit.title,
    unit.summary,
    unit.fieldValue("question_text"),
    unit.fieldValue("core_claim"),
    unit.fieldValue("case_summary"),
    unit.fieldValue("case_result"),
    unit.fieldValue("solution_summary"),
    unit.listField("themes").join(" "),
    unit.listField("keywords").join(" "),
    unit.listField("applicable_topics").join(" "),
  ]
    .filter(Boolean)
    .join(" ");
}

function hasThemeSignal(unit, pattern) {
  return pattern.test(unitText(unit));
}

function getThemes(unit) {
  return unit.listField("themes").map((item) => item.trim()).filter(Boolean);
}

function sharesTheme(a, b) {
  const aThemes = new Set(getThemes(a));
  const bThemes = getThemes(b);
  return bThemes.some((theme) => aThemes.has(theme));
}

function scoreIntentAlignment(unit, intentProfile) {
  const text = unitText(unit);
  let score = 0;

  if (intentProfile.money && /赚钱|变现|收入|生意|需求|业务/.test(text)) score += 4;

  if (intentProfile.interest) {
    if (/兴趣|生产型兴趣|消费型兴趣/.test(text)) score += 6;
    if (unit.prefix === "QST" && /什么样的兴趣|兴趣.*变现|变现.*兴趣/.test(text)) score += 10;
    if (unit.prefix === "CON" && /生产型兴趣|消费型兴趣/.test(text)) score += 12;
    if (unit.prefix === "SOL" && /兴趣变现|生产性|具体业务/.test(text)) score += 8;
  }

  if (intentProfile.demand) {
    if (/需求|老板思维|从需求倒推|从右到左|具体业务/.test(text)) score += 8;
    if (unit.prefix === "OPI" && /先看需求|老板思维|思维顺序错了|从需求出发|倒推产品/.test(text)) score += 20;
    if (unit.prefix === "QST" && /能力.*变现|赚不到钱|需求倒推/.test(text)) score += 6;
    if (unit.prefix === "SOL" && /从需求出发|对标|倒推/.test(text)) score += 7;
    if (unit.prefix === "CAS" && /柠檬水|需求先于原料/.test(text)) score += 5;
  }

  if (intentProfile.young && intentProfile.money) {
    if (unit.prefix === "QST" && /什么样的兴趣能真正变现/.test(text)) score += 8;
    if (unit.prefix === "OPI" && /先看需求|能力不够|老板/.test(text)) score += 12;
  }

  if (intentProfile.passive) {
    if (/被动收入|系统赚钱/.test(text)) score += 10;
  }

  if (intentProfile.stability) {
    if (/稳定|反脆弱|保险/.test(text)) score += 8;
  }

  if (unit.prefix === "OPI" && /为什么要找对标/.test(unit.title)) score -= 8;
  if (unit.prefix === "OPI" && /问题：|答案：|逻辑：/.test(text)) score -= 5;

  return score;
}

function scoreUnit(unit, primaryTokens, queryTokens, intentProfile) {
  const titleTokens = tokenize(unit.title);
  const keywordTokens = tokenize(unit.listField("keywords").join(" "));
  const themeTokens = tokenize(unit.listField("themes").join(" "));
  const summaryTokens = tokenize(unit.summary);
  const applicableTokens = tokenize(unit.listField("applicable_topics").join(" "));
  const pool = [
    ...titleTokens,
    ...keywordTokens,
    ...themeTokens,
    ...summaryTokens,
    ...applicableTokens,
  ];
  const poolSet = new Set(pool);

  let score = 0;
  for (const token of primaryTokens) {
    if (titleTokens.includes(token)) score += 14;
    if (keywordTokens.includes(token)) score += 9;
    if (themeTokens.includes(token)) score += 7;
    if (applicableTokens.includes(token)) score += 5;
    if (summaryTokens.includes(token)) score += 4;
    if (poolSet.has(token)) score += 2;
  }

  for (const token of queryTokens) {
    if (titleTokens.includes(token)) score += 8;
    if (keywordTokens.includes(token)) score += 5;
    if (themeTokens.includes(token)) score += 4;
    if (applicableTokens.includes(token)) score += 3;
    if (summaryTokens.includes(token)) score += 2;
    if (poolSet.has(token)) score += 1;
  }

  if (unit.prefix === "QST" && /怎么|如何|为什么|能不能|赚钱|变现|收入|生意/.test(unit.title + unit.summary)) score += 2;
  if (unit.prefix === "SOL" && /路径|方案|步骤|检查法|方法/.test(unit.title + unit.summary)) score += 2;
  if (unit.prefix === "CAS" && /案例|证明|过程|结果|数据/.test(unit.summary)) score += 1;
  if (unit.prefix === "OPI" && /本质|核心|判断|不要|先/.test(unit.summary)) score += 1;

  if (/概念图谱|用途：|底层概念坐标系|关键概念$|核心问题$|核心观点$|关键案例$|可执行方案$/.test(unit.title + " " + unit.summary)) {
    score -= 10;
  }

  if (unit.prefix === "QST" && !/[？?]|为什么|如何|怎么|能不能|怎样/.test(unit.fieldValue("question_text") || unit.summary)) {
    score -= 6;
  }

  if (unit.prefix === "OPI" && !/本质|核心|不要|先|应该|不是|而是|判断|根本/.test(unit.fieldValue("core_claim") || unit.summary)) {
    score -= 4;
  }

  if (unit.prefix === "CAS" && !/案例|过程|结果|证明|数据|月均|粉丝|播放|增长|收益/.test(unit.fieldValue("case_summary") + " " + unit.fieldValue("case_result") + " " + unit.summary)) {
    score -= 4;
  }

  if (unit.prefix === "SOL" && !/步骤|方案|路径|检查法|先|再|最后/.test(unit.fieldValue("solution_summary") + " " + unit.summary)) {
    score -= 4;
  }

  score += scoreIntentAlignment(unit, intentProfile);
  return score;
}

function scoreMainSelection(unit, prefix, intentProfile, context) {
  const text = unitText(unit);
  const targets = unit.relationshipTargets();
  let score = 0;
  const isHybridMoneyTopic =
    intentProfile.young && intentProfile.money && intentProfile.interest && intentProfile.demand;

  if (context.mainQuestion) {
    if (targets.includes(context.mainQuestion.id)) score += isHybridMoneyTopic && prefix === "OPI" ? 6 : 18;
    if (sharesTheme(unit, context.mainQuestion)) score += 6;
  }

  if (context.mainConcept) {
    if (targets.includes(context.mainConcept.id)) score += 10;
    if (sharesTheme(unit, context.mainConcept)) score += 5;
  }

  if (context.mainOpinion) {
    if (targets.includes(context.mainOpinion.id)) score += 20;
    if (sharesTheme(unit, context.mainOpinion)) score += 6;
  }

  if (prefix === "QST") {
    if (intentProfile.money && intentProfile.interest && /什么样的兴趣能真正变现/.test(text)) score += 18;
    if (intentProfile.demand && !intentProfile.interest && /为什么能力强的人离开公司后仍然赚不到钱/.test(text)) score += 18;
    if (intentProfile.demand && /能力怎么变现|老板思维|需求倒推/.test(text)) score += 8;
  }

  if (prefix === "CON") {
    if (intentProfile.interest && /生产型兴趣|消费型兴趣/.test(text)) score += 18;
    if (intentProfile.demand && !intentProfile.interest && /员工思维|老板思维/.test(text)) score += 18;
    if (intentProfile.money && intentProfile.young && /生产型兴趣|消费型兴趣/.test(text)) score += 10;
  }

  if (prefix === "OPI") {
    if (intentProfile.money && intentProfile.demand && /先看需求|老板思维|从需求出发|倒推产品/.test(text)) score += 24;
    if (intentProfile.interest && !intentProfile.demand && /兴趣能不能变现|生产型兴趣/.test(text)) score += 16;
    if (isHybridMoneyTopic) {
      if (/先看需求|老板思维|从需求出发|倒推产品/.test(text)) score += 48;
      if (/兴趣能不能变现，不取决于兴趣这个标签本身/.test(text)) score -= 20;
    }
    if (/为什么要找对标/.test(unit.title)) score -= 10;
    if (/为什么别人做不了答疑群/.test(unit.title) && intentProfile.demand) score -= 8;
  }

  if (prefix === "CAS") {
    if (intentProfile.money && intentProfile.demand && /需求先于原料|先写课程大纲|需求先于产品/.test(text)) score += 14;
    if (intentProfile.interest && /公开输出|数据验证/.test(text)) score += 10;
    if (intentProfile.young && intentProfile.money && intentProfile.demand && /需求先于原料|需求先于产品/.test(text)) score += 8;
  }

  if (prefix === "SOL") {
    if (intentProfile.interest && /兴趣变现三要素|生产性|具体业务/.test(text)) score += 14;
    if (intentProfile.demand && /从需求出发|对标|倒推/.test(text)) score += 14;
    if (intentProfile.young && intentProfile.money && intentProfile.demand && /从需求出发|倒推/.test(text)) score += 10;
    if (context.mainOpinion && targets.includes(context.mainOpinion.id)) score += 12;
  }

  return score;
}

function isHybridMoneyTopic(intentProfile) {
  return intentProfile.young && intentProfile.money && intentProfile.interest && intentProfile.demand;
}

function isDemandDrivenOpinion(unit) {
  return /先看需求|老板思维|从需求出发|倒推产品/.test(unitText(unit));
}

function isDemandDrivenSolution(unit) {
  return /从需求出发|先看需求|从右到左|对标|倒推/.test(unitText(unit));
}

function rankUnitsForType(candidates, prefix, topPerType, intentProfile, context = {}) {
  if (candidates.length === 0) return [];

  const sorted = [...candidates].sort((a, b) => {
    if (b.score !== a.score) return b.score - a.score;
    return a.unit.title.localeCompare(b.unit.title, "zh-Hans-CN");
  });

  const mainSorted = [...sorted].sort((a, b) => {
    const aScore = a.score + scoreMainSelection(a.unit, prefix, intentProfile, context);
    const bScore = b.score + scoreMainSelection(b.unit, prefix, intentProfile, context);
    if (bScore !== aScore) return bScore - aScore;
    return a.unit.title.localeCompare(b.unit.title, "zh-Hans-CN");
  });

  let primaryUnit = mainSorted[0].unit;

  if (prefix === "OPI" && isHybridMoneyTopic(intentProfile)) {
    const demandDriven = mainSorted.find((item) => isDemandDrivenOpinion(item.unit));
    if (demandDriven) primaryUnit = demandDriven.unit;
  }

  if (prefix === "SOL" && isHybridMoneyTopic(intentProfile) && context.mainOpinion && isDemandDrivenOpinion(context.mainOpinion)) {
    const demandDriven = mainSorted.find((item) => isDemandDrivenSolution(item.unit));
    if (demandDriven) primaryUnit = demandDriven.unit;
  }

  const selected = [primaryUnit];
  const remaining = sorted.slice(1).map((item) => {
    let bonus = 0;
    const primary = selected[0];

    if (!sharesTheme(item.unit, primary)) bonus += 3;

    if (intentProfile.money && intentProfile.demand) {
      if (prefix === "OPI" && hasThemeSignal(primary, /兴趣|生产型兴趣/) && hasThemeSignal(item.unit, /需求|老板思维|从需求倒推/)) {
        bonus += 8;
      }
      if (prefix === "SOL" && hasThemeSignal(item.unit, /从需求出发|对标|倒推/)) {
        bonus += 4;
      }
      if (prefix === "CAS" && hasThemeSignal(item.unit, /需求先于原料|数据验证|公开输出/)) {
        bonus += 3;
      }
    }

    return { ...item, score: item.score + bonus };
  });

  remaining.sort((a, b) => {
    if (b.score !== a.score) return b.score - a.score;
    return a.unit.title.localeCompare(b.unit.title, "zh-Hans-CN");
  });

  for (const item of remaining) {
    if (selected.length >= topPerType) break;
    if (selected.some((unit) => unit.id === item.unit.id)) continue;
    selected.push(item.unit);
  }

  return selected;
}

function recommendUnitsByQuery(title, query, topPerType = 3) {
  const primaryTokens = tokenize(normalizeAssemblyTitle(title));
  const queryTokens = tokenize(query);
  const intentTokens = expandIntentTokens(title, query);
  const intentProfile = buildIntentProfile(title, query);
  if (queryTokens.length === 0 && primaryTokens.length === 0) fail("query 和 title 不能同时为空");
  const allUnits = loadAllUnits();
  const grouped = { QST: [], CON: [], OPI: [], CAS: [], SOL: [] };

  for (const unit of allUnits) {
    const summary = `${unit.summary} ${unit.fieldValue("question_text")} ${unit.fieldValue("core_claim")} ${unit.fieldValue("case_summary")} ${unit.fieldValue("solution_summary")}`;
    if (/概念图谱/.test(unit.title) || /^> 用途：/.test(summary) || /底层概念坐标系/.test(summary)) continue;
    if (/ 的关键概念$| 的核心问题$| 的核心观点$| 的关键案例$| 的可执行方案$/.test(unit.title)) continue;
    const score = scoreUnit(unit, [...primaryTokens, ...intentTokens], queryTokens, intentProfile);
    if (score <= 0) continue;
    grouped[unit.prefix].push({ unit, score });
  }

  const context = {};
  grouped.QST = rankUnitsForType(grouped.QST, "QST", topPerType, intentProfile, context);
  context.mainQuestion = grouped.QST[0];
  grouped.CON = rankUnitsForType(grouped.CON, "CON", topPerType, intentProfile, context);
  context.mainConcept = grouped.CON[0];
  grouped.OPI = rankUnitsForType(grouped.OPI, "OPI", topPerType, intentProfile, context);
  context.mainOpinion = grouped.OPI[0];
  grouped.CAS = rankUnitsForType(grouped.CAS, "CAS", topPerType, intentProfile, context);
  grouped.SOL = rankUnitsForType(grouped.SOL, "SOL", topPerType, intentProfile, context);

  return grouped;
}

function formatLinks(units) {
  return units.length > 0 ? units.map((unit) => `[[${unit.basename}]]`).join("、") : "暂无";
}

function buildAssembly(args) {
  const title = args.title;
  let questionUnits = splitList(args.questions || args.question).map(loadUnit);
  let conceptUnits = splitList(args.concepts || args.concept).map(loadUnit);
  let opinionUnits = splitList(args.opinions || args.opinion).map(loadUnit);
  let caseUnits = splitList(args.cases || args.case).map(loadUnit);
  let solutionUnits = splitList(args.solutions || args.solution).map(loadUnit);

  if (args.query || args.auto) {
    const recommended = recommendUnitsByQuery(args.title, args.query || "", Number(args.top || 3));
    if (questionUnits.length === 0) questionUnits = recommended.QST;
    if (conceptUnits.length === 0) conceptUnits = recommended.CON;
    if (opinionUnits.length === 0) opinionUnits = recommended.OPI;
    if (caseUnits.length === 0) caseUnits = recommended.CAS;
    if (solutionUnits.length === 0) solutionUnits = recommended.SOL;
  }

  if (questionUnits.length === 0) fail("至少提供 1 个问题单元：--question 或 --questions");
  if (conceptUnits.length === 0) fail("至少提供 1 个概念单元：--concept 或 --concepts");
  if (opinionUnits.length === 0) fail("至少提供 1 个观点单元：--opinion 或 --opinions");
  if (caseUnits.length === 0) fail("至少提供 1 个案例单元：--case 或 --cases");
  if (solutionUnits.length === 0) fail("至少提供 1 个方案单元：--solution 或 --solutions");

  const mainQuestion = questionUnits[0];
  const mainConcept = conceptUnits[0];
  const mainOpinion = opinionUnits[0];
  const mainCase = caseUnits[0];
  const mainSolution = solutionUnits[0];

  const audience =
    args.audience ||
    "对赚钱这件事有真实焦虑，但还没有把兴趣、需求、能力和业务接成一条完整路径的人";
  const assemblyReason =
    args.reason ||
    `这组装配先用「${oneLine(mainQuestion.summary)}」界定问题，再用「${oneLine(mainOpinion.summary)}」给出判断边界，然后用案例把判断落地，最后用方案把下一步动作写清楚。`;
  const closing =
    args.closing ||
    "把抽象的赚钱焦虑，改造成可以拆解、可以验证、可以继续重组的内容结构";

  const lines = [
    `# 选题装配：${title}`,
    "",
    "## 目标受众",
    "",
    audience,
    "",
    "## 装配理由",
    "",
    assemblyReason,
    "",
    "## 核心调用单元",
    "",
    "### 问题",
    "",
    `- [[${mainQuestion.basename}]]`,
    "",
    "### 概念",
    "",
    `- [[${mainConcept.basename}]]`,
    "",
    "### 观点",
    "",
    `- [[${mainOpinion.basename}]]`,
    "",
    "### 案例",
    "",
    `- [[${mainCase.basename}]]`,
    "",
    "### 方案",
    "",
    `- [[${mainSolution.basename}]]`,
    "",
    "## 可追加调用单元",
    "",
    `- 补充问题：${formatLinks(questionUnits.slice(1))}`,
    `- 补充概念：${formatLinks(conceptUnits.slice(1))}`,
    `- 补充观点：${formatLinks(opinionUnits.slice(1))}`,
    `- 补充案例：${formatLinks(caseUnits.slice(1))}`,
    `- 补充方案：${formatLinks(solutionUnits.slice(1))}`,
    "",
    "## 建议结构",
    "",
    `1. 痛点：${oneLine(mainQuestion.summary)}`,
    `2. 冲突：${oneLine(mainOpinion.summary)}`,
    `3. 展开：${oneLine(mainConcept.summary)}`,
    `4. 案例：${oneLine(mainCase.summary)}`,
    `5. 方法：${oneLine(mainSolution.summary)}`,
    `6. 收束：${closing}`,
    "",
    "## 表达骨架",
    "",
    `### 开头\n\n${oneLine(mainQuestion.summary)}`,
    "",
    `### 中段 1\n\n${oneLine(mainConcept.summary)}`,
    "",
    `### 中段 2\n\n${oneLine(mainOpinion.summary)}`,
    "",
    `### 中段 3\n\n${oneLine(mainSolution.summary)}`,
    "",
    `### 结尾\n\n${closing}`,
    "",
    "## 备注",
    "",
    `- 来源单元：${[...questionUnits, ...conceptUnits, ...opinionUnits, ...caseUnits, ...solutionUnits]
      .map((unit) => `[[${unit.basename}]]`)
      .join("、")}`,
    args.query ? `- 查询词：${args.query}` : null,
    `- 生成时间：${new Intl.DateTimeFormat("en-CA", {
      timeZone: "Asia/Shanghai",
      year: "numeric",
      month: "2-digit",
      day: "2-digit",
    }).format(new Date())}`,
  ].filter(Boolean);

  ensureDir(assemblyRoot);
  const datePrefix = new Intl.DateTimeFormat("en-CA", {
    timeZone: "Asia/Shanghai",
    year: "numeric",
    month: "2-digit",
    day: "2-digit",
  }).format(new Date());
  const target = path.join(assemblyRoot, `${datePrefix}_${slugFromTitle(title)}_装配稿.md`);
  fs.writeFileSync(target, lines.join("\n") + "\n");
  console.log(target);
}

const args = parseArgs(process.argv.slice(2));
if (!args.title) fail("缺少标题：--title");

buildAssembly(args);

#!/usr/bin/env node

const fs = require("fs");
const path = require("path");

const root = path.resolve(process.cwd());
const unitRoot = path.join(root, "02-内容单元库");
const targetRoots = [
  path.join(root, "02-内容单元库"),
  path.join(root, "05-主题地图"),
  path.join(root, "06-选题装配"),
];
const codeFencePattern = /```[\s\S]*?```/g;
const associationSectionPattern = /\n## 关联单元\n([\s\S]*?)(\n## |\s*$)/;

function walkMarkdownFiles(dir) {
  if (!fs.existsSync(dir)) return [];
  const files = [];
  for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
    const full = path.join(dir, entry.name);
    if (entry.isDirectory()) files.push(...walkMarkdownFiles(full));
    else if (entry.isFile() && path.extname(entry.name).toLowerCase() === ".md") files.push(full);
  }
  return files;
}

function extractFrontmatter(content) {
  const match = content.match(/^(---\n[\s\S]*?\n---\n?)([\s\S]*)$/);
  if (!match) return { frontmatter: "", body: content };
  return { frontmatter: match[1], body: match[2] };
}

function getId(frontmatter) {
  const match = frontmatter.match(/^id:\s*(.+)$/m);
  return match ? match[1].trim() : "";
}

function getRelationshipTargets(frontmatter) {
  return [...frontmatter.matchAll(/^\s*target:\s*(\S+)\s*$/gm)].map((match) => match[1]);
}

const idToLink = new Map();
for (const file of walkMarkdownFiles(unitRoot)) {
  const content = fs.readFileSync(file, "utf8");
  const { frontmatter } = extractFrontmatter(content);
  const id = getId(frontmatter);
  if (!id) continue;
  idToLink.set(id, `[[${path.basename(file, ".md")}]]`);
}

let changedFiles = 0;
let changedLinks = 0;
let syncedAssociationFiles = 0;
let syncedAssociationLinks = 0;

function replaceLinksInBody(body) {
  const codeFences = [];
  const bodyWithoutCode = body.replace(codeFencePattern, (block) => {
    const token = `__CODE_FENCE_${codeFences.length}__`;
    codeFences.push(block);
    return token;
  });

  let nextBody = bodyWithoutCode;

  for (const [id, link] of idToLink.entries()) {
    const escapedId = id.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
    const backtickPattern = new RegExp("`" + escapedId + "`", "g");
    const barePattern = new RegExp(`(^|[^\\w\\[\\]])(${escapedId})(?=$|[^\\w_])`, "gm");

    const backtickMatches = nextBody.match(backtickPattern);
    if (backtickMatches) {
      changedLinks += backtickMatches.length;
      nextBody = nextBody.replace(backtickPattern, link);
    }

    const bareMatches = [...nextBody.matchAll(barePattern)].filter(([fullMatch]) => !fullMatch.includes(`[[${id}_`));
    if (bareMatches.length > 0) {
      changedLinks += bareMatches.length;
      nextBody = nextBody.replace(barePattern, (_, prefix, matchedId) => `${prefix}${idToLink.get(matchedId)}`);
    }
  }

  return nextBody.replace(/__CODE_FENCE_(\d+)__/g, (_, index) => codeFences[Number(index)]);
}

function syncAssociationSection(frontmatter, body) {
  const targets = getRelationshipTargets(frontmatter)
    .map((targetId) => idToLink.get(targetId))
    .filter(Boolean);

  if (targets.length === 0) return body;

  const uniqueTargets = [...new Set(targets)];
  const match = body.match(associationSectionPattern);
  if (!match) {
    syncedAssociationFiles += 1;
    syncedAssociationLinks += uniqueTargets.length;
    const trimmedBody = body.replace(/\s*$/, "");
    return `${trimmedBody}\n\n## 关联单元\n\n${uniqueTargets.map((link) => `- ${link}`).join("\n")}\n`;
  }

  const sectionContent = match[1];
  const existingLinks = [...sectionContent.matchAll(/\[\[([^\]]+)\]\]/g)].map((item) => `[[${item[1]}]]`);
  const missingLinks = uniqueTargets.filter((link) => !existingLinks.includes(link));

  if (missingLinks.length === 0) return body;

  const nextSectionContent = `${sectionContent}${missingLinks.map((link) => `- ${link}\n`).join("")}`;
  syncedAssociationFiles += 1;
  syncedAssociationLinks += missingLinks.length;
  return body.replace(associationSectionPattern, `\n## 关联单元\n${nextSectionContent}${match[2]}`);
}

for (const dir of targetRoots) {
  for (const file of walkMarkdownFiles(dir)) {
    const content = fs.readFileSync(file, "utf8");
    const { frontmatter, body } = extractFrontmatter(content);
    let nextBody = replaceLinksInBody(body);

    if (file.startsWith(unitRoot)) {
      nextBody = syncAssociationSection(frontmatter, nextBody);
    }

    if (nextBody === body) continue;
    fs.writeFileSync(file, `${frontmatter}${nextBody}`);
    changedFiles += 1;
  }
}

console.log(JSON.stringify({
  changedFiles,
  changedLinks,
  syncedAssociationFiles,
  syncedAssociationLinks,
}, null, 2));

#!/usr/bin/env node

const fs = require("fs");
const path = require("path");

const root = path.resolve(process.cwd());
const unitRoot = path.join(root, "02-内容单元库");
const outputDir = path.join(root, "03-处理状态");
const csvOutput = path.join(outputDir, "去重候选索引.csv");
const summaryOutput = path.join(outputDir, "去重与冲突总览.md");
const auditOutput = path.join(outputDir, "去重与冲突审计.csv");
const manualCandidateInput = path.join(outputDir, "人工去重候选.csv");
const today = new Intl.DateTimeFormat("en-CA", {
  timeZone: "Asia/Shanghai",
  year: "numeric",
  month: "2-digit",
  day: "2-digit",
}).format(new Date());

function walkFiles(dir) {
  if (!fs.existsSync(dir)) return [];
  const files = [];
  for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
    const full = path.join(dir, entry.name);
    if (entry.isDirectory()) files.push(...walkFiles(full));
    else if (entry.isFile() && path.extname(entry.name).toLowerCase() === ".md") files.push(full);
  }
  return files;
}

function extractFrontmatter(content) {
  const match = content.match(/^---\n([\s\S]*?)\n---\n?/);
  return match ? match[1] : "";
}

function getScalar(frontmatter, field) {
  const escaped = field.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
  const match = frontmatter.match(new RegExp(`^${escaped}:\\s*(.+)$`, "m"));
  return match ? match[1].trim() : "";
}

function getList(frontmatter, field) {
  const lines = frontmatter.split("\n");
  const start = lines.findIndex((line) => line.trim() === `${field}:`);
  if (start === -1) return [];

  const items = [];
  for (let i = start + 1; i < lines.length; i += 1) {
    const line = lines[i];
    if (!line.startsWith("  - ")) break;
    items.push(line.replace("  - ", "").trim());
  }
  return items;
}

function getRelationships(frontmatter) {
  const lines = frontmatter.split("\n");
  const relationships = [];
  let inRelationships = false;
  let current = null;

  for (const line of lines) {
    if (!inRelationships) {
      if (line.trim() === "relationships:") inRelationships = true;
      continue;
    }

    if (!line.startsWith("  ")) break;

    const trimmed = line.trim();
    if (trimmed === "[]") break;

    const typeMatch = trimmed.match(/^- type:\s*(.+)$/);
    if (typeMatch) {
      current = { type: typeMatch[1].trim(), target: "", note: "" };
      relationships.push(current);
      continue;
    }

    if (!current) continue;

    const targetMatch = trimmed.match(/^target:\s*(.+)$/);
    if (targetMatch) {
      current.target = targetMatch[1].trim();
      continue;
    }

    const noteMatch = trimmed.match(/^note:\s*(.+)$/);
    if (noteMatch) current.note = noteMatch[1].trim();
  }

  return relationships;
}

function uniqueIntersection(a, b) {
  const bSet = new Set(b);
  return [...new Set(a.filter((item) => bSet.has(item)))];
}

function normalizeText(text) {
  return text.replace(/[^\p{Script=Han}A-Za-z0-9]+/gu, "");
}

function uniqueChars(text) {
  return [...new Set(normalizeText(text).split(""))].filter(Boolean);
}

function titleSimilarity(a, b) {
  const aChars = uniqueChars(a);
  const bChars = uniqueChars(b);
  if (aChars.length === 0 || bChars.length === 0) return 0;
  const shared = uniqueIntersection(aChars, bChars).length;
  return shared / Math.max(aChars.length, bChars.length);
}

function escapeCsv(value) {
  return `"${String(value ?? "").replaceAll("\"", "\"\"")}"`;
}

function parseCsvLine(line) {
  const cells = [];
  let current = "";
  let inQuotes = false;
  for (let i = 0; i < line.length; i += 1) {
    const ch = line[i];
    if (ch === "\"") {
      if (inQuotes && line[i + 1] === "\"") {
        current += "\"";
        i += 1;
      } else {
        inQuotes = !inQuotes;
      }
    } else if (ch === "," && !inQuotes) {
      cells.push(current);
      current = "";
    } else {
      current += ch;
    }
  }
  cells.push(current);
  return cells;
}

function pairKey(a, b) {
  return [a, b].sort().join("::");
}

function loadExistingReviews() {
  const reviews = new Map();
  if (!fs.existsSync(csvOutput)) return reviews;

  const lines = fs.readFileSync(csvOutput, "utf8").trim().split("\n");
  if (lines.length <= 1) return reviews;

  const header = parseCsvLine(lines[0]);
  const indexByName = Object.fromEntries(header.map((name, index) => [name, index]));

  for (const line of lines.slice(1)) {
    if (!line.trim()) continue;
    const cells = parseCsvLine(line);
    const unitA = cells[indexByName.unit_a_id];
    const unitB = cells[indexByName.unit_b_id];
    const status = cells[indexByName.status] || "待人工判断";
    const note = cells[indexByName.note] || "";
    reviews.set(pairKey(unitA, unitB), { status, note });
  }

  return reviews;
}

function loadManualCandidates() {
  const manual = new Map();
  if (!fs.existsSync(manualCandidateInput)) return manual;

  const lines = fs.readFileSync(manualCandidateInput, "utf8").trim().split("\n");
  if (lines.length <= 1) return manual;

  const header = parseCsvLine(lines[0]);
  const indexByName = Object.fromEntries(header.map((name, index) => [name, index]));

  for (const line of lines.slice(1)) {
    if (!line.trim()) continue;
    const cells = parseCsvLine(line);
    const unitA = cells[indexByName.unit_a_id];
    const unitB = cells[indexByName.unit_b_id];
    if (!unitA || !unitB) continue;
    manual.set(pairKey(unitA, unitB), {
      reason: cells[indexByName.reason] || "人工补充候选",
      status: cells[indexByName.status] || "待人工判断",
      note: cells[indexByName.note] || "",
    });
  }

  return manual;
}

const units = walkFiles(unitRoot).map((file) => {
  const content = fs.readFileSync(file, "utf8");
  const frontmatter = extractFrontmatter(content);
  return {
    id: getScalar(frontmatter, "id"),
    type: getScalar(frontmatter, "type"),
    title: getScalar(frontmatter, "title"),
    relPath: path.relative(root, file).replaceAll(path.sep, "/"),
    themes: getList(frontmatter, "themes"),
    keywords: getList(frontmatter, "keywords"),
    sourceDocuments: getList(frontmatter, "source_documents"),
    relationships: getRelationships(frontmatter),
  };
}).filter((unit) => unit.id && unit.type && unit.title);

const unitById = new Map(units.map((unit) => [unit.id, unit]));
const candidates = [];
const existingReviews = loadExistingReviews();
const manualCandidates = loadManualCandidates();
const seenPairs = new Set();

for (let i = 0; i < units.length; i += 1) {
  for (let j = i + 1; j < units.length; j += 1) {
    const a = units[i];
    const b = units[j];

    if (a.type !== b.type) continue;

    const sharedThemes = uniqueIntersection(a.themes, b.themes);
    const sharedKeywords = uniqueIntersection(a.keywords, b.keywords);
    const sharedSources = uniqueIntersection(a.sourceDocuments, b.sourceDocuments);
    const similarity = titleSimilarity(a.title, b.title);
    const score = sharedThemes.length * 3 + sharedKeywords.length * 2 + sharedSources.length * 2 + Math.round(similarity * 10);

    const isCandidate =
      (sharedThemes.length >= 1 && sharedKeywords.length >= 1) ||
      (sharedSources.length >= 1 && (sharedThemes.length >= 1 || sharedKeywords.length >= 1)) ||
      (similarity >= 0.35 && (sharedThemes.length >= 1 || sharedKeywords.length >= 1 || sharedSources.length >= 1));

    if (!isCandidate) continue;

    let candidateType = "近似重复候选";
    if (sharedSources.length > 0 && sharedThemes.length > 0 && (sharedKeywords.length >= 1 || similarity >= 0.45)) {
      candidateType = "同义重复候选";
    }

    const review = existingReviews.get(pairKey(a.id, b.id)) || { status: "待人工判断", note: "" };
    const key = pairKey(a.id, b.id);
    seenPairs.add(key);

    candidates.push({
      unit_a_id: a.id,
      unit_a_type: a.type,
      unit_a_title: a.title,
      unit_b_id: b.id,
      unit_b_type: b.type,
      unit_b_title: b.title,
      shared_themes: sharedThemes.join(" | "),
      shared_keywords: sharedKeywords.join(" | "),
      shared_sources: sharedSources.join(" | "),
      title_similarity: similarity.toFixed(2),
      score,
      candidate_type: candidateType,
      status: review.status,
      note: review.note,
      candidate_reason: "自动识别",
      unit_a_file: a.relPath,
      unit_b_file: b.relPath,
    });
  }
}

for (const [key, manual] of manualCandidates.entries()) {
  if (seenPairs.has(key)) continue;
  const [unitAId, unitBId] = key.split("::");
  const a = unitById.get(unitAId);
  const b = unitById.get(unitBId);
  if (!a || !b) continue;

  const sharedThemes = uniqueIntersection(a.themes, b.themes);
  const sharedKeywords = uniqueIntersection(a.keywords, b.keywords);
  const sharedSources = uniqueIntersection(a.sourceDocuments, b.sourceDocuments);
  const similarity = titleSimilarity(a.title, b.title);

  candidates.push({
    unit_a_id: a.id,
    unit_a_type: a.type,
    unit_a_title: a.title,
    unit_b_id: b.id,
    unit_b_type: b.type,
    unit_b_title: b.title,
    shared_themes: sharedThemes.join(" | "),
    shared_keywords: sharedKeywords.join(" | "),
    shared_sources: sharedSources.join(" | "),
    title_similarity: similarity.toFixed(2),
    score: -1,
    candidate_type: "人工补充候选",
    status: manual.status,
    note: manual.note,
    candidate_reason: manual.reason,
    unit_a_file: a.relPath,
    unit_b_file: b.relPath,
  });
}

candidates.sort((a, b) => {
  if (b.score !== a.score) return b.score - a.score;
  const byType = a.unit_a_type.localeCompare(b.unit_a_type, "zh-Hans-CN");
  if (byType !== 0) return byType;
  return a.unit_a_id.localeCompare(b.unit_a_id, "zh-Hans-CN");
});

const rows = [
  [
    "unit_a_id",
    "unit_a_type",
    "unit_a_title",
    "unit_b_id",
    "unit_b_type",
    "unit_b_title",
    "shared_themes",
    "shared_keywords",
    "shared_sources",
    "title_similarity",
    "score",
    "candidate_type",
    "candidate_reason",
    "status",
    "note",
    "unit_a_file",
    "unit_b_file",
  ],
  ...candidates.map((row) => [
    row.unit_a_id,
    row.unit_a_type,
    row.unit_a_title,
    row.unit_b_id,
    row.unit_b_type,
    row.unit_b_title,
    row.shared_themes,
    row.shared_keywords,
    row.shared_sources,
    row.title_similarity,
    row.score,
    row.candidate_type,
    row.candidate_reason,
    row.status,
    row.note,
    row.unit_a_file,
    row.unit_b_file,
  ]),
];

fs.writeFileSync(csvOutput, rows.map((row) => row.map(escapeCsv).join(",")).join("\n") + "\n");

const typeCounts = candidates.reduce((acc, row) => {
  acc[row.candidate_type] = (acc[row.candidate_type] || 0) + 1;
  return acc;
}, {});
const statusCounts = candidates.reduce((acc, row) => {
  acc[row.status] = (acc[row.status] || 0) + 1;
  return acc;
}, {});

function getRelationshipBetween(unit, targetId, type = null) {
  return unit.relationships.find((relationship) => {
    if (relationship.target !== targetId) return false;
    if (type && relationship.type !== type) return false;
    return true;
  });
}

const auditRows = [];
const auditCounts = {
  conflict_backlinked_ok: 0,
  conflict_backlinked_missing: 0,
  layered_link_ok: 0,
  layered_link_not_required: 0,
  layered_link_missing: 0,
};

for (const candidate of candidates) {
  const unitA = unitById.get(candidate.unit_a_id);
  const unitB = unitById.get(candidate.unit_b_id);
  if (!unitA || !unitB) continue;

  if (candidate.status === "已判断：不合并，建立冲突关系") {
    const aConflict = getRelationshipBetween(unitA, unitB.id, "冲突");
    const bConflict = getRelationshipBetween(unitB, unitA.id, "冲突");
    const ok = Boolean(aConflict?.note && bConflict?.note);
    auditCounts[ok ? "conflict_backlinked_ok" : "conflict_backlinked_missing"] += 1;
    auditRows.push({
      candidate_pair: `${unitA.id} <-> ${unitB.id}`,
      candidate_status: candidate.status,
      audit_type: "冲突回写审计",
      audit_result: ok ? "通过" : "缺失",
      audit_note: ok
        ? "双方内容单元均已写入带 note 的冲突关系"
        : "候选已判断为建立冲突关系，但至少一侧未回写冲突关系或缺少 note",
    });
    continue;
  }

  if (candidate.status === "已判断：不合并，分层保留") {
    const aToB = getRelationshipBetween(unitA, unitB.id);
    const bToA = getRelationshipBetween(unitB, unitA.id);
    const hasExplicitLink = Boolean(aToB || bToA);
    const isConceptToJudgmentOrSolution =
      (unitA.type === "概念单元" && (unitB.type === "观点单元" || unitB.type === "方案单元")) ||
      (unitB.type === "概念单元" && (unitA.type === "观点单元" || unitA.type === "方案单元"));
    const isQuestionPair = unitA.type === "问题单元" && unitB.type === "问题单元";
    const isViewToSolution =
      (unitA.type === "观点单元" && unitB.type === "方案单元") ||
      (unitA.type === "方案单元" && unitB.type === "观点单元");

    let auditResult = "缺失";
    let auditNote = "候选已判断为分层保留，但对应内容单元之间缺少显式关系";

    if (hasExplicitLink) {
      auditResult = "通过";
      auditNote = "至少一侧内容单元已写入显式关系，能支撑分层保留";
      auditCounts.layered_link_ok += 1;
    } else if (isQuestionPair || isViewToSolution) {
      auditResult = "无需";
      auditNote = "当前分层保留组合不强制要求显式关系";
      auditCounts.layered_link_not_required += 1;
    } else if (isConceptToJudgmentOrSolution) {
      auditResult = "缺失";
      auditNote = "概念单元分层保留时，应至少通过 `解释` 关系显式支撑对应观点或方案";
      auditCounts.layered_link_missing += 1;
    } else {
      auditResult = "无需";
      auditNote = "当前分层保留组合不强制要求显式关系";
      auditCounts.layered_link_not_required += 1;
    }

    auditRows.push({
      candidate_pair: `${unitA.id} <-> ${unitB.id}`,
      candidate_status: candidate.status,
      audit_type: "分层保留关系审计",
      audit_result: auditResult,
      audit_note: auditNote,
    });
  }
}

const auditCsvRows = [
  ["candidate_pair", "candidate_status", "audit_type", "audit_result", "audit_note"],
  ...auditRows.map((row) => [row.candidate_pair, row.candidate_status, row.audit_type, row.audit_result, row.audit_note]),
];

fs.writeFileSync(auditOutput, auditCsvRows.map((row) => row.map(escapeCsv).join(",")).join("\n") + "\n");

const summaryLines = [
  "# 去重与冲突总览",
  "",
  `最后更新：${today}`,
  "",
  "## 当前统计",
  "",
  `- 内容单元总数：${units.length}`,
  `- 去重候选总数：${candidates.length}`,
  "",
  "## 候选类型分布",
  "",
];

for (const type of Object.keys(typeCounts).sort((a, b) => a.localeCompare(b, "zh-Hans-CN"))) {
  summaryLines.push(`- ${type}：${typeCounts[type]}`);
}
if (Object.keys(typeCounts).length === 0) summaryLines.push("- 暂无候选");

summaryLines.push("", "## 处理状态分布", "");
for (const status of Object.keys(statusCounts).sort((a, b) => a.localeCompare(b, "zh-Hans-CN"))) {
  summaryLines.push(`- ${status}：${statusCounts[status]}`);
}
if (Object.keys(statusCounts).length === 0) summaryLines.push("- 暂无状态");

summaryLines.push(
  "",
  "## 当前说明",
  "",
  "- 本文件先给出去重候选，不自动合并",
  "- 自动识别候选与人工补充候选会同时进入索引",
  "- 已判断为 `建立冲突关系` 的候选，会审计双方内容单元是否都已回写 `冲突` 关系",
  "- 已判断为 `分层保留` 的候选，会审计对应内容单元之间是否存在显式关系支撑",
  "",
  "## 关系审计",
  "",
  `- 冲突回写已通过：${auditCounts.conflict_backlinked_ok}`,
  `- 冲突回写待补：${auditCounts.conflict_backlinked_missing}`,
  `- 分层保留关系已通过：${auditCounts.layered_link_ok}`,
  `- 分层保留关系无需直连：${auditCounts.layered_link_not_required}`,
  `- 分层保留关系待补：${auditCounts.layered_link_missing}`,
  "",
  "## 权威文件",
  "",
  `- 候选明细：\`${path.relative(root, csvOutput).replaceAll(path.sep, "/")}\``,
  `- 审计明细：\`${path.relative(root, auditOutput).replaceAll(path.sep, "/")}\``,
  `- 人工补充候选：\`${path.relative(root, manualCandidateInput).replaceAll(path.sep, "/")}\``,
  "- 去重规则：`00-规则与索引/内容单元去重与版本规则.md`",
  "- 关系规则：`00-规则与索引/内容单元关系规则.md`",
);

fs.writeFileSync(summaryOutput, `${summaryLines.join("\n")}\n`);

console.log(JSON.stringify({
  csvOutput,
  summaryOutput,
  auditOutput,
  unitCount: units.length,
  candidateCount: candidates.length,
}, null, 2));