Nsfc Research Foundation Writer

# ================================
# nsfc-research-foundation-writer 默认配置
# ================================

skill_info:
  name: nsfc-research-foundation-writer
  version: 0.1.2
  # template_year: 移除年份限制，使技能适用于不同年份的 NSFC 模板
  category: writing
  description: "为 NSFC 正文“（三）研究基础”写作/重构，并同步编排“工作条件/研究风险应对”（不适用：非标书正文场景）"
  author: "Bensz Conan"

parameters:
  project_root:
    type: string
    required: true
    description: 项目根目录（如 projects/NSFC_Young 或你的标书项目路径）
  output_mode:
    type: string
    required: false
    default: apply
    allowed_values: [preview, apply]
    # preview: 预览模式，只生成内容不写入文件
    # apply: 应用模式，将生成的内容写入 extraTex 文件

targets:
  foundation_tex: extraTex/3.1.研究基础.tex
  conditions_tex: extraTex/3.2.工作条件.tex

guardrails:
  allowed_write_files:
    - extraTex/3.1.研究基础.tex
    - extraTex/3.2.工作条件.tex
  forbidden_write_files:
    - main.tex
    - extraTex/@config.tex
  forbidden_write_globs:
    - "**/*.cls"
    - "**/*.sty"

quality_contract:
  foundation_must_cover:
    - 与本项目相关的研究积累（证据链）
    - 已取得的阶段性成果（可核验）
    - 可行性要点（理论/技术/团队/条件）
    - 研究风险与应对措施（显式写出）
  conditions_must_cover:
    - 已具备条件（平台/数据/样本/算力/团队/合规）
    - 尚缺条件与解决途径（时间/预算/合作/采购/替代方案）

from __future__ import annotations

import re
from typing import Iterable


def extract_yaml_value_under_block(lines: Iterable[str], block_key: str, key: str) -> str | None:
    """
    Minimal YAML extractor for a scalar value under a top-level mapping block.

    This skill intentionally avoids external YAML dependencies; keep this helper
    small and predictable, and only support the patterns we generate in config.yaml.
    """
    in_block = False
    block_indent: int | None = None
    key_re = re.compile(rf"^(\s*){re.escape(key)}:\s*(.*?)\s*$")

    for line in lines:
        if not in_block:
            if re.match(rf"^{re.escape(block_key)}:\s*$", line):
                in_block = True
                block_indent = len(line) - len(line.lstrip(" "))
            continue

        if line.strip() == "":
            continue

        indent = len(line) - len(line.lstrip(" "))
        if block_indent is not None and indent <= block_indent and not line.startswith(" " * (block_indent + 1)):
            break

        m = key_re.match(line)
        if m and indent >= (block_indent or 0) + 2:
            return m.group(2).strip().strip('"').strip("'")

    return None


def extract_yaml_list_under_block(lines: Iterable[str], block_key: str, key: str) -> list[str] | None:
    """Extract a simple YAML list under `block_key: { key: [ - item ] }` style."""
    in_block = False
    block_indent: int | None = None
    key_indent: int | None = None
    items: list[str] = []

    for line in lines:
        if not in_block:
            if re.match(rf"^{re.escape(block_key)}:\s*$", line):
                in_block = True
                block_indent = len(line) - len(line.lstrip(" "))
            continue

        if line.strip() == "":
            continue

        indent = len(line) - len(line.lstrip(" "))
        if block_indent is not None and indent <= block_indent and not line.startswith(" " * (block_indent + 1)):
            break

        if key_indent is None:
            if re.match(rf"^\s*{re.escape(key)}:\s*$", line) and indent >= (block_indent or 0) + 2:
                key_indent = indent
            continue

        if indent <= key_indent:
            break

        stripped = line.strip()
        if stripped.startswith("- "):
            items.append(stripped.removeprefix("- ").strip().strip('"').strip("'"))

    return items if items else None

#!/usr/bin/env python3
from __future__ import annotations

import argparse
import re
import sys
from pathlib import Path

from _yaml_utils import extract_yaml_value_under_block

RISK_PHRASES = [
    "首次",
    "领先",
    "国际领先",
    "国内领先",
    "唯一",
    "填补空白",
    "世界领先",
    "国内首创",
]


