Nsfc Abstract

skill_info:
  name: nsfc-abstract
  version: 2.1.2
  description: NSFC 标书中英文摘要生成（英文为中文的忠实翻译）与长度校验
  author: "Bensz Conan"
  category: writing

limits:
  zh_max_chars: 400
  en_max_chars: 4000
  content_points_min: 3
  content_points_max: 4
  zh_recommended_sentences: 5

format:
  # 用于脚本与示例的分段标记；不要求用户在最终标书里保留这些标记
  zh_begin: "[ZH]"
  zh_end: "[/ZH]"
  en_begin: "[EN]"
  en_end: "[/EN]"
  field_begin: "[FIELD]"
  field_end: "[/FIELD]"

output:
  filename: "NSFC-ABSTRACTS.md"
  zh_heading: "# 中文摘要"
  en_heading: "# English Abstract"
  field_heading: "# 主要研究领域"

title:
  # Whether title suggestions are required in the final output.
  title_required: true
  # Default number of title candidates to provide (in addition to the recommended title line).
  title_candidates_default: 5
  # Optional marker-format for machine parsing.
  title_begin: "[TITLE]"
  title_end: "[/TITLE]"
  # Markdown heading for the title section in NSFC-ABSTRACTS.md
  title_heading: "# 标题建议"

field:
  # Whether "主要研究领域" is required in the final output.
  field_required: true
  # Max Chinese characters (汉字) for the field sentence; 0 = no limit.
  field_max_chars: 25

（示例：仅用于演示输出格式与长度校验，不代表真实数据/结论）

标题建议：
[TITLE]
推荐标题：跨尺度可解释特征驱动的肿瘤免疫治疗反应预测与机制溯源
Recommended Title: Cross-scale Interpretable Feature-driven Prediction and Mechanism Tracing of Tumor Immunotherapy Response
1) 多模态影像与循环标志物联合特征用于免疫治疗应答预测及机制解析 —— 理由：对象与判据清楚，强调可验证终点 / EN: Multimodal Imaging and Circulating Biomarker Combined Features for Immunotherapy Response Prediction and Mechanism Analysis
2) 面向免疫治疗分层的可解释表征模型构建与关键通路验证 —— 理由：突出方法创新与验证闭环 / EN: Construction of Interpretable Representation Models and Key Pathway Validation for Immunotherapy Stratification
3) 肿瘤微环境时空异质性表征及其与免疫治疗反应的因果链研究 —— 理由：机制向，贴合生医评审口味 / EN: Characterization of Tumor Microenvironment Spatiotemporal Heterogeneity and Its Causal Links to Immunotherapy Response
4) 跨中心多模态数据标准化与免疫治疗反应评估工具开发 —— 理由：强调可行性与工程交付 / EN: Cross-center Multimodal Data Standardization and Development of Immunotherapy Response Assessment Tools
5) 可解释联合特征揭示免疫抑制通路动态变化并指导分层干预 —— 理由：整合机制+应用，但仍保留”可验证”语义 / EN: Interpretable Combined Features Reveal Dynamic Immunosuppressive Pathway Changes to Guide Stratified Intervention
[/TITLE]

中文摘要：
[ZH]
肿瘤免疫治疗显著改善部分患者预后，但对多数实体瘤仍存在应答率低与耐药等瓶颈。当前缺乏能够同时表征肿瘤微环境时空异质性与治疗反应的可解释指标体系，导致机制判断与个体化决策受限。我们前期在多中心队列中发现，基于多模态影像与循环分子标志物的联合特征可稳定区分应答/非应答人群，并提示关键免疫抑制通路的动态变化，据此提出“跨尺度可解释特征驱动的反应预测与机制溯源”假说。本项目拟：（1）构建跨中心的多模态数据规范与质控流程；（2）建立可解释表征模型，解析与免疫反应相关的关键特征；（3）在动物模型与前瞻性队列中验证关键通路与预测口径；（4）形成可复用的评估工具与干预靶点线索。预期阐明影响免疫治疗反应的关键机制并提供可落地的分层评估策略，为提升实体瘤治疗获益提供新思路。
[/ZH]

English Abstract:
[EN]
Immunotherapy has improved outcomes for some patients, yet most solid tumors still suffer from low response rates and drug resistance. A major limitation is the lack of interpretable metrics that jointly capture the spatiotemporal heterogeneity of the tumor microenvironment and treatment responses, which hampers mechanistic understanding and personalized decision-making. In our multicenter pilot cohorts, we found that combined features from multimodal imaging and circulating molecular biomarkers can robustly distinguish responders from non-responders and indicate dynamic changes in key immunosuppressive pathways; therefore, we hypothesize that cross-scale interpretable features can drive response prediction and mechanism tracing. This project will (1) build cross-center standards and quality control for multimodal data, (2) develop interpretable representation models to identify key features associated with immune responses, (3) validate critical pathways and prediction criteria in animal models and prospective cohorts, and (4) deliver reusable assessment tools and actionable clues for intervention targets. We expect to elucidate key mechanisms underlying immunotherapy responses and provide practical stratification strategies to improve clinical benefits for solid tumors.
[/EN]

主要研究领域：
[FIELD]
肿瘤微环境免疫调控与免疫治疗反应预测
[/FIELD]

#!/usr/bin/env python3
"""
Validate abstract length constraints for nsfc-abstract skill output.

Expected input contains:
  [TITLE] ... [/TITLE]   (optional / configurable)
  [ZH] ... [/ZH]
  [EN] ... [/EN]
  [FIELD] ... [/FIELD]   ("主要研究领域" section; optional / configurable)
"""

from __future__ import annotations

import argparse
import json
import re
import sys
from dataclasses import dataclass
from pathlib import Path
from typing import Optional, Tuple


def _read_text(path: Path) -> str:
    return path.read_text(encoding="utf-8")


def _extract_block(text: str, begin: str, end: str) -> str:
    # Non-greedy across newlines
    pattern = re.compile(re.escape(begin) + r"(.*?)" + re.escape(end), re.DOTALL)
    m = pattern.search(text)
    if not m:
        raise ValueError(f"未找到分段标记：{begin}...{end}")
    return m.group(1).strip()

