Lunwen

__pycache__/
*.py[cod]
node_modules/
tools/browser/node_modules/
tools/browser/.cache/

interface:
  display_name: "Lunwen"
  short_description: "Write Chinese theses, learn sample-paper structure, manage references, figures, screenshots, and DOCX delivery."
  default_prompt: "Use this skill to write or revise a Chinese thesis or graduation project paper based on real project facts, sample papers, templates, references, figures, screenshots, and DOCX delivery. Before writing, ask for local file paths for template/sample/opening report. If a sample or template is DOCX, run `python tools/analyze_docx.py <sample.docx> --json-out output/style-profile.json`. If a sample is PDF, run `python tools/analyze_sample_pdf.py <sample.pdf> --json-out output/sample-analysis.json`. After analysis, summarize directory, target chapter lengths, and extracted styles, then explicitly wait for user confirmation before writing. During writing, run `python tools/count_chapter_words.py <thesis.md>` to control length, and run `python tools/ensure_thesis_assets.py <thesis.md> --check-only` to verify architecture figure, E-R figure, flow figure, data table, test-case table, and screenshot placeholders exist. When screenshot placeholders exist, use the repository-bundled browser flow: `python tools/extract_screenshot_placeholders.py <thesis.md> --json-out labels.json`, `python tools/build_screenshot_plan.py labels.json output/screenshot-plan.json --base-url <system-url>`, then `python tools/capture_thesis_screenshots.py output/screenshot-plan.json` to produce `image-map.json`. Before DOCX delivery, remove Markdown markers like `**` and links from正文, then generate with `python tools/generate_thesis_docx.py <source.md> <target.docx> --style-profile output/style-profile.json --image-map image-map.json`. Do not silently skip missing images: keep placeholders or warnings in the final DOCX."

{
  "base_url": "http://127.0.0.1:3000",
  "cdp_url": "",
  "output_dir": "output/doc",
  "image_map_output": "image-map.json",
  "headless": true,
  "viewport": {
    "width": 1440,
    "height": 900
  },
  "entries": [
    {
      "label": "系统首页",
      "url": "/",
      "wait_for_selector": "body",
      "wait_for_text": "",
      "clip_selector": "",
      "filename": "系统首页.png",
      "full_page": true,
      "actions": []
    },
    {
      "label": "核心功能页面",
      "url": "/dashboard",
      "wait_for_selector": "[data-page='dashboard']",
      "wait_for_text": "",
      "clip_selector": "",
      "filename": "核心功能页面.png",
      "full_page": true,
      "actions": []
    }
  ]
}

MIT License

Copyright (c) 2026 Doryoku1223

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.

{
  "name": "lunwen-skill",
  "private": true,
  "version": "0.1.0",
  "description": "Self-contained browser automation helpers for thesis screenshots.",
  "scripts": {
    "install:browsers": "playwright install chromium",
    "capture:screenshots": "node tools/browser/capture_screenshots.mjs"
  },
  "dependencies": {
    "playwright": "^1.53.0"
  }
}

pypdf
pdfplumber
python-docx

from __future__ import annotations

import json
import re
import sys
from collections import Counter, defaultdict
from pathlib import Path
from typing import Any

from docx import Document
from docx.enum.text import WD_ALIGN_PARAGRAPH
from docx.oxml.ns import qn


TITLE_PATTERNS = {
    "heading1": re.compile(r"^第.+章"),
    "heading2": re.compile(r"^\d+\.\d+(?!\.)"),
    "heading3": re.compile(r"^\d+\.\d+\.\d+"),
}


def alignment_name(value: int | None) -> str:
    mapping = {
        None: "left",
        WD_ALIGN_PARAGRAPH.LEFT: "left",
        WD_ALIGN_PARAGRAPH.CENTER: "center",
        WD_ALIGN_PARAGRAPH.RIGHT: "right",
        WD_ALIGN_PARAGRAPH.JUSTIFY: "justify",
        WD_ALIGN_PARAGRAPH.DISTRIBUTE: "distribute",
    }
    return mapping.get(value, "left")


def east_asia_font(run) -> str | None:
    if run._element.rPr is None or run._element.rPr.rFonts is None:
        return None
    return run._element.rPr.rFonts.get(qn("w:eastAsia"))


def paragraph_signature(paragraph) -> dict[str, Any]:
    run_fonts = []
    run_sizes = []
    bold_values = []

    for run in paragraph.runs:
        if not run.text.strip():
            continue
        run_fonts.append((east_asia_font(run) or run.font.name or "").strip())
        if run.font.size:
            run_sizes.append(round(run.font.size.pt, 1))
        if run.bold is not None:
            bold_values.append(bool(run.bold))

    first_line_indent = paragraph.paragraph_format.first_line_indent
    line_spacing = paragraph.paragraph_format.line_spacing
    page_break_before = False
    p_pr = paragraph._p.pPr
    if p_pr is not None and p_pr.pageBreakBefore is not None:
        page_break_before = True

    return {
        "font": most_common(run_fonts),
        "size_pt": most_common(run_sizes),
        "bold": most_common(bold_values, default=False),
        "alignment": alignment_name(paragraph.alignment),
        "first_line_indent_pt": round(first_line_indent.pt, 1) if first_line_indent else 0.0,
        "line_spacing": round(float(line_spacing), 2) if isinstance(line_spacing, (int, float)) else None,
        "space_before_pt": round(paragraph.paragraph_format.space_before.pt, 1)
        if paragraph.paragraph_format.space_before
        else 0.0,
        "space_after_pt": round(paragraph.paragraph_format.space_after.pt, 1)
        if paragraph.paragraph_format.space_after
        else 0.0,
        "page_break_before": page_break_before,
    }


def most_common(values: list[Any], default: Any = None) -> Any:
    filtered = [value for value in values if value not in ("", None)]
    if not filtered:
        return default
    return Counter(filtered).most_common(1)[0][0]


def classify_paragraph(text: str, in_reference_section: bool) -> str | None:
    normalized = text.strip()
    if not normalized:
        return None

    if normalized == "摘要":
        return "abstract_heading_cn"
    if normalized.lower() == "abstract":
        return "abstract_heading_en"
    if normalized == "参考文献":
        return "references_heading"
    if normalized == "致谢":
        return "ack_heading"
    if normalized.startswith("关键词"):
        return "keywords_cn"
    if normalized.startswith("Keywords"):
        return "keywords_en"
    if normalized.startswith("图"):
        return "figure_caption"
    if normalized.startswith("表"):
        return "table_caption"
    if in_reference_section and re.match(r"^\[\d+\]", normalized):
        return "references_body"

    if TITLE_PATTERNS["heading3"].match(normalized):
        return "heading3"
    if TITLE_PATTERNS["heading2"].match(normalized):
        return "heading2"
    if TITLE_PATTERNS["heading1"].match(normalized):
        return "heading1"

    if re.search(r"[A-Za-z]{3,}", normalized) and not re.search(r"[\u4e00-\u9fff]", normalized):
        return "body_en"
    return "body_cn"