def _err(message: str) -> int:
    print(f"ERROR: {message}", file=sys.stderr)
    return 1


def _warn(message: str) -> None:
    print(f"WARNING: {message}", file=sys.stderr)


def _load_targets(config_yaml: Path) -> tuple[str, str]:
    lines = config_yaml.read_text(encoding="utf-8").splitlines()
    foundation = extract_yaml_value_under_block(lines, "targets", "foundation_tex") or ""
    conditions = extract_yaml_value_under_block(lines, "targets", "conditions_tex") or ""
    if not foundation or not conditions:
        raise ValueError("missing targets.foundation_tex / targets.conditions_tex in config.yaml")
    return foundation, conditions


def main() -> int:
    parser = argparse.ArgumentParser(
        description="Check nsfc-research-foundation-writer outputs under a LaTeX project root (existence + light heuristics)."
    )
    parser.add_argument("--project-root", required=True, help="LaTeX project root (must contain extraTex/).")
    parser.add_argument(
        "--no-content-check",
        action="store_true",
        help="Only check that target files exist (skip content heuristics).",
    )
    parser.add_argument(
        "--no-risk-scan",
        action="store_true",
        help="Skip scanning for risk phrases like '首次/领先'.",
    )
    parser.add_argument(
        "--fail-on-risk-phrases",
        action="store_true",
        help="Treat risk phrases as errors (default: warnings).",
    )
    args = parser.parse_args()

    skill_root = Path(__file__).resolve().parents[1]
    config_yaml = skill_root / "config.yaml"
    if not config_yaml.exists():
        return _err(f"missing config.yaml: {config_yaml}")

    try:
        target_foundation, target_conditions = _load_targets(config_yaml)
    except ValueError as exc:
        return _err(str(exc))

    project_root = Path(args.project_root).expanduser().resolve()
    extra_tex = project_root / "extraTex"
    if not extra_tex.exists() or not extra_tex.is_dir():
        return _err(f"missing extraTex/ under project root: {extra_tex}")

    foundation_path = project_root / target_foundation
    conditions_path = project_root / target_conditions
    for p in [foundation_path, conditions_path]:
        if not p.exists() or not p.is_file():
            return _err(f"missing target file: {p}")

    if args.no_content_check:
        print("OK: target files exist (content checks skipped)", flush=True)
        return 0

    foundation_text = foundation_path.read_text(encoding="utf-8", errors="replace")
    conditions_text = conditions_path.read_text(encoding="utf-8", errors="replace")

    # Foundation must include explicit risk responses; require >=3 risk items.
    if "风险" not in foundation_text:
        return _err(f"{foundation_path} does not contain '风险' (risk section missing?)")
    if not (("应对" in foundation_text) or ("预案" in foundation_text) or ("替代" in foundation_text)):
        _warn(f"{foundation_path} has '风险' but lacks common response keywords (应对/预案/替代); please confirm risk responses are explicit")

    # Try to count "risk items" from common LaTeX heading patterns.
    risk_items: list[str] = []
    risk_items += re.findall(r"\\subsubsubsection\{[^}]*风险[^}]*\}", foundation_text)
    risk_items += re.findall(r"\\subsubsection\{[^}]*风险[^}]*\}", foundation_text)
    risk_items += re.findall(r"(?m)^\\s*#+\\s*.*风险.*$", foundation_text)  # markdown-like headings (rare)
    risk_items += re.findall(r"风险\\s*(?:\\d+|[一二三四五六七八九十])", foundation_text)

    # Deduplicate near-identical hits.
    risk_items = list(dict.fromkeys(risk_items))
    if len(risk_items) < 3:
        return _err(f"{foundation_path} seems to contain < 3 risk items (found {len(risk_items)})")

    # Conditions should reflect "have" and "lack + plan" structure.
    if not (("已具备" in conditions_text) or ("具备" in conditions_text)):
        _warn(f"{conditions_path} does not mention '已具备/具备' explicitly; please confirm it lists existing conditions")
    if not (("尚缺" in conditions_text) or ("缺少" in conditions_text) or ("不足" in conditions_text)):
        _warn(f"{conditions_path} does not mention '尚缺/缺少/不足' explicitly; please confirm it covers missing conditions + plan")

    # Placeholders are allowed in preview / when info is missing; warn for apply-mode outputs.
    if "[请补充：" in foundation_text or "[需补充：" in foundation_text or "[请补充：" in conditions_text or "[需补充：" in conditions_text:
        _warn("found placeholder markers like '[请补充：...]' in outputs; confirm this is intentional and consistent with provided info")

    if not args.no_risk_scan:
        hits: list[tuple[str, str]] = []
        combined = f"{foundation_text}\n{conditions_text}"
        for phrase in RISK_PHRASES:
            if phrase in combined:
                hits.append((phrase, "found"))
        if hits:
            msg = "risk phrases present: " + ", ".join(p for p, _ in hits)
            if args.fail_on_risk_phrases:
                return _err(msg)
            _warn(msg)

    print("OK: output checks passed", flush=True)
    return 0


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