def _extract_blocks_by_headings(text: str, zh_heading: str, en_heading: str) -> Tuple[str, str]:
    lines = text.splitlines()

    def _is_heading(line: str, heading: str) -> bool:
        return line.strip() == heading.strip()

    zh_i = None
    en_i = None
    for i, line in enumerate(lines):
        if zh_i is None and _is_heading(line, zh_heading):
            zh_i = i
            continue
        if en_i is None and _is_heading(line, en_heading):
            en_i = i
            continue

    if zh_i is None or en_i is None or zh_i > en_i:
        raise ValueError(f"未找到标题分段：{zh_heading} 与 {en_heading}")

    zh = "\n".join(lines[zh_i + 1 : en_i]).strip()

    # EN content ends at the next markdown heading (any level) if present,
    # e.g. "## 长度自检" appended by writer script.
    en_lines = []
    for line in lines[en_i + 1 :]:
        if line.lstrip().startswith("#"):
            break
        en_lines.append(line)
    en = "\n".join(en_lines).strip()
    if not zh or not en:
        raise ValueError("标题分段已找到，但内容为空（请在标题下方写入正文）")
    return zh, en


def _normalize_for_count(text: str) -> str:
    # Abstracts are typically submitted as a single paragraph. Users may format
    # outputs with newlines/spaces for readability; count after collapsing
    # whitespace to reduce surprises.
    return re.sub(r"\s+", " ", text).strip()

def _count_ascii_double_quotes(text: str) -> int:
    # In Chinese abstracts, avoid ASCII double quotes. Prefer the Chinese form instead.
    return text.count('"')  # ASCII double-quote U+0022

def _count_other_nonstandard_quotes(text: str) -> int:
    # Detect non-standard double-quote-like chars other than ASCII “ and the allowed “...” (U+201C/U+201D).
    # Includes: fullwidth ＂ (U+FF02), decorative 〝〞, corner brackets 「」『』.
    bad = '\uff02\u301d\u301e\u300c\u300d\u300e\u300f'
    return sum(text.count(c) for c in bad)

def _count_numeric_commas(text: str) -> int:
    # In Chinese abstracts, avoid comma as number separator, e.g. "1,000" / "1，000".
    # Only count commas that appear *between* digits to avoid false positives.
    return len(re.findall(r"(?<=\d)[,，](?=\d)", text))

def _count_cjk_chars(text: str) -> int:
    """Count Chinese/CJK unified ideograph characters only (汉字)."""
    return sum(
        1 for ch in text
        if '\u4e00' <= ch <= '\u9fff'
        or '\u3400' <= ch <= '\u4dbf'
        or '\U00020000' <= ch <= '\U0002a6df'
    )

def _parse_bool(v: Optional[str], default: bool) -> bool:
    if v is None:
        return default
    s = v.strip().lower()
    if s in {"1", "true", "yes", "y", "on"}:
        return True
    if s in {"0", "false", "no", "n", "off"}:
        return False
    return default


@dataclass(frozen=True)
class SkillConfig:
    zh_max: int
    en_max: int
    zh_begin: str
    zh_end: str
    en_begin: str
    en_end: str
    zh_heading: str
    en_heading: str
    out_name: str
    title_required: bool
    title_candidates_default: int
    title_begin: str
    title_end: str
    title_heading: str
    field_required: bool
    field_max_chars: int
    field_begin: str
    field_end: str
    field_heading: str


def _load_limits_from_config(skill_root: Path) -> SkillConfig:
    """
    Avoid external deps (PyYAML). We only need a few scalar fields, so parse by regex.
    """
    config_path = skill_root / "config.yaml"
    if not config_path.exists():
        return SkillConfig(
            zh_max=400,
            en_max=4000,
            zh_begin="[ZH]",
            zh_end="[/ZH]",
            en_begin="[EN]",
            en_end="[/EN]",
            zh_heading="# 中文摘要",
            en_heading="# English Abstract",
            out_name="NSFC-ABSTRACTS.md",
            title_required=False,
            title_candidates_default=5,
            title_begin="[TITLE]",
            title_end="[/TITLE]",
            title_heading="# 标题建议",
            field_required=False,
            field_max_chars=25,
            field_begin="[FIELD]",
            field_end="[/FIELD]",
            field_heading="# 主要研究领域",
        )

    raw = config_path.read_text(encoding="utf-8")

    def _strip_inline_comment(value: str) -> str:
        v = value.lstrip()
        if not v:
            return v
        if v[0] in {"\"", "'"}:
            q = v[0]
            out = []
            escaped = False
            for ch in v[1:]:
                if escaped:
                    out.append(ch)
                    escaped = False
                    continue
                if ch == "\\":
                    escaped = True
                    continue
                if ch == q:
                    break
                out.append(ch)
            return "".join(out)
        return v.split("#", 1)[0].rstrip()

    def _get_scalar(key: str) -> Optional[str]:
        # NOTE: use real whitespace class `[ \t]` (not `\\t`), otherwise it would also match literal 't'.
        m = re.search(rf"^[ \t]*{re.escape(key)}:[ \t]*(.+?)\s*$", raw, re.M)
        if not m:
            return None
        return _strip_inline_comment(m.group(1)).strip()

    def _int(key: str, default: int) -> int:
        v = _get_scalar(key)
        if v is None:
            return default
        return int(v) if v.isdigit() else default

    def _str(key: str, default: str) -> str:
        v = _get_scalar(key)
        return v if v is not None and v != "" else default

    zh_max = _int("zh_max_chars", 400)
    en_max = _int("en_max_chars", 4000)
    zh_begin = _str("zh_begin", "[ZH]")
    zh_end = _str("zh_end", "[/ZH]")
    en_begin = _str("en_begin", "[EN]")
    en_end = _str("en_end", "[/EN]")
    zh_heading = _str("zh_heading", "# 中文摘要")
    en_heading = _str("en_heading", "# English Abstract")
    out_name = _str("filename", "NSFC-ABSTRACTS.md")

    title_required = _parse_bool(_get_scalar("title_required"), False)
    title_candidates_default = _int("title_candidates_default", 5)
    title_begin = _str("title_begin", "[TITLE]")
    title_end = _str("title_end", "[/TITLE]")
    title_heading = _str("title_heading", "# 标题建议")

    field_required = _parse_bool(_get_scalar("field_required"), False)
    field_max_chars = _int("field_max_chars", 25)
    field_begin = _str("field_begin", "[FIELD]")
    field_end = _str("field_end", "[/FIELD]")
    field_heading = _str("field_heading", "# 主要研究领域")

    return SkillConfig(
        zh_max=zh_max,
        en_max=en_max,
        zh_begin=zh_begin,
        zh_end=zh_end,
        en_begin=en_begin,
        en_end=en_end,
        zh_heading=zh_heading,
        en_heading=en_heading,
        out_name=out_name,
        title_required=title_required,
        title_candidates_default=title_candidates_default,
        title_begin=title_begin,
        title_end=title_end,
        title_heading=title_heading,
        field_required=field_required,
        field_max_chars=field_max_chars,
        field_begin=field_begin,
        field_end=field_end,
        field_heading=field_heading,
    )