def aggregate_styles(document: Document) -> dict[str, Any]:
    grouped: dict[str, list[dict[str, Any]]] = defaultdict(list)
    in_reference_section = False

    for paragraph in document.paragraphs:
        text = paragraph.text.strip()
        if text == "参考文献":
            in_reference_section = True
        elif re.match(r"^第.+章", text):
            in_reference_section = False

        category = classify_paragraph(text, in_reference_section)
        if category is None:
            continue
        grouped[category].append(paragraph_signature(paragraph))

    result = {}
    for category, signatures in grouped.items():
        result[category] = {
            "font": most_common([item["font"] for item in signatures]),
            "size_pt": most_common([item["size_pt"] for item in signatures]),
            "bold": most_common([item["bold"] for item in signatures], default=False),
            "alignment": most_common([item["alignment"] for item in signatures], default="left"),
            "first_line_indent_pt": most_common([item["first_line_indent_pt"] for item in signatures], default=0.0),
            "line_spacing": most_common([item["line_spacing"] for item in signatures]),
            "space_before_pt": most_common([item["space_before_pt"] for item in signatures], default=0.0),
            "space_after_pt": most_common([item["space_after_pt"] for item in signatures], default=0.0),
            "page_break_before": most_common([item["page_break_before"] for item in signatures], default=False),
            "sample_count": len(signatures),
        }

    return result


def print_summary(path: Path, styles: dict[str, Any]) -> None:
    print(f"FILE\t{path}")
    ordered_keys = [
        "heading1",
        "heading2",
        "heading3",
        "body_cn",
        "body_en",
        "abstract_heading_cn",
        "abstract_heading_en",
        "keywords_cn",
        "keywords_en",
        "figure_caption",
        "table_caption",
        "references_body",
    ]
    for key in ordered_keys:
        if key not in styles:
            continue
        style = styles[key]
        print(
            f"{key}\tfont={style['font']}\tsize_pt={style['size_pt']}\tbold={style['bold']}"
            f"\talignment={style['alignment']}\tfirst_line_indent_pt={style['first_line_indent_pt']}"
            f"\tline_spacing={style['line_spacing']}\tpage_break_before={style['page_break_before']}"
        )


def main() -> int:
    if len(sys.argv) < 2:
        print("Usage: python analyze_docx.py <docx> [--json-out path]")
        return 1

    docx_path = Path(sys.argv[1])
    document = Document(docx_path)
    styles = aggregate_styles(document)
    payload = {
        "source_file": str(docx_path),
        "styles": styles,
    }

    if len(sys.argv) >= 4 and sys.argv[2] == "--json-out":
        output_path = Path(sys.argv[3])
        output_path.parent.mkdir(parents=True, exist_ok=True)
        output_path.write_text(json.dumps(payload, ensure_ascii=False, indent=2), encoding="utf-8")

    print_summary(docx_path, styles)
    return 0


if __name__ == "__main__":
    raise SystemExit(main())

from __future__ import annotations

import json
import re
import sys
from pathlib import Path

from pypdf import PdfReader


def clean_count(text: str) -> int:
    return len(re.sub(r"\s+", "", text))


def walk_outline(items, reader, level=1, out=None):
    if out is None:
        out = []
    for item in items:
        if isinstance(item, list):
            walk_outline(item, reader, level + 1, out)
        else:
            title = item.get("/Title", "").strip()
            if not title:
                continue
            try:
                page = reader.get_destination_page_number(item) + 1
            except Exception:
                continue
            out.append({"level": level, "title": title, "page": page})
    return out


def find_end_page(items, idx, total_pages):
    cur = items[idx]
    for j in range(idx + 1, len(items)):
        if items[j]["level"] <= cur["level"]:
            return max(cur["page"], items[j]["page"] - 1)
    return total_pages


def analyze_pdf(path: Path) -> dict:
    reader = PdfReader(str(path))
    pages = [page.extract_text() or "" for page in reader.pages]
    outline = walk_outline(reader.outline, reader)
    sections = []
    for idx, item in enumerate(outline):
        end_page = find_end_page(outline, idx, len(pages))
        text = "\n".join(pages[item["page"] - 1 : end_page])
        sections.append(
            {
                "level": item["level"],
                "title": item["title"],
                "start_page": item["page"],
                "end_page": end_page,
                "char_count": clean_count(text),
            }
        )
    return {
        "file": str(path),
        "total_pages": len(pages),
        "sections": sections,
    }


def main() -> int:
    if len(sys.argv) < 2:
        print("Usage: python analyze_sample_pdf.py <pdf> [--json-out path]")
        return 1

    pdf_path = Path(sys.argv[1])
    result = analyze_pdf(pdf_path)

    json_out = None
    if len(sys.argv) >= 4 and sys.argv[2] == "--json-out":
        json_out = Path(sys.argv[3])

    if json_out:
        json_out.write_text(json.dumps(result, ensure_ascii=False, indent=2), encoding="utf-8")

    print(f"FILE\t{result['file']}")
    print(f"TOTAL_PAGES\t{result['total_pages']}")
    for section in result["sections"]:
        if section["level"] <= 2:
            print(
                f"{section['title']}\t"
                f"p.{section['start_page']}-{section['end_page']}\t"
                f"{section['char_count']}"
            )
    return 0


if __name__ == "__main__":
    raise SystemExit(main())

import fs from "node:fs";
import path from "node:path";
import { chromium } from "playwright";

function resolveUrl(baseUrl, entryUrl) {
  if (!entryUrl) {
    return baseUrl;
  }
  if (/^https?:\/\//i.test(entryUrl)) {
    return entryUrl;
  }
  if (!baseUrl) {
    throw new Error(`Entry url "${entryUrl}" requires base_url in the plan.`);
  }
  return new URL(entryUrl, baseUrl).toString();
}