#!/usr/bin/env python3
from __future__ import annotations

import argparse
import subprocess
import sys
from pathlib import Path


def _run(cmd: list[str]) -> int:
    print("+ " + " ".join(cmd), flush=True)
    proc = subprocess.run(cmd, text=True)
    return proc.returncode


def main() -> int:
    parser = argparse.ArgumentParser(
        description="Run nsfc-research-foundation-writer minimal checks (validate skill + optional project output checks).",
    )
    parser.add_argument(
        "--project-root",
        default="",
        help="Optional LaTeX project root to check outputs (must contain extraTex/).",
    )
    parser.add_argument(
        "--no-content-check",
        action="store_true",
        help="Only check that target files exist (skip content heuristics).",
    )
    parser.add_argument(
        "--no-risk-scan",
        action="store_true",
        help="Skip scanning for risk phrases like '首次/领先'.",
    )
    parser.add_argument(
        "--fail-on-risk-phrases",
        action="store_true",
        help="Treat risk phrases as errors (default: warnings).",
    )
    args = parser.parse_args()

    skill_root = Path(__file__).resolve().parents[1]
    validate = skill_root / "scripts" / "validate_skill.py"
    check_outputs = skill_root / "scripts" / "check_project_outputs.py"

    rc = _run([sys.executable, str(validate)])
    if rc != 0:
        return rc

    if args.project_root:
        cmd = [
            sys.executable,
            str(check_outputs),
            "--project-root",
            args.project_root,
        ]
        if args.no_content_check:
            cmd.append("--no-content-check")
        if args.no_risk_scan:
            cmd.append("--no-risk-scan")
        if args.fail_on_risk_phrases:
            cmd.append("--fail-on-risk-phrases")

        rc = _run(cmd)
        if rc != 0:
            return rc

    print("OK: all checks passed", flush=True)
    return 0


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

#!/usr/bin/env python3
from __future__ import annotations

import re
import sys
from pathlib import Path
from typing import Any

from _yaml_utils import extract_yaml_list_under_block, extract_yaml_value_under_block


def _err(message: str) -> int:
    print(f"ERROR: {message}", file=sys.stderr)
    return 1


def _warn(message: str) -> None:
    print(f"WARNING: {message}", file=sys.stderr)


def _extract_frontmatter(text: str) -> str:
    if not text.startswith("---"):
        return ""
    parts = text.split("\n---\n", 1)
    if len(parts) != 2:
        return ""
    return parts[0]


def _parse_frontmatter_yaml(frontmatter: str) -> dict[str, Any] | None:
    try:
        import yaml  # type: ignore[import-untyped]
    except ImportError:
        _warn("PyYAML is not installed; skipping strict frontmatter YAML parsing")
        return None

    try:
        parsed = yaml.safe_load(frontmatter) or {}
    except yaml.YAMLError as exc:
        raise ValueError(f"SKILL.md frontmatter is invalid YAML: {exc}") from exc

    if not isinstance(parsed, dict):
        raise ValueError("SKILL.md frontmatter must parse to a YAML mapping")
    return parsed