def _extract_section_by_heading(text: str, heading: str) -> Optional[str]:
    lines = text.splitlines()

    def _is_heading(line: str, h: str) -> bool:
        return line.strip() == h.strip()

    start_i = None
    for i, line in enumerate(lines):
        if _is_heading(line, heading):
            start_i = i
            break
    if start_i is None:
        return None
    body_lines = []
    for line in lines[start_i + 1 :]:
        if line.lstrip().startswith("#"):
            break
        body_lines.append(line)
    body = "\n".join(body_lines).strip()
    return body or None


def _extract_title_by_headings(text: str, title_heading: str, zh_heading: str) -> Optional[str]:
    lines = text.splitlines()

    def _is_heading(line: str, heading: str) -> bool:
        return line.strip() == heading.strip()

    t_i = None
    zh_i = None
    for i, line in enumerate(lines):
        if t_i is None and _is_heading(line, title_heading):
            t_i = i
            continue
        if zh_i is None and _is_heading(line, zh_heading):
            zh_i = i
            continue

    if t_i is None:
        return None

    end_i = zh_i if (zh_i is not None and zh_i > t_i) else len(lines)
    body = "\n".join(lines[t_i + 1 : end_i]).strip()
    return body or None


def build_title_report(title_raw: Optional[str], *, required: bool, min_candidates: int) -> dict:
    title = (title_raw or "").strip()
    present = bool(title)
    recommended_ok = bool(re.search(r"(?m)^\s*推荐标题\s*[:：]\s*\S+", title))
    cand_lines = re.findall(r"(?m)^\s*(?:[-*]\s*)?\d+[\)\.、]\s+\S+", title)
    cand_n = len(cand_lines)
    ok = (not required) or (present and recommended_ok and cand_n >= int(min_candidates))
    return {
        "present": present,
        "required": bool(required),
        "has_recommended": recommended_ok,
        "candidates": cand_n,
        "min_candidates": int(min_candidates),
        "ok": ok,
    }

def build_field_report(field_raw: Optional[str], *, required: bool, max_chars: int = 25) -> dict:
    field = (field_raw or "").strip()
    present = bool(field)
    cjk_count = _count_cjk_chars(field) if field else 0
    len_ok = (max_chars <= 0) or (cjk_count <= max_chars)
    ok = ((not required) or present) and len_ok
    return {
        "present": present,
        "required": bool(required),
        "cjk_chars": cjk_count,
        "max_chars": max_chars,
        "len_ok": len_ok,
        "ok": ok,
    }


def _build_report(zh_raw: str, en_raw: str, *, zh_max: int, en_max: int) -> dict:
    """
    Build a machine-readable report.

    Note: length counting collapses consecutive whitespace into a single space.
    """
    zh = _normalize_for_count(zh_raw)
    en = _normalize_for_count(en_raw)

    zh_len = len(zh)
    en_len = len(en)
    zh_exceeded = max(0, zh_len - zh_max)
    en_exceeded = max(0, en_len - en_max)

    zh_ascii_dq = _count_ascii_double_quotes(zh_raw)
    zh_numeric_commas = _count_numeric_commas(zh_raw)
    zh_punct_ok = zh_ascii_dq == 0
    zh_num_ok = zh_numeric_commas == 0
    zh_len_ok = zh_exceeded == 0

    en_len_ok = en_exceeded == 0

    return {
        "zh": {
            "len": zh_len,
            "max": zh_max,
            "exceeded": zh_exceeded,
            "len_ok": zh_len_ok,
            "ascii_double_quotes": zh_ascii_dq,
            "numeric_commas": zh_numeric_commas,
            "punct_ok": zh_punct_ok,
            "num_ok": zh_num_ok,
            "ok": zh_len_ok and zh_punct_ok and zh_num_ok,
        },
        "en": {
            "len": en_len,
            "max": en_max,
            "exceeded": en_exceeded,
            "len_ok": en_len_ok,
            "ok": en_len_ok,
        },
    }


# Public alias for reuse by other scripts (write_abstracts_md.py).
build_report = _build_report