function slugify(label) {
  const normalized = label.replace(/[\\/:*?"<>|]/g, "-").replace(/\s+/g, "-").trim();
  return normalized || "screenshot";
}

async function waitForEntry(page, entry) {
  if (entry.wait_for_timeout_ms) {
    await page.waitForTimeout(entry.wait_for_timeout_ms);
  }
  if (entry.wait_for_text) {
    await page.getByText(entry.wait_for_text, { exact: false }).first().waitFor({ state: "visible", timeout: entry.timeout_ms ?? 15000 });
  }
  if (entry.wait_for_selector) {
    await page.waitForSelector(entry.wait_for_selector, { state: "visible", timeout: entry.timeout_ms ?? 15000 });
  }
}

async function applyActions(page, entry) {
  for (const action of entry.actions ?? []) {
    switch (action.type) {
      case "click":
        await page.locator(action.selector).first().click();
        break;
      case "fill":
        await page.locator(action.selector).first().fill(action.value ?? "");
        break;
      case "press":
        await page.locator(action.selector).first().press(action.key);
        break;
      case "wait_for_selector":
        await page.waitForSelector(action.selector, { state: action.state ?? "visible", timeout: action.timeout_ms ?? 15000 });
        break;
      case "wait_for_text":
        await page.getByText(action.text, { exact: false }).first().waitFor({ state: "visible", timeout: action.timeout_ms ?? 15000 });
        break;
      case "wait_for_timeout":
        await page.waitForTimeout(action.timeout_ms ?? 1000);
        break;
      default:
        throw new Error(`Unsupported action type: ${action.type}`);
    }
  }
}

async function main() {
  const planPath = process.argv[2];
  if (!planPath) {
    console.error("Usage: node tools/browser/capture_screenshots.mjs <plan.json>");
    process.exit(1);
  }

  const absolutePlanPath = path.resolve(planPath);
  const plan = JSON.parse(fs.readFileSync(absolutePlanPath, "utf8"));
  const outputDir = path.resolve(path.dirname(absolutePlanPath), plan.output_dir ?? "output/doc");
  fs.mkdirSync(outputDir, { recursive: true });

  const browser = plan.cdp_url
    ? await chromium.connectOverCDP(plan.cdp_url)
    : await chromium.launch({ headless: plan.headless !== false });

  const context = plan.cdp_url
    ? browser.contexts()[0]
    : await browser.newContext({
        viewport: plan.viewport ?? { width: 1440, height: 900 },
        ignoreHTTPSErrors: true
      });

  const page = context.pages()[0] ?? await context.newPage();
  const imageMap = {};

  try {
    for (const entry of plan.entries ?? []) {
      const targetUrl = resolveUrl(plan.base_url, entry.url);
      await page.goto(targetUrl, { waitUntil: entry.wait_until ?? "networkidle", timeout: entry.timeout_ms ?? 30000 });
      await applyActions(page, entry);
      await waitForEntry(page, entry);

      const filename = entry.filename ?? `${slugify(entry.label)}.png`;
      const outputPath = path.resolve(outputDir, filename);
      const locator = entry.clip_selector ? page.locator(entry.clip_selector).first() : null;

      if (locator) {
        await locator.screenshot({ path: outputPath, type: "png" });
      } else {
        await page.screenshot({ path: outputPath, fullPage: entry.full_page !== false, type: "png" });
      }

      imageMap[entry.label] = outputPath;
      console.log(`CAPTURED\t${entry.label}\t${outputPath}`);
    }
  } finally {
    const imageMapPath = path.resolve(path.dirname(absolutePlanPath), plan.image_map_output ?? "image-map.json");
    fs.writeFileSync(imageMapPath, JSON.stringify(imageMap, null, 2), "utf8");
    console.log(`IMAGE_MAP\t${imageMapPath}`);
    if (plan.cdp_url) {
      await browser.close();
    } else {
      await context.close();
      await browser.close();
    }
  }
}

main().catch((error) => {
  console.error(error.stack || String(error));
  process.exit(1);
});

from __future__ import annotations

import json
import sys
from pathlib import Path


def main() -> int:
    if len(sys.argv) < 4:
        print("Usage: python build_image_map.py <labels.json> <image-dir> <output.json> [--manual manual-map.json]")
        return 1

    labels_path = Path(sys.argv[1])
    image_dir = Path(sys.argv[2])
    output_path = Path(sys.argv[3])
    manual_path = None
    if len(sys.argv) >= 6 and sys.argv[4] == "--manual":
        manual_path = Path(sys.argv[5])

    labels = json.loads(labels_path.read_text(encoding="utf-8")).get("labels", [])
    manual_map = {}
    if manual_path and manual_path.exists():
        manual_map = json.loads(manual_path.read_text(encoding="utf-8"))
    result = {}
    for label in labels:
        if label in manual_map:
            manual_target = Path(manual_map[label])
            if manual_target.exists():
                result[label] = str(manual_target)
                continue
        candidates = [
            image_dir / f"{label}.png",
            image_dir / f"{label}.jpg",
            image_dir / f"{label}.jpeg",
        ]
        for candidate in candidates:
            if candidate.exists():
                result[label] = str(candidate)
                break

    output_path.write_text(json.dumps(result, ensure_ascii=False, indent=2), encoding="utf-8")
    print(output_path)
    return 0


if __name__ == "__main__":
    raise SystemExit(main())

from __future__ import annotations

import json
import re
import sys
from collections import Counter
from pathlib import Path


REF_RE = re.compile(r"^\[(\d+)\]\s*(.+)$")


def classify_language(text: str) -> str:
    return "zh" if re.search(r"[\u4e00-\u9fff]", text) else "en"


def extract_year(text: str) -> int | None:
    years = re.findall(r"\b(20\d{2})\b", text)
    return int(years[0]) if years else None


def parse_references(path: Path) -> list[dict]:
    refs = []
    for line in path.read_text(encoding="utf-8").splitlines():
        line = line.strip()
        m = REF_RE.match(line)
        if not m:
            continue
        body = m.group(2).strip()
        refs.append(
            {
                "raw": line,
                "index": int(m.group(1)),
                "language": classify_language(body),
                "year": extract_year(body),
                "has_doi": "doi" in body.lower(),
            }
        )
    return refs


def main() -> int:
    if len(sys.argv) < 2:
        print("Usage: python build_reference_pool.py <reference-markdown-file>")
        return 1

    path = Path(sys.argv[1])
    refs = parse_references(path)
    lang_counts = Counter(ref["language"] for ref in refs)
    bad_years = [ref for ref in refs if ref["year"] is None or ref["year"] < 2020]
    print(f"TOTAL\t{len(refs)}")
    print(f"ZH\t{lang_counts.get('zh', 0)}")
    print(f"EN\t{lang_counts.get('en', 0)}")
    print(f"BAD_YEAR\t{len(bad_years)}")
    for ref in bad_years:
        print(f"BAD\t{ref['raw']}")
    return 0


if __name__ == "__main__":
    raise SystemExit(main())

from __future__ import annotations

import argparse
import json
import re
from pathlib import Path


def safe_filename(label: str) -> str:
    return re.sub(r'[\\/:*?"<>|]+', "-", label).strip() or "screenshot"


def parse_args() -> argparse.Namespace:
    parser = argparse.ArgumentParser(description="Build a screenshot capture plan from thesis screenshot placeholders.")
    parser.add_argument("labels_json", type=Path)
    parser.add_argument("output_plan", type=Path)
    parser.add_argument("--base-url", dest="base_url", default="")
    parser.add_argument("--output-dir", dest="output_dir", default="output/doc")
    parser.add_argument("--image-map", dest="image_map_output", default="image-map.json")
    parser.add_argument("--cdp-url", dest="cdp_url", default="")
    return parser.parse_args()


def main() -> int:
    args = parse_args()
    payload = json.loads(args.labels_json.read_text(encoding="utf-8"))
    labels = payload.get("labels", [])
    entries = []

    for label in labels:
        entries.append(
            {
                "label": label,
                "url": "",
                "wait_for_selector": "",
                "wait_for_text": "",
                "clip_selector": "",
                "filename": f"{safe_filename(label)}.png",
                "full_page": True,
                "actions": [],
            }
        )

    plan = {
        "base_url": args.base_url,
        "cdp_url": args.cdp_url,
        "output_dir": args.output_dir,
        "image_map_output": args.image_map_output,
        "headless": True,
        "viewport": {"width": 1440, "height": 900},
        "entries": entries,
    }

    args.output_plan.parent.mkdir(parents=True, exist_ok=True)
    args.output_plan.write_text(json.dumps(plan, ensure_ascii=False, indent=2), encoding="utf-8")
    print(args.output_plan)
    return 0


if __name__ == "__main__":
    raise SystemExit(main())

from __future__ import annotations

import argparse
import shutil
import subprocess
from pathlib import Path


REPO_ROOT = Path(__file__).resolve().parent.parent
PACKAGE_JSON = REPO_ROOT / "package.json"


def npm_command() -> list[str]:
    npm = shutil.which("npm")
    if not npm:
        raise RuntimeError("npm is required for Playwright bootstrap, but it was not found in PATH.")
    return [npm]


def ensure_playwright_installed() -> None:
    node_modules = REPO_ROOT / "node_modules" / "playwright"
    if node_modules.exists():
        return

    subprocess.run(npm_command() + ["install"], cwd=REPO_ROOT, check=True)
    subprocess.run(npm_command() + ["run", "install:browsers"], cwd=REPO_ROOT, check=True)


def run_capture(plan_path: Path) -> None:
    node = shutil.which("node")
    if not node:
        raise RuntimeError("Node.js is required for browser capture, but it was not found in PATH.")

    script = REPO_ROOT / "tools" / "browser" / "capture_screenshots.mjs"
    subprocess.run([node, str(script), str(plan_path)], cwd=REPO_ROOT, check=True)


def parse_args() -> argparse.Namespace:
    parser = argparse.ArgumentParser(description="Capture thesis screenshots with the repository-bundled Playwright flow.")
    parser.add_argument("plan_json", type=Path)
    parser.add_argument("--skip-bootstrap", action="store_true")
    return parser.parse_args()


def main() -> int:
    args = parse_args()
    if not PACKAGE_JSON.exists():
        print("package.json not found; Playwright bootstrap is unavailable.")
        return 1

    try:
        if not args.skip_bootstrap:
            ensure_playwright_installed()
        run_capture(args.plan_json)
    except subprocess.CalledProcessError as exc:
        print(f"Command failed with exit code {exc.returncode}")
        return exc.returncode
    except RuntimeError as exc:
        print(str(exc))
        return 1

    return 0


if __name__ == "__main__":
    raise SystemExit(main())

from __future__ import annotations

import re
import sys
from pathlib import Path

from markdown_utils import compute_text_metrics


CHAPTER_RE = re.compile(r"^##\s+(.+)$", flags=re.M)


def chapter_spans(text: str) -> list[tuple[str, int, int]]:
    matches = list(CHAPTER_RE.finditer(text))
    spans: list[tuple[str, int, int]] = []

    for index, match in enumerate(matches):
        start = match.end()
        end = matches[index + 1].start() if index + 1 < len(matches) else len(text)
        spans.append((match.group(1).strip(), start, end))

    return spans


def format_metrics(label: str, metrics: dict[str, int]) -> str:
    return (
        f"{label}\t"
        f"APPROX_WORDS={metrics['approx_word_count']}\t"
        f"CHAR_NO_SPACES={metrics['char_no_spaces']}\t"
        f"CHAR_WITH_SPACES={metrics['char_with_spaces']}\t"
        f"CJK_CHARS={metrics['chinese_chars']}\t"
        f"NON_CJK_WORDS={metrics['non_chinese_words']}\t"
        f"EN_WORDS={metrics['english_words']}"
    )


def main() -> int:
    if len(sys.argv) < 2:
        print("Usage: python count_chapter_words.py <markdown-file>")
        return 1

    path = Path(sys.argv[1])
    text = path.read_text(encoding="utf-8")
    print(format_metrics("TOTAL", compute_text_metrics(text)))

    for title, start, end in chapter_spans(text):
        print(format_metrics(title, compute_text_metrics(text[start:end])))

    return 0


if __name__ == "__main__":
    raise SystemExit(main())

from __future__ import annotations

import argparse
import re
from pathlib import Path


REQUIRED_ITEMS = [
    {
        "id": "architecture",
        "label": "系统总体架构图",
        "kind": "figure",
        "keywords": ["架构图", "总体架构", "系统架构"],
        "template": """```mermaid
flowchart LR
    U[用户] --> W[Web/桌面前端]
    W --> S[业务服务层]
    S --> D[(数据库)]
    S --> F[文件存储/缓存]
```
图 {number} {label}""",
    },
    {
        "id": "er",
        "label": "数据库 E-R 图",
        "kind": "figure",
        "keywords": ["E-R 图", "ER图", "实体关系"],
        "template": """```mermaid
erDiagram
    USER ||--o{{ NOTE : creates
    NOTE ||--o{{ TAG : tagged_with
    USER {{
        int id
        string name
    }}
    NOTE {{
        int id
        string title
    }}
    TAG {{
        int id
        string name
    }}
```
图 {number} {label}""",
    },
    {
        "id": "flow",
        "label": "关键业务流程图",
        "kind": "figure",
        "keywords": ["流程图", "业务流程", "关键流程"],
        "template": """```mermaid
flowchart TD
    A[进入系统] --> B[输入业务参数]
    B --> C[执行核心处理]
    C --> D[保存结果]
    D --> E[反馈执行状态]
```
图 {number} {label}""",
    },
    {
        "id": "data_table",
        "label": "核心数据表设计",
        "kind": "table",
        "keywords": ["数据表", "表结构", "数据库设计"],
        "template": """表 {number} {label}
| 表名 | 说明 | 关键字段 |
| --- | --- | --- |
| user | 用户信息表 | id, username, password |
| note | 业务主表 | id, title, content |
| tag | 分类标签表 | id, name |""",
    },
    {
        "id": "test_table",
        "label": "系统测试用例表",
        "kind": "table",
        "keywords": ["测试用例", "测试表", "功能测试"],
        "template": """表 {number} {label}
| 用例编号 | 测试目标 | 输入/操作 | 预期结果 |
| --- | --- | --- | --- |
| TC-01 | 正常流程 | 输入合法数据并提交 | 系统提示成功 |
| TC-02 | 异常流程 | 输入缺失字段 | 系统给出校验提示 |""",
    },
    {
        "id": "screenshot",
        "label": "核心功能页面截图",
        "kind": "screenshot",
        "keywords": ["此处插入截图", "页面截图", "系统截图"],
        "template": "[此处插入截图：系统首页]\n[此处插入截图：核心功能页面]",
    },
]


FIGURE_RE = re.compile(r"^图\s*(\d+(?:\.\d+)?)", flags=re.M)
TABLE_RE = re.compile(r"^表\s*(\d+(?:\.\d+)?)", flags=re.M)


def next_number(text: str, pattern: re.Pattern[str]) -> str:
    matches = pattern.findall(text)
    if not matches:
        return "1.1"
    last = matches[-1]
    if "." in last:
        major, minor = last.split(".", 1)
        if minor.isdigit():
            return f"{major}.{int(minor) + 1}"
    if last.isdigit():
        return str(int(last) + 1)
    return "1.1"


def analyze_missing_items(text: str) -> list[dict]:
    missing = []
    for item in REQUIRED_ITEMS:
        if any(keyword in text for keyword in item["keywords"]):
            continue
        missing.append(item)
    return missing


def append_templates(text: str, missing: list[dict]) -> str:
    if not missing:
        return text

    figure_number = next_number(text, FIGURE_RE)
    table_number = next_number(text, TABLE_RE)
    blocks = ["", "## 图表与截图补全草稿", ""]

    for item in missing:
        if item["kind"] == "figure":
            blocks.append(item["template"].format(number=figure_number, label=item["label"]))
            major, minor = figure_number.split(".") if "." in figure_number else (figure_number, "0")
            figure_number = f"{major}.{int(minor) + 1}"
        elif item["kind"] == "table":
            blocks.append(item["template"].format(number=table_number, label=item["label"]))
            major, minor = table_number.split(".") if "." in table_number else (table_number, "0")
            table_number = f"{major}.{int(minor) + 1}"
        else:
            blocks.append(item["template"])
        blocks.append("")

    return text.rstrip() + "\n" + "\n".join(blocks)


def parse_args() -> argparse.Namespace:
    parser = argparse.ArgumentParser(description="Ensure mandatory figures, tables and screenshots exist in thesis markdown.")
    parser.add_argument("markdown_file", type=Path)
    parser.add_argument("--check-only", action="store_true")
    parser.add_argument("--in-place", action="store_true")
    return parser.parse_args()


def main() -> int:
    args = parse_args()
    text = args.markdown_file.read_text(encoding="utf-8")
    missing = analyze_missing_items(text)

    print(f"MISSING_COUNT\t{len(missing)}")
    for item in missing:
        print(f"MISSING\t{item['id']}\t{item['label']}")

    if args.check_only or not args.in_place or not missing:
        return 2 if missing else 0

    updated = append_templates(text, missing)
    args.markdown_file.write_text(updated, encoding="utf-8")
    print(f"UPDATED\t{args.markdown_file}")
    return 0


if __name__ == "__main__":
    raise SystemExit(main())

from __future__ import annotations

import json
import re
import sys
from pathlib import Path


CAPTION_RE = re.compile(r"^(图\s*\d+(?:\.\d+)?\s+.+)$")


def safe_name(text: str) -> str:
    cleaned = re.sub(r"[^\w\u4e00-\u9fff\-]+", "-", text).strip("-")
    return cleaned[:80] or "diagram"


def main() -> int:
    if len(sys.argv) < 3:
        print("Usage: python extract_mermaid_blocks.py <markdown-file> <output-dir> [--manifest path]")
        return 1

    source = Path(sys.argv[1])
    out_dir = Path(sys.argv[2])
    manifest_path = None
    if len(sys.argv) >= 5 and sys.argv[3] == "--manifest":
        manifest_path = Path(sys.argv[4])

    out_dir.mkdir(parents=True, exist_ok=True)
    lines = source.read_text(encoding="utf-8").splitlines()
    in_mermaid = False
    buffer: list[str] = []
    pending_blocks: list[dict] = []
    results: list[dict] = []
    index = 0

    for line in lines:
        stripped = line.strip()
        if in_mermaid:
            if stripped.startswith("```"):
                pending_blocks.append({"content": "\n".join(buffer)})
                in_mermaid = False
                buffer = []
            else:
                buffer.append(line.rstrip())
            continue

        if stripped.startswith("```mermaid"):
            in_mermaid = True
            buffer = []
            continue

        cap = CAPTION_RE.match(stripped)
        if cap and pending_blocks:
            block = pending_blocks.pop(0)
            index += 1
            caption = cap.group(1).strip()
            filename = f"{index:02d}-{safe_name(caption)}.mmd"
            file_path = out_dir / filename
            file_path.write_text(block["content"], encoding="utf-8")
            results.append(
                {
                    "caption": caption,
                    "mmd": str(file_path),
                    "png": str(file_path.with_suffix(".png")),
                    "svg": str(file_path.with_suffix(".svg")),
                }
            )

    if manifest_path:
        manifest_path.parent.mkdir(parents=True, exist_ok=True)
        manifest_path.write_text(json.dumps(results, ensure_ascii=False, indent=2), encoding="utf-8")

    print(f"COUNT\t{len(results)}")
    for item in results:
        print(f"{item['caption']}\t{item['mmd']}")
    return 0


if __name__ == "__main__":
    raise SystemExit(main())

from __future__ import annotations

import json
import re
import sys
from pathlib import Path


PLACEHOLDER_RE = re.compile(r"^\[此处插入截图：(.+?)\]$")


def main() -> int:
    if len(sys.argv) < 2:
        print("Usage: python extract_screenshot_placeholders.py <markdown-file> [--json-out path]")
        return 1

    source = Path(sys.argv[1])
    labels = []
    for line in source.read_text(encoding="utf-8").splitlines():
        m = PLACEHOLDER_RE.match(line.strip())
        if m:
            labels.append(m.group(1).strip())

    print("COUNT\t" + str(len(labels)))
    for label in labels:
        print(label)

    if len(sys.argv) >= 4 and sys.argv[2] == "--json-out":
        Path(sys.argv[3]).write_text(
            json.dumps({"labels": labels}, ensure_ascii=False, indent=2),
            encoding="utf-8",
        )
    return 0


if __name__ == "__main__":
    raise SystemExit(main())

from __future__ import annotations

import argparse
import re
from pathlib import Path

from docx import Document
from docx.enum.text import WD_ALIGN_PARAGRAPH
from docx.oxml import OxmlElement
from docx.oxml.ns import qn
from docx.shared import Cm, Pt


CODE_BLOCK_RE = re.compile(r"^```(mermaid|plantuml)\s*$", re.I)
CAPTION_RE = re.compile(r"^(图\s*\d+(?:\.\d+)?\s+.+)$")


def set_run_fonts(run, east_asia_font: str, latin_font: str, size_pt: float, *, bold: bool = False) -> None:
    run.bold = bold
    run.font.size = Pt(size_pt)
    run.font.name = latin_font
    r_pr = run._element.get_or_add_rPr()
    r_fonts = r_pr.rFonts
    if r_fonts is None:
        r_fonts = OxmlElement("w:rFonts")
        r_pr.append(r_fonts)
    r_fonts.set(qn("w:eastAsia"), east_asia_font)
    r_fonts.set(qn("w:ascii"), latin_font)
    r_fonts.set(qn("w:hAnsi"), latin_font)


def add_paragraph(doc: Document, text: str, *, font_cn: str = "宋体", font_en: str = "Times New Roman", size: float = 10.5, bold: bool = False, center: bool = False) -> None:
    paragraph = doc.add_paragraph()
    paragraph.alignment = WD_ALIGN_PARAGRAPH.CENTER if center else WD_ALIGN_PARAGRAPH.LEFT
    run = paragraph.add_run(text)
    set_run_fonts(run, font_cn, font_en, size, bold=bold)
    if not center:
        paragraph.paragraph_format.first_line_indent = Pt(21)
    paragraph.paragraph_format.line_spacing = 1.25


def add_code_block(doc: Document, code: str) -> None:
    for line in code.splitlines() or [""]:
        paragraph = doc.add_paragraph()
        paragraph.alignment = WD_ALIGN_PARAGRAPH.LEFT
        paragraph.paragraph_format.first_line_indent = Pt(0)
        paragraph.paragraph_format.line_spacing = 1.1
        run = paragraph.add_run(line.rstrip())
        set_run_fonts(run, "Consolas", "Consolas", 9)


def extract_blocks(markdown_path: Path) -> list[dict[str, str]]:
    lines = markdown_path.read_text(encoding="utf-8").splitlines()
    blocks: list[dict[str, str]] = []
    in_code = False
    lang = ""
    buffer: list[str] = []
    pending: list[dict[str, str]] = []

    for line in lines:
        stripped = line.strip()
        if in_code:
            if stripped.startswith("```"):
                pending.append({"lang": lang.lower(), "code": "\n".join(buffer)})
                in_code = False
                lang = ""
                buffer = []
            else:
                buffer.append(line.rstrip())
            continue

        code_match = CODE_BLOCK_RE.match(stripped)
        if code_match:
            in_code = True
            lang = code_match.group(1)
            buffer = []
            continue

        caption_match = CAPTION_RE.match(stripped)
        if caption_match and pending:
            item = pending.pop(0)
            item["caption"] = caption_match.group(1).strip()
            blocks.append(item)

    return blocks


def build_doc(title: str, markdown_path: Path, output_path: Path) -> Path:
    blocks = extract_blocks(markdown_path)
    doc = Document()
    section = doc.sections[0]
    section.top_margin = Cm(2.54)
    section.bottom_margin = Cm(2.54)
    section.left_margin = Cm(3.17)
    section.right_margin = Cm(3.17)

    add_paragraph(doc, f"{title}-附件", font_cn="黑体", font_en="Times New Roman", size=18, bold=True, center=True)
    add_paragraph(doc, "流程图、E-R 图及其他 Mermaid / PlantUML 源码附件", font_cn="黑体", font_en="Times New Roman", size=14, center=True)

    if not blocks:
        add_paragraph(doc, "正文中未提取到 Mermaid 或 PlantUML 代码块。", size=10.5)
    else:
        for index, block in enumerate(blocks, start=1):
            add_paragraph(doc, f"{index}. {block['caption']}", font_cn="黑体", font_en="Times New Roman", size=14, bold=True)
            add_paragraph(doc, f"图类型：{block['lang']}", size=10.5)
            add_code_block(doc, block["code"])

    output_path.parent.mkdir(parents=True, exist_ok=True)
    doc.save(str(output_path))
    return output_path


def parse_args() -> argparse.Namespace:
    parser = argparse.ArgumentParser(description="Generate appendix DOCX containing Mermaid / PlantUML source blocks from thesis markdown.")
    parser.add_argument("title", help="Thesis title used for the appendix heading")
    parser.add_argument("markdown_file", type=Path)
    parser.add_argument("target_docx", type=Path)
    return parser.parse_args()


def main() -> int:
    args = parse_args()
    output = build_doc(args.title, args.markdown_file, args.target_docx)
    print(output)
    return 0


if __name__ == "__main__":
    raise SystemExit(main())

from __future__ import annotations

import argparse
import json
import re
from pathlib import Path
from typing import Any

from docx import Document
from docx.enum.table import WD_ALIGN_VERTICAL, WD_TABLE_ALIGNMENT
from docx.enum.text import WD_ALIGN_PARAGRAPH, WD_LINE_SPACING
from docx.oxml import OxmlElement
from docx.oxml.ns import qn
from docx.shared import Cm, Pt

from markdown_utils import SCREENSHOT_PLACEHOLDER_RE, cleanup_inline_markdown


SPECIAL_CENTERED_HEADINGS = {
    "摘要": "abstract_heading_cn",
    "abstract": "abstract_heading_en",
    "参考文献": "references_heading",
    "致谢": "ack_heading",
}

ALIGNMENT_MAP = {
    "left": WD_ALIGN_PARAGRAPH.LEFT,
    "center": WD_ALIGN_PARAGRAPH.CENTER,
    "right": WD_ALIGN_PARAGRAPH.RIGHT,
    "justify": WD_ALIGN_PARAGRAPH.JUSTIFY,
    "distribute": WD_ALIGN_PARAGRAPH.DISTRIBUTE,
}


def default_style_profile() -> dict[str, Any]:
    return {
        "styles": {
            "title": centered_style("黑体", "Times New Roman", 18, bold=True),
            "heading1": paragraph_style("黑体", "Times New Roman", 18, bold=True, space_before=10, space_after=10),
            "heading2": paragraph_style("黑体", "Times New Roman", 15, bold=True, space_before=10, space_after=10),
            "heading3": paragraph_style("黑体", "Times New Roman", 12, bold=True, space_before=10, space_after=10),
            "abstract_heading_cn": centered_style("黑体", "Times New Roman", 18, bold=True, page_break_before=True),
            "abstract_heading_en": centered_style(
                "Times New Roman",
                "Times New Roman",
                18,
                bold=True,
                page_break_before=True,
            ),
            "references_heading": centered_style("黑体", "Times New Roman", 18, bold=True, page_break_before=True),
            "ack_heading": centered_style("黑体", "Times New Roman", 18, bold=True, page_break_before=True),
            "body_cn": paragraph_style("宋体", "Times New Roman", 10.5, first_line_indent=21),
            "body_en": paragraph_style("Times New Roman", "Times New Roman", 12, first_line_indent=21),
            "keywords_cn_label": run_style("黑体", "Times New Roman", 12, bold=True),
            "keywords_cn_content": run_style("宋体", "Times New Roman", 12),
            "keywords_en_label": run_style("Times New Roman", "Times New Roman", 12, bold=True),
            "keywords_en_content": run_style("Times New Roman", "Times New Roman", 12),
            "keywords_paragraph": paragraph_style("宋体", "Times New Roman", 10.5, first_line_indent=0),
            "figure_caption": centered_style("宋体", "Times New Roman", 10.5, line_spacing=1, line_spacing_rule="single"),
            "table_caption": centered_style("宋体", "Times New Roman", 10.5, line_spacing=1, line_spacing_rule="single"),
            "table_text": centered_style("宋体", "Times New Roman", 10.5),
            "references_body": paragraph_style("宋体", "Times New Roman", 10.5, first_line_indent=-21, left_indent=21),
            "missing_asset": centered_style("楷体", "Times New Roman", 10.5),
            "code": paragraph_style("Consolas", "Consolas", 9, first_line_indent=0),
        }
    }


def paragraph_style(
    east_asia_font: str,
    latin_font: str,
    size_pt: float,
    *,
    bold: bool = False,
    alignment: str = "left",
    line_spacing: float = 1.25,
    line_spacing_rule: str = "multiple",
    first_line_indent: float = 0,
    left_indent: float = 0,
    space_before: float = 0,
    space_after: float = 0,
    page_break_before: bool = False,
) -> dict[str, Any]:
    return {
        "east_asia_font": east_asia_font,
        "latin_font": latin_font,
        "size_pt": size_pt,
        "bold": bold,
        "alignment": alignment,
        "line_spacing": line_spacing,
        "line_spacing_rule": line_spacing_rule,
        "first_line_indent_pt": first_line_indent,
        "left_indent_pt": left_indent,
        "space_before_pt": space_before,
        "space_after_pt": space_after,
        "page_break_before": page_break_before,
    }


def centered_style(
    east_asia_font: str,
    latin_font: str,
    size_pt: float,
    *,
    bold: bool = False,
    line_spacing: float = 1.25,
    line_spacing_rule: str = "multiple",
    page_break_before: bool = False,
) -> dict[str, Any]:
    return paragraph_style(
        east_asia_font,
        latin_font,
        size_pt,
        bold=bold,
        alignment="center",
        line_spacing=line_spacing,
        line_spacing_rule=line_spacing_rule,
        first_line_indent=0,
        space_before=0,
        space_after=0,
        page_break_before=page_break_before,
    )


def run_style(east_asia_font: str, latin_font: str, size_pt: float, *, bold: bool = False) -> dict[str, Any]:
    return {
        "east_asia_font": east_asia_font,
        "latin_font": latin_font,
        "size_pt": size_pt,
        "bold": bold,
    }


def infer_fonts(style: dict[str, Any], fallback: dict[str, Any]) -> dict[str, Any]:
    font = style.get("font")
    if font and "east_asia_font" not in style:
        style["east_asia_font"] = font
    if font and "latin_font" not in style:
        style["latin_font"] = font if re.search(r"[A-Za-z]", str(font)) and not re.search(r"[\u4e00-\u9fff]", str(font)) else fallback["latin_font"]
    return style


def deep_merge(base: dict[str, Any], override: dict[str, Any]) -> dict[str, Any]:
    merged = json.loads(json.dumps(base))
    for key, value in override.items():
        if isinstance(value, dict) and isinstance(merged.get(key), dict):
            merged[key] = deep_merge(merged[key], value)
        else:
            merged[key] = value
    return merged


def load_style_profile(path: Path | None) -> dict[str, Any]:
    profile = default_style_profile()
    if path is None or not path.exists():
        return profile

    raw = json.loads(path.read_text(encoding="utf-8"))
    if "styles" not in raw:
        raw = {"styles": raw}
    profile = deep_merge(profile, raw)

    styles = profile["styles"]
    fallback_map = default_style_profile()["styles"]
    for name, style in list(styles.items()):
        if isinstance(style, dict):
            styles[name] = infer_fonts(style, fallback_map.get(name, fallback_map["body_cn"]))

    # Allow simplified analyzer output to drive keyword/caption styles.
    if "keywords_cn" in styles:
        styles["keywords_paragraph"] = deep_merge(styles["keywords_paragraph"], styles["keywords_cn"])
        styles["keywords_cn_label"] = deep_merge(styles["keywords_cn_label"], styles["keywords_cn"])
        styles["keywords_cn_content"] = deep_merge(styles["keywords_cn_content"], styles["keywords_cn"])
    if "keywords_en" in styles:
        styles["keywords_paragraph"] = deep_merge(styles["keywords_paragraph"], styles["keywords_en"])
        styles["keywords_en_label"] = deep_merge(styles["keywords_en_label"], styles["keywords_en"])
        styles["keywords_en_content"] = deep_merge(styles["keywords_en_content"], styles["keywords_en"])
    if "figure_caption" in styles:
        styles["figure_caption"] = infer_fonts(styles["figure_caption"], fallback_map["figure_caption"])
    if "table_caption" in styles:
        styles["table_caption"] = infer_fonts(styles["table_caption"], fallback_map["table_caption"])

    return profile


def set_run_fonts(run, east_asia_font: str, latin_font: str, size_pt: float, *, bold: bool = False) -> None:
    run.bold = bold
    run.font.size = Pt(size_pt)
    run.font.name = latin_font
    r_pr = run._element.get_or_add_rPr()
    r_fonts = r_pr.rFonts
    if r_fonts is None:
        r_fonts = OxmlElement("w:rFonts")
        r_pr.append(r_fonts)
    r_fonts.set(qn("w:eastAsia"), east_asia_font)
    r_fonts.set(qn("w:ascii"), latin_font)
    r_fonts.set(qn("w:hAnsi"), latin_font)


def apply_paragraph_style(paragraph, style: dict[str, Any]) -> None:
    paragraph.alignment = ALIGNMENT_MAP.get(style.get("alignment", "left"), WD_ALIGN_PARAGRAPH.LEFT)
    paragraph.paragraph_format.line_spacing_rule = (
        WD_LINE_SPACING.SINGLE if style.get("line_spacing_rule") == "single" else WD_LINE_SPACING.MULTIPLE
    )
    paragraph.paragraph_format.line_spacing = style.get("line_spacing", 1.25)
    paragraph.paragraph_format.first_line_indent = Pt(style.get("first_line_indent_pt", 0))
    paragraph.paragraph_format.left_indent = Pt(style.get("left_indent_pt", 0))
    paragraph.paragraph_format.space_before = Pt(style.get("space_before_pt", 0))
    paragraph.paragraph_format.space_after = Pt(style.get("space_after_pt", 0))
    if style.get("page_break_before"):
        add_page_break_before(paragraph)
    for run in paragraph.runs:
        set_run_fonts(
            run,
            style["east_asia_font"],
            style["latin_font"],
            style["size_pt"],
            bold=style.get("bold", False),
        )


def add_page_break_before(paragraph) -> None:
    p_pr = paragraph._p.get_or_add_pPr()
    page_break_before = OxmlElement("w:pageBreakBefore")
    p_pr.append(page_break_before)


def load_image_map(path: Path | None) -> dict[str, Path]:
    if path is None or not path.exists():
        return {}
    data = json.loads(path.read_text(encoding="utf-8"))
    return {k: Path(v) for k, v in data.items()}


def add_image(doc: Document, path: Path) -> None:
    paragraph = doc.add_paragraph()
    paragraph.alignment = WD_ALIGN_PARAGRAPH.CENTER
    paragraph.add_run().add_picture(str(path), width=Cm(14.5))


def add_missing_asset_placeholder(doc: Document, label: str, styles: dict[str, Any]) -> None:
    paragraph = doc.add_paragraph()
    paragraph.add_run(f"【待补素材：{label}】")
    apply_paragraph_style(paragraph, styles["missing_asset"])


def normalize_text(text: str) -> str:
    return cleanup_inline_markdown(text)


def add_markdown_table(doc: Document, lines: list[str], styles: dict[str, Any]) -> None:
    rows = []
    for row in lines:
        cells = [normalize_text(cell.strip()) for cell in row.strip().strip("|").split("|")]
        if all(re.fullmatch(r"[:\- ]+", cell or "") for cell in cells):
            continue
        rows.append(cells)
    if len(rows) < 2:
        return
    headers = rows[0]
    data_rows = rows[1:]
    table = doc.add_table(rows=1 + len(data_rows), cols=len(headers))
    table.style = "Table Grid"
    table.alignment = WD_TABLE_ALIGNMENT.CENTER
    for idx, text in enumerate(headers):
        table.rows[0].cells[idx].text = text
    for row_index, row in enumerate(data_rows, start=1):
        for cell_index, text in enumerate(row):
            if cell_index < len(table.rows[row_index].cells):
                table.rows[row_index].cells[cell_index].text = text
    for row in table.rows:
        for cell in row.cells:
            cell.vertical_alignment = WD_ALIGN_VERTICAL.CENTER
            for paragraph in cell.paragraphs:
                apply_paragraph_style(paragraph, styles["table_text"])


def apply_keyword_runs(paragraph, label: str, content: str, styles: dict[str, Any]) -> None:
    apply_paragraph_style(paragraph, styles["keywords_paragraph"])
    if label.startswith("关键词"):
        label_style = styles["keywords_cn_label"]
        content_style = styles["keywords_cn_content"]
    else:
        label_style = styles["keywords_en_label"]
        content_style = styles["keywords_en_content"]

    label_run = paragraph.add_run(label)
    set_run_fonts(
        label_run,
        label_style["east_asia_font"],
        label_style["latin_font"],
        label_style["size_pt"],
        bold=label_style.get("bold", False),
    )

    if content:
        spacer = "" if label.endswith(("：", ":")) else " "
        content_run = paragraph.add_run(f"{spacer}{normalize_text(content)}")
        set_run_fonts(
            content_run,
            content_style["east_asia_font"],
            content_style["latin_font"],
            content_style["size_pt"],
            bold=content_style.get("bold", False),
        )


def build_doc(source: Path, image_map: dict[str, Path], profile: dict[str, Any]) -> Document:
    styles = profile["styles"]
    doc = Document()
    section = doc.sections[0]
    section.top_margin = Cm(2.54)
    section.bottom_margin = Cm(2.54)
    section.left_margin = Cm(3.17)
    section.right_margin = Cm(3.17)

    lines = source.read_text(encoding="utf-8").splitlines()
    current_section = ""
    in_code = False
    code_lang = ""
    pending_mermaid = False
    seen_content = False
    index = 0

    while index < len(lines):
        line = lines[index]
        stripped = line.strip()

        if in_code:
            if stripped.startswith("```"):
                in_code = False
                if code_lang == "mermaid":
                    pending_mermaid = True
                code_lang = ""
            elif code_lang != "mermaid":
                paragraph = doc.add_paragraph()
                paragraph.add_run(line.rstrip())
                apply_paragraph_style(paragraph, styles["code"])
            index += 1
            continue

        if not stripped:
            index += 1
            continue

        if stripped == "---":
            index += 1
            continue

        if stripped.startswith("```"):
            in_code = True
            code_lang = stripped[3:].strip().lower()
            index += 1
            continue

        if stripped.startswith("# "):
            paragraph = doc.add_paragraph()
            paragraph.add_run(normalize_text(stripped[2:].strip()))
            apply_paragraph_style(paragraph, styles["title"])
            seen_content = True
            index += 1
            continue

        if stripped.startswith("## "):
            text = normalize_text(stripped[3:].strip())
            normalized = text.replace(" ", "").lower()
            style_key = SPECIAL_CENTERED_HEADINGS.get(normalized, "heading1")
            paragraph = doc.add_paragraph()
            paragraph.add_run(text)
            if seen_content and style_key == "heading1":
                style = deep_merge(styles["heading1"], {"page_break_before": True})
            else:
                style = styles[style_key]
            apply_paragraph_style(paragraph, style)
            current_section = text
            seen_content = True
            index += 1
            continue

        if stripped.startswith("### "):
            paragraph = doc.add_paragraph()
            paragraph.add_run(normalize_text(stripped[4:].strip()))
            apply_paragraph_style(paragraph, styles["heading2"])
            seen_content = True
            index += 1
            continue

        if stripped.startswith("#### "):
            paragraph = doc.add_paragraph()
            paragraph.add_run(normalize_text(stripped[5:].strip()))
            apply_paragraph_style(paragraph, styles["heading3"])
            seen_content = True
            index += 1
            continue

        keyword_match = re.match(r"^(关键词[:：]|Keywords[:：])\s*(.*)$", stripped)
        if keyword_match:
            paragraph = doc.add_paragraph()
            apply_keyword_runs(paragraph, keyword_match.group(1), keyword_match.group(2), styles)
            seen_content = True
            index += 1
            continue

        image_match = SCREENSHOT_PLACEHOLDER_RE.match(stripped)
        if image_match:
            label = image_match.group(1).strip()
            image_path = image_map.get(label)
            if image_path and image_path.exists():
                add_image(doc, image_path)
            else:
                add_missing_asset_placeholder(doc, label, styles)
            seen_content = True
            index += 1
            continue

        if re.match(r"^图\s*\d+(\.\d+)?", stripped):
            caption = normalize_text(stripped)
            if pending_mermaid:
                image_path = image_map.get(caption)
                if image_path and image_path.exists():
                    add_image(doc, image_path)
                else:
                    add_missing_asset_placeholder(doc, caption, styles)
                pending_mermaid = False
            paragraph = doc.add_paragraph()
            paragraph.add_run(caption)
            apply_paragraph_style(paragraph, styles["figure_caption"])
            seen_content = True
            index += 1
            continue

        if re.match(r"^表\s*\d+(\.\d+)?", stripped):
            paragraph = doc.add_paragraph()
            paragraph.add_run(normalize_text(stripped))
            apply_paragraph_style(paragraph, styles["table_caption"])
            seen_content = True
            index += 1
            continue

        if stripped.startswith("|"):
            table_lines = []
            while index < len(lines) and lines[index].strip().startswith("|"):
                table_lines.append(lines[index].strip())
                index += 1
            add_markdown_table(doc, table_lines, styles)
            seen_content = True
            continue

        paragraph = doc.add_paragraph()
        paragraph.add_run(normalize_text(stripped))
        if current_section.replace(" ", "") == "参考文献" and re.match(r"^\[\d+\]", stripped):
            apply_paragraph_style(paragraph, styles["references_body"])
        elif current_section.lower() == "abstract":
            apply_paragraph_style(paragraph, styles["body_en"])
        else:
            apply_paragraph_style(paragraph, styles["body_cn"])
        seen_content = True
        index += 1

    return doc


def parse_args() -> argparse.Namespace:
    parser = argparse.ArgumentParser(description="Generate thesis DOCX from markdown source.")
    parser.add_argument("source", type=Path)
    parser.add_argument("target", type=Path)
    parser.add_argument("legacy_image_map", nargs="?", type=Path, help="Optional image map for backward compatibility.")
    parser.add_argument("--image-map", dest="image_map", type=Path, default=None)
    parser.add_argument("--style-profile", dest="style_profile", type=Path, default=None)
    return parser.parse_args()


def main() -> int:
    args = parse_args()
    image_map_path = args.image_map or args.legacy_image_map
    profile = load_style_profile(args.style_profile)
    image_map = load_image_map(image_map_path)
    args.target.parent.mkdir(parents=True, exist_ok=True)
    document = build_doc(args.source, image_map, profile)
    document.save(args.target)
    print(args.target)
    return 0


if __name__ == "__main__":
    raise SystemExit(main())