def _extract_frontmatter_field(frontmatter: str, key: str) -> str | None:
    match = re.search(rf"(?m)^{re.escape(key)}:\s*(.+?)\s*$", frontmatter)
    if not match:
        return None
    return match.group(1).strip().strip('"').strip("'")


def main() -> int:
    skill_root = Path(__file__).resolve().parents[1]
    repo_root = skill_root.parents[1]
    skill_md = skill_root / "SKILL.md"
    config_yaml = skill_root / "config.yaml"

    required_files = [
        skill_md,
        config_yaml,
        skill_root / "README.md",
        skill_root / "CHANGELOG.md",
        skill_root / "references" / "info_form.md",
        skill_root / "references" / "dod_checklist.md",
        skill_root / "references" / "example_output.md",
        skill_root / "scripts" / "_yaml_utils.py",
    ]
    for path in required_files:
        if not path.exists():
            return _err(f"missing required file: {path}")

    skill_text = skill_md.read_text(encoding="utf-8")
    frontmatter = _extract_frontmatter(skill_text)
    if not frontmatter:
        return _err("SKILL.md missing YAML frontmatter block")
    try:
        _parse_frontmatter_yaml(frontmatter)
    except ValueError as exc:
        return _err(str(exc))

    fm_name = _extract_frontmatter_field(frontmatter, "name")
    fm_version = _extract_frontmatter_field(frontmatter, "version")
    fm_config = _extract_frontmatter_field(frontmatter, "config")
    fm_references = _extract_frontmatter_field(frontmatter, "references")
    if not fm_name or not fm_version or not fm_config or not fm_references:
        return _err("SKILL.md frontmatter missing required fields: name/version/config/references")

    fm_config_path = Path(fm_config)
    resolved_config_path = (
        (repo_root / fm_config_path) if str(fm_config_path).startswith("skills/") else (skill_root / fm_config_path)
    ).resolve()
    if resolved_config_path != config_yaml.resolve():
        return _err(f"config path mismatch: SKILL.md={resolved_config_path} expected={config_yaml.resolve()}")

    fm_refs_path = Path(fm_references)
    resolved_refs_path = (
        (repo_root / fm_refs_path) if str(fm_refs_path).startswith("skills/") else (skill_root / fm_refs_path)
    ).resolve()
    if not resolved_refs_path.exists() or not resolved_refs_path.is_dir():
        return _err(f"references path invalid: {resolved_refs_path}")

    config_lines = config_yaml.read_text(encoding="utf-8").splitlines()
    cfg_name = extract_yaml_value_under_block(config_lines, "skill_info", "name")
    cfg_version = extract_yaml_value_under_block(config_lines, "skill_info", "version")
    if not cfg_name or not cfg_version:
        return _err("config.yaml missing skill_info.name or skill_info.version")
    if cfg_name != fm_name:
        return _err(f"skill name mismatch: SKILL.md={fm_name} config.yaml={cfg_name}")
    if cfg_version != fm_version:
        return _err(f"skill version mismatch: SKILL.md={fm_version} config.yaml={cfg_version}")

    target_foundation = extract_yaml_value_under_block(config_lines, "targets", "foundation_tex")
    target_conditions = extract_yaml_value_under_block(config_lines, "targets", "conditions_tex")
    if not target_foundation or not target_conditions:
        return _err("config.yaml missing targets.foundation_tex or targets.conditions_tex")

    allowed = extract_yaml_list_under_block(config_lines, "guardrails", "allowed_write_files") or []
    if target_foundation not in allowed or target_conditions not in allowed:
        return _err("config.yaml guardrails.allowed_write_files must include both targets.* paths")

    # Heuristic checks: keep them lightweight; warn rather than fail when ambiguous.
    for needle in [target_foundation, target_conditions, "main.tex", "extraTex/@config.tex"]:
        if needle not in skill_text:
            _warn(f"SKILL.md does not mention expected guardrail/target string: {needle}")

    info_form = (skill_root / "references" / "info_form.md").read_text(encoding="utf-8")
    if re.search(r"(?i)\bNSFC\s*20\d{2}\b", info_form):
        _warn("references/info_form.md contains a year-like token (e.g., 'NSFC 2026'); consider keeping it year-agnostic")

    print("OK: skill validation passed", flush=True)
    return 0


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