def main(argv: list[str]) -> int:
    ap = argparse.ArgumentParser(
        formatter_class=argparse.RawTextHelpFormatter,
        description=(
            "Validate nsfc-abstract output constraints.\n"
            "It extracts ZH/EN blocks, then counts characters. Title/Field sections may be required by config.\n"
            "Counting collapses consecutive whitespace into a single space by default.\n"
            "In --strict mode, it also enforces: ZH no ASCII double quotes (\") and no digit-comma-digit (1,000)."
        ),
        epilog=(
            "Exit codes:\n"
            "  0  success (and within limits when --strict is used)\n"
            "  1  constraint violations with --strict\n"
            "  2  input format error / missing required sections\n"
        ),
    )
    ap.add_argument("file", help="包含 [ZH]/[EN] 分段标记的文本文件路径（或 - 表示 stdin）")
    ap.add_argument("--strict", action="store_true", help="严格模式：超限/中文标点/数字格式不合规则返回非 0")
    ap.add_argument("--json", action="store_true", help="以 JSON 输出结果（机器可读；仅打印 JSON）")
    ap.add_argument("--diff", action="store_true", help="输出超出字符数（exceeded= max(0, len-max)）")
    ap.add_argument(
        "--require-title",
        action="store_true",
        help="要求存在标题建议分段（默认取 config.yaml:title.title_required）",
    )
    ap.add_argument(
        "--no-title",
        action="store_true",
        help="忽略标题建议分段（不做检查；向后兼容旧输出）",
    )
    ap.add_argument(
        "--min-title-candidates",
        type=int,
        default=0,
        help="标题候选最少数量（默认取 config.yaml:title.title_candidates_default；0 表示使用默认值）",
    )
    ap.add_argument(
        "--require-field",
        action="store_true",
        help="要求存在“主要研究领域”分段（默认取 config.yaml:field.field_required）",
    )
    ap.add_argument(
        "--no-field",
        action="store_true",
        help="忽略“主要研究领域”分段（不做检查；向后兼容旧输出）",
    )
    args = ap.parse_args(argv)

    skill_root = Path(__file__).resolve().parents[1]
    cfg = _load_limits_from_config(skill_root)

    if args.file == "-":
        text = sys.stdin.read()
    else:
        text = _read_text(Path(args.file))

    zh_raw = None
    en_raw = None
    try:
        zh_raw = _extract_block(text, cfg.zh_begin, cfg.zh_end)
        en_raw = _extract_block(text, cfg.en_begin, cfg.en_end)
    except ValueError:
        # Fall back to heading-based extraction.
        try:
            zh_raw, en_raw = _extract_blocks_by_headings(text, cfg.zh_heading, cfg.en_heading)
        except ValueError as e:
            print(f"[ERROR] {e}", file=sys.stderr)
            print("", file=sys.stderr)
            print("修复提示（两种任选其一）：", file=sys.stderr)
            print("A) 标记格式：", file=sys.stderr)
            print(f"{cfg.zh_begin}\n（中文摘要正文）\n{cfg.zh_end}", file=sys.stderr)
            print(f"{cfg.en_begin}\n(English abstract translation)\n{cfg.en_end}", file=sys.stderr)
            print(f"{cfg.field_begin}\n- （主要研究领域要点）\n{cfg.field_end}", file=sys.stderr)
            print("", file=sys.stderr)
            print("B) 标题格式（推荐，便于直接保存为文件）：", file=sys.stderr)
            print(
                f"{cfg.zh_heading}\n（中文摘要正文）\n\n{cfg.en_heading}\n(English abstract translation)\n\n{cfg.field_heading}\n- （主要研究领域要点）",
                file=sys.stderr,
            )
            print("", file=sys.stderr)
            print(f"提示：本 skill 约定输出文件为工作目录下的 `{cfg.out_name}`（可用 write_abstracts_md.py 生成）。", file=sys.stderr)
            return 2

    zh_raw_len = len(zh_raw)
    en_raw_len = len(en_raw)

    report = _build_report(zh_raw, en_raw, zh_max=cfg.zh_max, en_max=cfg.en_max)
    zh_ok = bool(report["zh"]["ok"])
    en_ok = bool(report["en"]["ok"])

    # Title section (optional, but required by config/flags).
    title_required = bool(args.require_title or cfg.title_required) and (not args.no_title)
    min_cands = int(args.min_title_candidates) if int(args.min_title_candidates) > 0 else int(cfg.title_candidates_default)
    title_raw: Optional[str] = None
    if not args.no_title:
        try:
            title_raw = _extract_block(text, cfg.title_begin, cfg.title_end)
        except ValueError:
            title_raw = _extract_title_by_headings(text, cfg.title_heading, cfg.zh_heading)
    title_report = build_title_report(title_raw, required=title_required, min_candidates=min_cands)
    report["title"] = title_report

    # Field section (optional, but may be required by config/flags).
    field_required = bool(args.require_field or cfg.field_required) and (not args.no_field)
    field_raw: Optional[str] = None
    if not args.no_field:
        try:
            field_raw = _extract_block(text, cfg.field_begin, cfg.field_end)
        except ValueError:
            field_raw = _extract_section_by_heading(text, cfg.field_heading)
    field_report = build_field_report(field_raw, required=field_required, max_chars=cfg.field_max_chars)
    report["field"] = field_report

    if title_required and not title_report["present"]:
        if args.json:
            # Still emit the report for machine debugging.
            sys.stdout.write(json.dumps(report, ensure_ascii=False))
            sys.stdout.write("\n")
        else:
            print("", file=sys.stderr)
            print("[ERROR] 缺少标题建议分段。修复提示：", file=sys.stderr)
            print(f"{cfg.title_begin}\n推荐标题：...\n1) ... —— 理由：...\n2) ... —— 理由：...\n...\n{cfg.title_end}", file=sys.stderr)
            print("", file=sys.stderr)
            print("或使用 Markdown 标题：", file=sys.stderr)
            print(
                f"{cfg.title_heading}\n推荐标题：...\n1) ... —— 理由：...\n...\n\n{cfg.zh_heading}\n（中文摘要正文）",
                file=sys.stderr,
            )
        return 2

    if field_required and not field_report["present"]:
        if args.json:
            sys.stdout.write(json.dumps(report, ensure_ascii=False))
            sys.stdout.write("\n")
        else:
            print("", file=sys.stderr)
            print("[ERROR] 缺少“主要研究领域”分段。修复提示：", file=sys.stderr)
            print(f"{cfg.field_begin}\n- ...\n{cfg.field_end}", file=sys.stderr)
            print("", file=sys.stderr)
            print("或使用 Markdown 标题：", file=sys.stderr)
            print(f"{cfg.field_heading}\n- ...\n\n{cfg.zh_heading}\n（中文摘要正文）", file=sys.stderr)
        return 2

    if args.json:
        # Keep stdout strictly machine-readable.
        sys.stdout.write(json.dumps(report, ensure_ascii=False))
        sys.stdout.write("\n")
        if args.strict and (not zh_ok or not en_ok or not title_report["ok"] or not field_report["ok"]):
            return 1
        return 0

    print("Length Check (whitespace-collapsed)")
    print(f"- Limits: ZH<= {cfg.zh_max}, EN<= {cfg.en_max}")
    print(
        f"- Markers: ZH {cfg.zh_begin}..{cfg.zh_end}; EN {cfg.en_begin}..{cfg.en_end}; FIELD {cfg.field_begin}..{cfg.field_end}"
    )
    print(f"- Headings: ZH {cfg.zh_heading}; EN {cfg.en_heading}; FIELD {cfg.field_heading}")

    def _status(lang_report: dict) -> str:
        if not lang_report.get("len_ok", True):
            return "EXCEEDED"
        if lang_report.get("punct_ok", True) is False:
            return "INVALID_PUNCT"
        if lang_report.get("num_ok", True) is False:
            return "INVALID_NUM"
        return "OK"

    print(
        f"- ZH: {report['zh']['len']}/{cfg.zh_max} ({_status(report['zh'])}) [raw={zh_raw_len}]"
        + (f" [exceeded={report['zh']['exceeded']}]" if args.diff else "")
    )
    if report["zh"].get("ascii_double_quotes", 0) > 0:
        print(f"- ZH quotes: ASCII (\") = {report['zh']['ascii_double_quotes']} (请改为中文引号“...”)")
    if report["zh"].get("numeric_commas", 0) > 0:
        print(f"- ZH numbers: digit-comma-digit = {report['zh']['numeric_commas']} (请改为 1000 而不是 1,000)")
    print(
        f"- EN: {report['en']['len']}/{cfg.en_max} ({_status(report['en'])}) [raw={en_raw_len}]"
        + (f" [exceeded={report['en']['exceeded']}]" if args.diff else "")
    )
    if not args.no_title:
        print(
            f"- TITLE: {'OK' if title_report['ok'] else 'INVALID'} "
            f"[required={title_required}, candidates={title_report['candidates']}/{min_cands}, "
            f"recommended={title_report['has_recommended']}]"
        )
    if not args.no_field:
        print(
            f"- FIELD: {'OK' if field_report['ok'] else 'INVALID'} "
            f"[required={field_required}, cjk={field_report.get('cjk_chars', 0)}/{cfg.field_max_chars}]"
        )

    if args.strict and (not zh_ok or not en_ok or not title_report["ok"] or not field_report["ok"]):
        return 1
    return 0


if __name__ == "__main__":
    raise SystemExit(main(sys.argv[1:]))

#!/usr/bin/env python3
"""
Write NSFC-ABSTRACTS.md in the current working directory.

Input formats supported:
  1) Marker format: [ZH]...[/ZH] and [EN]...[/EN]
  2) Markdown headings: "# 中文摘要" and "# English Abstract" (headings configurable)

This script is intentionally stdlib-only (no PyYAML).
"""

from __future__ import annotations

import argparse
import json
import re
import sys
from dataclasses import dataclass
from pathlib import Path
from typing import Optional, Tuple


def _extract_block_by_markers(text: str, begin: str, end: str) -> Optional[str]:
    pattern = re.compile(re.escape(begin) + r"(.*?)" + re.escape(end), re.DOTALL)
    m = pattern.search(text)
    return m.group(1).strip() if m else None


def _extract_block_by_headings(text: str, zh_heading: str, en_heading: str) -> Optional[Tuple[str, str]]:
    # Normalize line endings and keep original content lines.
    lines = text.splitlines()

    def _is_heading(line: str, heading: str) -> bool:
        return line.strip() == heading.strip()

    zh_i = None
    en_i = None
    for i, line in enumerate(lines):
        if zh_i is None and _is_heading(line, zh_heading):
            zh_i = i
            continue
        if en_i is None and _is_heading(line, en_heading):
            en_i = i
            continue

    if zh_i is None or en_i is None:
        return None
    if zh_i > en_i:
        # If swapped, treat as invalid format.
        return None

    zh_lines = lines[zh_i + 1 : en_i]
    zh = "\n".join(zh_lines).strip()
    # EN content ends at the next markdown heading (any level) if present,
    # e.g. "## 长度自检" appended by this script itself.
    en_lines = []
    for line in lines[en_i + 1 :]:
        if line.lstrip().startswith("#"):
            break
        en_lines.append(line)
    en = "\n".join(en_lines).strip()
    return zh, en


def _normalize_for_count(text: str) -> str:
    return re.sub(r"\s+", " ", text).strip()


def _read_text(path: Path) -> str:
    return path.read_text(encoding="utf-8")

def _is_safe_filename(name: str) -> bool:
    """
    Ensure output stays in current working directory.
    Reject absolute paths, parent segments, or nested paths like "a/b.md".
    """
    s = (name or "").strip()
    if not s or s in {".", ".."}:
        return False
    p = Path(s)
    if p.is_absolute():
        return False
    if len(p.parts) != 1:
        return False
    if any(part in {".", ".."} for part in p.parts):
        return False
    return True

def _parse_bool(v: Optional[str], default: bool) -> bool:
    if v is None:
        return default
    s = v.strip().lower()
    if s in {"1", "true", "yes", "y", "on"}:
        return True
    if s in {"0", "false", "no", "n", "off"}:
        return False
    return default


@dataclass(frozen=True)
class SkillConfig:
    zh_max: int
    en_max: int
    zh_begin: str
    zh_end: str
    en_begin: str
    en_end: str
    out_name: str
    zh_heading: str
    en_heading: str
    title_required: bool
    title_candidates_default: int
    title_begin: str
    title_end: str
    title_heading: str
    field_required: bool
    field_max_chars: int
    field_begin: str
    field_end: str
    field_heading: str


def _load_config(skill_root: Path) -> SkillConfig:
    """
    Minimal config reader (no YAML deps). It searches for scalar keys by regex.
    """
    config_path = skill_root / "config.yaml"
    raw = config_path.read_text(encoding="utf-8") if config_path.exists() else ""

    def _strip_inline_comment(value: str) -> str:
        v = value.lstrip()
        if not v:
            return v
        if v[0] in {"\"", "'"}:
            q = v[0]
            out = []
            escaped = False
            for ch in v[1:]:
                if escaped:
                    out.append(ch)
                    escaped = False
                    continue
                if ch == "\\":
                    escaped = True
                    continue
                if ch == q:
                    break
                out.append(ch)
            return "".join(out)
        return v.split("#", 1)[0].rstrip()

    def _get_scalar(key: str) -> Optional[str]:
        m = re.search(rf"^[ \t]*{re.escape(key)}:[ \t]*(.+?)\s*$", raw, re.M)
        if not m:
            return None
        return _strip_inline_comment(m.group(1)).strip()

    def _int(key: str, default: int) -> int:
        v = _get_scalar(key)
        if v is None:
            return default
        return int(v) if v.isdigit() else default

    def _str(key: str, default: str) -> str:
        v = _get_scalar(key)
        return v if v is not None and v != "" else default

    zh_max = _int("zh_max_chars", 400)
    en_max = _int("en_max_chars", 4000)

    zh_begin = _str("zh_begin", "[ZH]")
    zh_end = _str("zh_end", "[/ZH]")
    en_begin = _str("en_begin", "[EN]")
    en_end = _str("en_end", "[/EN]")

    out_name = _str("filename", "NSFC-ABSTRACTS.md")
    zh_heading = _str("zh_heading", "# 中文摘要")
    en_heading = _str("en_heading", "# English Abstract")

    title_required = _parse_bool(_get_scalar("title_required"), False)
    title_candidates_default = _int("title_candidates_default", 5)
    title_begin = _str("title_begin", "[TITLE]")
    title_end = _str("title_end", "[/TITLE]")
    title_heading = _str("title_heading", "# 标题建议")

    field_required = _parse_bool(_get_scalar("field_required"), False)
    field_max_chars = _int("field_max_chars", 25)
    field_begin = _str("field_begin", "[FIELD]")
    field_end = _str("field_end", "[/FIELD]")
    field_heading = _str("field_heading", "# 主要研究领域")

    return SkillConfig(
        zh_max=zh_max,
        en_max=en_max,
        zh_begin=zh_begin,
        zh_end=zh_end,
        en_begin=en_begin,
        en_end=en_end,
        out_name=out_name,
        zh_heading=zh_heading,
        en_heading=en_heading,
        title_required=title_required,
        title_candidates_default=title_candidates_default,
        title_begin=title_begin,
        title_end=title_end,
        title_heading=title_heading,
        field_required=field_required,
        field_max_chars=field_max_chars,
        field_begin=field_begin,
        field_end=field_end,
        field_heading=field_heading,
    )


def _extract_section_by_heading(text: str, heading: str) -> Optional[str]:
    lines = text.splitlines()

    def _is_heading(line: str, h: str) -> bool:
        return line.strip() == h.strip()

    start_i = None
    for i, line in enumerate(lines):
        if _is_heading(line, heading):
            start_i = i
            break
    if start_i is None:
        return None

    body_lines = []
    for line in lines[start_i + 1 :]:
        if line.lstrip().startswith("#"):
            break
        body_lines.append(line)
    body = "\n".join(body_lines).strip()
    return body or None


def _extract_title_by_headings(text: str, title_heading: str, zh_heading: str) -> Optional[str]:
    lines = text.splitlines()

    def _is_heading(line: str, heading: str) -> bool:
        return line.strip() == heading.strip()

    t_i = None
    zh_i = None
    for i, line in enumerate(lines):
        if t_i is None and _is_heading(line, title_heading):
            t_i = i
            continue
        if zh_i is None and _is_heading(line, zh_heading):
            zh_i = i
            continue

    if t_i is None:
        return None
    end_i = zh_i if (zh_i is not None and zh_i > t_i) else len(lines)
    body = "\n".join(lines[t_i + 1 : end_i]).strip()
    return body or None


def _parse_input(
    text: str,
    *,
    title_begin: str,
    title_end: str,
    title_heading: str,
    title_required: bool,
    title_candidates_default: int,
    zh_begin: str,
    zh_end: str,
    en_begin: str,
    en_end: str,
    field_begin: str,
    field_end: str,
    field_heading: str,
    zh_heading: str,
    en_heading: str,
) -> Tuple[Optional[str], str, str, Optional[str]]:
    title = _extract_block_by_markers(text, title_begin, title_end)
    zh = _extract_block_by_markers(text, zh_begin, zh_end)
    en = _extract_block_by_markers(text, en_begin, en_end)
    field = _extract_block_by_markers(text, field_begin, field_end)
    if zh is not None and en is not None:
        return title, zh, en, field

    by_h = _extract_block_by_headings(text, zh_heading, en_heading)
    if by_h is not None:
        zh_h, en_h = by_h
        title_h = _extract_title_by_headings(text, title_heading, zh_heading)
        field_h = _extract_section_by_heading(text, field_heading)
        return title_h, zh_h, en_h, field_h

    if title_required:
        raise ValueError(
            "无法解析输入（标题+中英文摘要是必需的；“主要研究领域”是否必需取决于 config.yaml）。请使用以下任一格式：\n"
            f"1) 标记格式：{title_begin}...{title_end} 与 {zh_begin}...{zh_end} 与 {en_begin}...{en_end}（可选：{field_begin}...{field_end}）\n"
            f"2) 标题格式：{title_heading} 与 {zh_heading} 与 {en_heading}（可选：{field_heading}）\n"
            f"并确保标题候选不少于 {title_candidates_default} 个，且包含“推荐标题：...”一行。"
        )

    raise ValueError(
        "无法解析输入。请使用以下任一格式：\n"
        f"1) 标记格式：{zh_begin}...{zh_end} 与 {en_begin}...{en_end}（可选：{field_begin}...{field_end}）\n"
        f"2) 标题格式：{zh_heading} 与 {en_heading}（可选：{field_heading}）"
    )


def main(argv: list[str]) -> int:
    ap = argparse.ArgumentParser(formatter_class=argparse.RawTextHelpFormatter)
    ap.add_argument("input", help="包含摘要内容的输入文件路径（或 - 表示 stdin）")
    ap.add_argument("--out", default=None, help="输出 Markdown 文件名（默认取 config.yaml:output.filename）")
    ap.add_argument("--strict", action="store_true", help="严格模式：超限等约束不满足则返回非 0")
    ap.add_argument(
        "--auto-compress",
        action="store_true",
        help="超限时自动压缩（占位：当前版本不执行压缩，仅提示并返回 1）",
    )
    ap.add_argument("--json", action="store_true", help="输出 JSON 报告（stdout 仅打印 JSON）")
    args = ap.parse_args(argv)

    skill_root = Path(__file__).resolve().parents[1]
    cfg = _load_config(skill_root)

    if args.input == "-":
        raw = sys.stdin.read()
    else:
        raw = _read_text(Path(args.input))

    title_raw, zh_raw, en_raw, field_raw = _parse_input(
        raw,
        title_begin=cfg.title_begin,
        title_end=cfg.title_end,
        title_heading=cfg.title_heading,
        title_required=cfg.title_required,
        title_candidates_default=cfg.title_candidates_default,
        zh_begin=cfg.zh_begin,
        zh_end=cfg.zh_end,
        en_begin=cfg.en_begin,
        en_end=cfg.en_end,
        field_begin=cfg.field_begin,
        field_end=cfg.field_end,
        field_heading=cfg.field_heading,
        zh_heading=cfg.zh_heading,
        en_heading=cfg.en_heading,
    )

    zh = zh_raw.strip()
    en = en_raw.strip()
    title = (title_raw or "").strip()
    field = (field_raw or "").strip()

    # Reuse validator's counting semantics for consistency.
    try:
        import validate_abstract  # type: ignore

        report = validate_abstract.build_report(zh, en, zh_max=cfg.zh_max, en_max=cfg.en_max)
        title_report = validate_abstract.build_title_report(
            title_raw,
            required=cfg.title_required,
            min_candidates=cfg.title_candidates_default,
        )
        field_report = validate_abstract.build_field_report(field_raw, required=cfg.field_required, max_chars=cfg.field_max_chars)
    except Exception:
        # Fallback: keep behavior even if import fails for any reason.
        zh_len = len(_normalize_for_count(zh))
        en_len = len(_normalize_for_count(en))
        zh_ascii_dq = zh.count("\"")
        zh_numeric_commas = len(re.findall(r"(?<=\d)[,，](?=\d)", zh))
        zh_punct_ok = zh_ascii_dq == 0
        zh_num_ok = zh_numeric_commas == 0
        zh_len_ok = zh_len <= cfg.zh_max
        en_len_ok = en_len <= cfg.en_max
        report = {
            "zh": {
                "len": zh_len,
                "max": cfg.zh_max,
                "exceeded": max(0, zh_len - cfg.zh_max),
                "len_ok": zh_len_ok,
                "ascii_double_quotes": zh_ascii_dq,
                "numeric_commas": zh_numeric_commas,
                "punct_ok": zh_punct_ok,
                "num_ok": zh_num_ok,
                "ok": zh_len_ok and zh_punct_ok and zh_num_ok,
            },
            "en": {
                "len": en_len,
                "max": cfg.en_max,
                "exceeded": max(0, en_len - cfg.en_max),
                "len_ok": en_len_ok,
                "ok": en_len_ok,
            },
        }
        title_report = {
            "present": bool(title),
            "required": bool(cfg.title_required),
            "has_recommended": bool(re.search(r"(?m)^\s*推荐标题\s*[:：]\s*\S+", title)),
            "candidates": len(re.findall(r"(?m)^\s*(?:[-*]\s*)?\d+[\)\.、]\s+\S+", title)),
            "min_candidates": int(cfg.title_candidates_default),
            "ok": (not cfg.title_required)
            or (
                bool(title)
                and bool(re.search(r"(?m)^\s*推荐标题\s*[:：]\s*\S+", title))
                and len(re.findall(r"(?m)^\s*(?:[-*]\s*)?\d+[\)\.、]\s+\S+", title)) >= int(cfg.title_candidates_default)
            ),
        }
        def _count_cjk(t: str) -> int:
            return sum(
                1 for ch in t
                if '\u4e00' <= ch <= '\u9fff'
                or '\u3400' <= ch <= '\u4dbf'
            )
        field_cjk = _count_cjk(field)
        field_len_ok = (cfg.field_max_chars <= 0) or (field_cjk <= cfg.field_max_chars)
        field_report = {
            "present": bool(field),
            "required": bool(cfg.field_required),
            "cjk_chars": field_cjk,
            "max_chars": cfg.field_max_chars,
            "len_ok": field_len_ok,
            "ok": ((not cfg.field_required) or bool(field)) and field_len_ok,
        }

    zh_ok = bool(report["zh"]["ok"])
    en_ok = bool(report["en"]["ok"])
    zh_len_ok = bool(report["zh"].get("len_ok", zh_ok))
    en_len_ok = bool(report["en"].get("len_ok", en_ok))
    zh_punct_ok = bool(report["zh"].get("punct_ok", True))
    zh_ascii_dq = int(report["zh"].get("ascii_double_quotes", 0) or 0)
    zh_num_ok = bool(report["zh"].get("num_ok", True))
    zh_numeric_commas = int(report["zh"].get("numeric_commas", 0) or 0)
    title_ok = bool(title_report.get("ok"))
    field_ok = bool(field_report.get("ok"))
    report["title"] = title_report
    report["field"] = field_report

    out_name = args.out or cfg.out_name
    if not _is_safe_filename(out_name):
        sys.stderr.write(f"[ERROR] 非法输出文件名：{out_name!r}（必须是当前目录下的单个文件名，不允许路径）。\n")
        if args.json:
            sys.stdout.write(json.dumps(report, ensure_ascii=False))
            sys.stdout.write("\n")
        return 2
    out_path = Path.cwd() / out_name

    if cfg.title_required and not title_ok:
        sys.stderr.write(
            "[ERROR] 缺少或不合格的标题建议分段（不写入）。\n"
            f"- required: {cfg.title_required}\n"
            f"- min candidates: {cfg.title_candidates_default}\n"
            "修复提示：在输入中加入 [TITLE]...[/TITLE] 或 \"# 标题建议\" 分段，并包含“推荐标题：...”与不少于 5 个候选条目。\n"
        )
        if args.json:
            sys.stdout.write(json.dumps(report, ensure_ascii=False))
            sys.stdout.write("\n")
        return 2

    if cfg.field_required and not field_report.get("present"):
        sys.stderr.write("[ERROR] 缺少“主要研究领域”分段（不写入）。\n")
        sys.stderr.write(f"- required: {cfg.field_required}\n")
        sys.stderr.write(f"修复提示：在输入中加入 {cfg.field_begin}...{cfg.field_end} 或 \"{cfg.field_heading}\" 分段。\n")
        if args.json:
            sys.stdout.write(json.dumps(report, ensure_ascii=False))
            sys.stdout.write("\n")
        return 2

    # Hard constraints for CN abstract formatting: always refuse to write an invalid output file.
    # Field length is always enforced (regardless of field_required) when field is present.
    if field and not field_report.get("len_ok", True):
        cjk_n = field_report.get("cjk_chars", 0)
        max_n = field_report.get("max_chars", cfg.field_max_chars)
        sys.stderr.write(f"[ERROR] “主要研究领域”超限：{cjk_n}/{max_n} 个汉字（不写入）。\n")
        sys.stderr.write(f"修复提示：压缩至 {max_n} 个汉字以内的一句话。\n")
        if args.json:
            sys.stdout.write(json.dumps(report, ensure_ascii=False))
            sys.stdout.write("\n")
        return 1
    if not zh_punct_ok:
        sys.stderr.write(f"[ERROR] 中文摘要包含英文双引号（\\\"）共 {zh_ascii_dq} 处（不写入）。\n")
        sys.stderr.write("修复提示：将英文双引号替换为中文引号“...”，避免出现 \"...\"。\n")
        if args.json:
            sys.stdout.write(json.dumps(report, ensure_ascii=False))
            sys.stdout.write("\n")
        return 1

    if not zh_num_ok:
        sys.stderr.write(f"[ERROR] 中文摘要数字格式包含“数字,数字”共 {zh_numeric_commas} 处（不写入）。\n")
        sys.stderr.write("修复提示：将 1,000 / 1，000 改为 1000（中文摘要通常不写千分位逗号）。\n")
        if args.json:
            sys.stdout.write(json.dumps(report, ensure_ascii=False))
            sys.stdout.write("\n")
        return 1

    if (args.strict or args.auto_compress) and (not zh_len_ok or not en_len_ok):
        # In strict mode, do not write an invalid output file.
        mode = "strict" if args.strict else "auto-compress"
        msg = (
            f"[ERROR] 摘要超限（{mode} 模式不写入）：ZH {report['zh']['len']}/{cfg.zh_max}；EN {report['en']['len']}/{cfg.en_max}\n"
            f"- exceeded: ZH {report['zh']['exceeded']}, EN {report['en']['exceeded']}\n"
        )
        sys.stderr.write(msg)
        if args.auto_compress:
            sys.stderr.write(
                "\n[HINT] --auto-compress 当前为占位参数：不会自动压缩。\n"
                "请按 SKILL.md 的“字数超限处理”策略手工压缩后重试。\n"
            )
        if args.json:
            sys.stdout.write(json.dumps(report, ensure_ascii=False))
            sys.stdout.write("\n")
        return 1

    title_text = ""
    if title:
        title_text = f"{cfg.title_heading}\n\n{title}\n\n"
    field_text = ""
    if field:
        field_text = f"{cfg.field_heading}\n\n{field}\n"
    out_text = (
        title_text
        + f"{cfg.zh_heading}\n\n{zh}\n"
        + f"{cfg.en_heading}\n\n{en}\n"
        + field_text
        + "## 长度自检\n"
        + f"- 中文摘要字符数：{report['zh']['len']}/{cfg.zh_max}\n"
        + f"- 英文摘要字符数：{report['en']['len']}/{cfg.en_max}\n"
    )
    out_path.write_text(out_text, encoding="utf-8")

    if args.json:
        # Keep stdout strictly machine-readable.
        sys.stdout.write(json.dumps(report, ensure_ascii=False))
        sys.stdout.write("\n")
        print(f"[OK] Wrote: {out_path}", file=sys.stderr)
    else:
        print(f"[OK] Wrote: {out_path}")
        print(f"- TITLE: {'OK' if title_ok else 'INVALID'}")
        print(f"- FIELD: {'OK' if field_ok else 'INVALID'}")
        zh_status = "OK"
        if not zh_len_ok:
            zh_status = "EXCEEDED"
        elif not zh_punct_ok:
            zh_status = "INVALID_PUNCT"
        elif not zh_num_ok:
            zh_status = "INVALID_NUM"
        en_status = "OK" if en_len_ok else "EXCEEDED"
        print(f"- ZH: {report['zh']['len']}/{cfg.zh_max} ({zh_status})")
        print(f"- EN: {report['en']['len']}/{cfg.en_max} ({en_status})")

    if args.strict and (not zh_ok or not en_ok):
        return 1
    return 0


if __name__ == "__main__":
    raise SystemExit(main(sys.argv[1:]))