Nsfc Code

# ================================
# nsfc-code 默认配置（Single Source of Truth for version）
# ================================

skill_info:
  name: nsfc-code
  version: 1.0.0
  description: "根据 NSFC 标书正文内容，结合申请代码推荐库，为你给出 5 组申请代码1/2（主/次）推荐与理由；输出到 NSFC-CODE-vYYYYMMDDHHmm.md（只读，不修改标书）"
  category: writing
  author: "Bensz Conan"

parameters:
  input_paths:
    type: array
    required: true
    description: 待分析的标书正文来源（文件或目录路径；常见为 `projects/NSFC_Young/` 或 `main.tex`）
  preferred_prefixes:
    type: array
    required: false
    default: []
    description: 可选：限定候选代码的学部前缀（例如仅在你确定学科门类时填 `["A"]` 或 `["A","F"]`），避免跨学科噪声
  output_dir:
    type: string
    required: false
    default: ""
    description: 输出目录；为空则使用当前工作目录
  output_filename:
    type: string
    required: false
    default: ""
    description: 输出文件名；为空则使用 `NSFC-CODE-vYYYYMMDDHHmm.md`
  top_k_candidates:
    type: integer
    required: false
    default: 50
    description: 候选代码粗排数量（用于 AI 二次筛选）

guardrails:
  # 只读：不允许修改标书内容（tex/bib/cls/sty 等）。
  # 允许写入：根层交付文件、隐藏工作区、测试/计划产物。
  allowed_write_globs:
    - "NSFC-CODE-*.md"
    - ".nsfc-code/**"
    - "skills/nsfc-code/tests/**"
    - "skills/nsfc-code/plans/**"
  forbidden_write_globs:
    - "**/*.tex"
    - "**/*.bib"
    - "**/*.cls"
    - "**/*.sty"

references:
  overrides_toml: "skills/nsfc-code/references/nsfc_code_recommend.toml"

output_contract:
  # 隐藏工作区（中间文件，每次运行独立隔离）
  work_dir: ".nsfc-code/v{ts}/"
  # 最终交付（工作目录根层，文件名按分钟级时间戳）
  final_report: "NSFC-CODE-v{ts}.md"

% Demo-only excerpt for nsfc-code (not a real NSFC proposal).
\section{研究目标与科学问题}
本项目面向复杂工程系统的\textbf{安全可靠}运行，研究数据驱动的风险评估与决策方法。核心科学问题是：在多源异构数据与不确定性干扰下，如何建立可解释、可验证的风险建模与推断框架，并给出可落地的优化控制策略。

\section{研究内容与技术路线}
\subsection{数据驱动的风险建模与不确定性量化}
研究概率建模、贝叶斯推断与不确定性量化方法，构建面向安全场景的风险指标体系，实现对关键失效模式的预测与评估。

\subsection{安全约束下的优化与控制}
研究鲁棒优化、随机优化与控制中的数学方法，在安全约束条件下实现策略优化与闭环控制，并结合仿真与真实数据进行验证。

\subsection{面向应用的验证与评估}
以图像与信号处理数据为例，构建风险识别与预警原型系统，形成可复用的软件工具链与实验基准。

#!/usr/bin/env python3
"""
Create a new NSFC code recommendation report skeleton with the required filename:
  NSFC-CODE-vYYYYMMDDHHmm.md

This is a deterministic helper to reduce human/LLM mistakes on timestamp formatting
and document structure. It does NOT read or modify any proposal files.
"""

from __future__ import annotations

import argparse
from datetime import datetime
from pathlib import Path
from typing import Optional, Sequence


TEMPLATE = """# NSFC 申请代码推荐

- 生成时间：{generated_at}
- 输入来源：{input_hint}
- 参考库：skills/nsfc-code/references/nsfc_code_recommend.toml

## 标书内容要点（只读提炼）

- 研究对象：
- 核心科学问题：
- 主要方法/技术路线：
- 关键应用场景/系统：
- 关键词（10-20 个）：

## 5 组代码推荐（主/次）

### 推荐 1
- 申请代码1（主）：
- 申请代码2（次）：
- 理由：

### 推荐 2
- 申请代码1（主）：
- 申请代码2（次）：
- 理由：

### 推荐 3
- 申请代码1（主）：
- 申请代码2（次）：
- 理由：

### 推荐 4
- 申请代码1（主）：
- 申请代码2（次）：
- 理由：

### 推荐 5
- 申请代码1（主）：
- 申请代码2（次）：
- 理由：
"""


def main(argv: Optional[Sequence[str]] = None) -> int:
    ap = argparse.ArgumentParser()
    ap.add_argument("--output-dir", default=".", help="Directory to write the report (default: .)")
    ap.add_argument(
        "--ts",
        default="",
        help="Explicit timestamp in YYYYMMDDHHmm (optional; default is now)",
    )
    ap.add_argument("--input-hint", default="（待填写：标书路径/文件列表）", help="Text to fill into 输入来源")
    ap.add_argument("--overwrite", action="store_true", help="Overwrite if file exists")
    args = ap.parse_args(list(argv) if argv is not None else None)

    ts = args.ts.strip()
    if not ts:
        ts = datetime.now().strftime("%Y%m%d%H%M")
    if len(ts) != 12 or not ts.isdigit():
        raise SystemExit("FAIL: --ts must be YYYYMMDDHHmm (12 digits)")

    out_dir = Path(args.output_dir).expanduser().resolve()
    out_dir.mkdir(parents=True, exist_ok=True)
    out_path = out_dir / f"NSFC-CODE-v{ts}.md"

    if out_path.exists() and not args.overwrite:
        raise SystemExit(f"FAIL: output exists (use --overwrite): {out_path}")

    generated_at = datetime.strptime(ts, "%Y%m%d%H%M").strftime("%Y-%m-%d %H:%M")
    out_path.write_text(
        TEMPLATE.format(generated_at=generated_at, input_hint=args.input_hint),
        encoding="utf-8",
    )
    print(str(out_path))
    return 0


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

#!/usr/bin/env python3
"""
Rank NSFC application codes by heuristic similarity between:
- proposal text (from .tex/.md/.txt files)
- overrides TOML recommend descriptions (2026)

Design goals:
- Dependency-free (no third-party packages; Python 3.9+).
- Read-only on inputs; writes only if --out/--output-dir is provided.
- Provide a "candidate shortlist" for the LLM to finalize 5 code pairs.
"""

from __future__ import annotations

import argparse
import json
import re
import sys
from dataclasses import dataclass
from datetime import datetime
from pathlib import Path
from typing import Dict, Iterable, List, Optional, Sequence, Tuple


SKILL_ROOT = Path(__file__).resolve().parents[1]
DEFAULT_OVERRIDES = SKILL_ROOT / "references" / "nsfc_code_recommend.toml"

try:
    import tomllib  # py311+
except Exception:  # pragma: no cover - runtime dependent
    tomllib = None  # type: ignore[assignment]


_HEADER_RE = re.compile(r"^\[([A-Za-z0-9_.-]+)\]\s*$")
_RECOMMEND_RE = re.compile(r'^\s*recommend\s*=\s*"(.*)"\s*$')


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


def load_overrides(path: Path) -> Dict[str, str]:
    """
    Minimal TOML reader for files shaped like:
      [A.A01.A0101]
      recommend = "..."
    """
    if not path.exists():
        raise FileNotFoundError(str(path))

    # Prefer a real TOML parser when available (Python 3.11+),
    # but keep a zero-deps fallback for Python 3.9/3.10.
    if tomllib is not None:
        try:
            data = tomllib.loads(_read_text(path))
            codes: Dict[str, str] = {}
            for code, payload in data.items():
                if not isinstance(payload, dict):
                    continue
                rec = payload.get("recommend")
                if isinstance(rec, str) and rec.strip():
                    codes[str(code)] = rec
            if codes:
                return codes
        except Exception:
            # Fall back to the minimal parser below.
            pass

    codes: Dict[str, str] = {}
    current: Optional[str] = None
    for raw in _read_text(path).splitlines():
        line = raw.strip()
        if not line or line.startswith("#"):
            continue

        m = _HEADER_RE.match(line)
        if m:
            current = m.group(1).strip()
            continue

        if current:
            m2 = _RECOMMEND_RE.match(line)
            if m2:
                # Basic unescape: \" -> "
                val = m2.group(1).replace('\\"', '"')
                codes[current] = val
                continue
    return codes


def is_binary_file(path: Path) -> bool:
    # A cheap heuristic: if NUL in first chunk, treat as binary.
    try:
        with path.open("rb") as f:
            chunk = f.read(2048)
        return b"\x00" in chunk
    except Exception:
        return True


def iter_input_files(inputs: Sequence[Path]) -> Iterable[Path]:
    exts = {".tex", ".md", ".txt"}
    skip_md_basenames = {"README.md", "CHANGELOG.md", "SKILL.md"}
    skip_dir_parts = {".git", ".latex-cache", "build", "dist", "out", ".nsfc-code"}
    for inp in inputs:
        if inp.is_file():
            if inp.suffix.lower() in exts and not is_binary_file(inp):
                yield inp
            continue
        if inp.is_dir():
            for p in inp.rglob("*"):
                if not p.is_file():
                    continue
                if p.suffix.lower() not in exts:
                    continue
                # Avoid feeding tool-generated reports or meta-docs back into ranking.
                if p.suffix.lower() == ".md":
                    if p.name in skip_md_basenames:
                        continue
                    if p.name.startswith("NSFC-"):
                        continue
                if any(part in skip_dir_parts for part in p.parts):
                    continue
                if is_binary_file(p):
                    continue
                yield p


_COMMENT_RE = re.compile(r"(?<!\\)%.*$")
_MATH_INLINE_RE = re.compile(r"\$[^$]*\$")
_MATH_DISPLAY_RE = re.compile(r"\$\$.*?\$\$", flags=re.S)
_TEX_ENV_RE = re.compile(r"\\begin\{[^}]+\}|\\end\{[^}]+\}")
_CITE_RE = re.compile(r"\\(?:cite|citet|citep|ref|eqref|label)\{[^}]*\}")
_CMD_RE = re.compile(r"\\[A-Za-z@]+(\*?)")
_BRACE_RE = re.compile(r"[\{\}\[\]]")


def latex_to_text(s: str) -> str:
    # Strip TeX comments first (line-wise).
    lines = []
    for line in s.splitlines():
        line = _COMMENT_RE.sub("", line)
        lines.append(line)
    s2 = "\n".join(lines)

    # Remove math.
    s2 = _MATH_DISPLAY_RE.sub(" ", s2)
    s2 = _MATH_INLINE_RE.sub(" ", s2)

    # Remove environments and common citation/ref tokens.
    s2 = _TEX_ENV_RE.sub(" ", s2)
    s2 = _CITE_RE.sub(" ", s2)

    # Keep argument text; remove command names and braces.
    s2 = s2.replace("\\linebreak{}", " ")
    s2 = _CMD_RE.sub(" ", s2)
    s2 = _BRACE_RE.sub(" ", s2)

    # Collapse whitespace.
    s2 = re.sub(r"\s+", " ", s2).strip()
    return s2


_RECOMMEND_BOILERPLATE = [
    "资助",
    "领域基础与应用基础研究",
    "基础与应用基础研究",
    "重点围绕",
    "重点支持",
    "开展理论、方法与应用研究",
    "开展理论、方法与应用研究，",
    "鼓励交叉创新",
    "聚焦关键科学问题与技术突破",
    "强调原创性与可转化性",
]


def clean_recommend_text(s: str) -> str:
    # Remove boilerplate phrases to make similarity more sensitive to distinctive terms.
    out = s
    for ph in _RECOMMEND_BOILERPLATE:
        out = out.replace(ph, "")
    return out


def normalize_for_ngrams(s: str) -> str:
    # Keep CJK + ascii letters/digits; drop punctuation/spaces.
    s = s.lower()
    s = re.sub(r"[^0-9a-z\u4e00-\u9fff]+", "", s)
    return s


def ngrams(s: str, n: int) -> set:
    if n <= 0:
        return set()
    if len(s) < n:
        return set()
    return {s[i : i + n] for i in range(0, len(s) - n + 1)}


def jaccard(a: set, b: set) -> float:
    if not a or not b:
        return 0.0
    inter = len(a & b)
    union = len(a | b)
    return inter / union if union else 0.0


@dataclass(frozen=True)
class RankedCode:
    code: str
    score: float
    recommend: str


def rank_codes(
    proposal_text: str,
    overrides: Dict[str, str],
    *,
    w2: float = 0.55,
    w3: float = 0.45,
) -> List[RankedCode]:
    norm_p = normalize_for_ngrams(proposal_text)
    p2 = ngrams(norm_p, 2)
    p3 = ngrams(norm_p, 3)

    ranked: List[RankedCode] = []
    for code, desc in overrides.items():
        norm_d = normalize_for_ngrams(clean_recommend_text(desc))
        d2 = ngrams(norm_d, 2)
        d3 = ngrams(norm_d, 3)
        score = w2 * jaccard(p2, d2) + w3 * jaccard(p3, d3)
        ranked.append(RankedCode(code=code, score=score, recommend=desc))

    ranked.sort(key=lambda x: x.score, reverse=True)
    return ranked


def suggest_pairs(ranked: Sequence[RankedCode], k: int = 5) -> List[Tuple[str, str]]:
    """
    Suggest (code1, code2) pairs from ranked list.
    Heuristic:
    - pick diverse code1 by major prefix (first 2 segments, e.g., A.A06)
    - for each code1, pick code2 as the best remaining with same first segment (e.g., A)
      and preferably same major prefix; otherwise next best.
    """
    if k <= 0:
        return []

    def major_prefix(code: str) -> str:
        parts = code.split(".")
        return ".".join(parts[:2]) if len(parts) >= 2 else code

    def first_prefix(code: str) -> str:
        return code.split(".")[0] if code else code

    used_codes = set()
    used_major = set()
    picks: List[str] = []
    for item in ranked:
        if item.code in used_codes:
            continue
        mp = major_prefix(item.code)
        if mp in used_major:
            continue
        picks.append(item.code)
        used_codes.add(item.code)
        used_major.add(mp)
        if len(picks) >= k:
            break

    pairs: List[Tuple[str, str]] = []
    for c1 in picks:
        mp1 = major_prefix(c1)
        fp1 = first_prefix(c1)
        c2: Optional[str] = None
        # Prefer same major prefix.
        for item in ranked:
            if item.code == c1 or item.code in used_codes:
                continue
            if major_prefix(item.code) == mp1:
                c2 = item.code
                break
        # Fallback: same first prefix (discipline letter).
        if c2 is None:
            for item in ranked:
                if item.code == c1 or item.code in used_codes:
                    continue
                if first_prefix(item.code) == fp1:
                    c2 = item.code
                    break
        # Final fallback: next best.
        if c2 is None:
            for item in ranked:
                if item.code == c1 or item.code in used_codes:
                    continue
                c2 = item.code
                break
        if c2 is None:
            continue
        used_codes.add(c2)
        pairs.append((c1, c2))
    return pairs


def main(argv: Optional[Sequence[str]] = None) -> int:
    ap = argparse.ArgumentParser()
    ap.add_argument("--input", action="append", required=True, help="Input file/dir path; repeatable")
    ap.add_argument("--overrides", default=str(DEFAULT_OVERRIDES), help="Path to overrides TOML")
    ap.add_argument(
        "--prefix",
        action="append",
        default=[],
        help="Restrict to code first-segment prefix (e.g., A/F/H); repeatable",
    )
    ap.add_argument("--top-k", type=int, default=50, help="How many candidates to print (default: 50)")
    ap.add_argument("--format", choices=["table", "json"], default="table", help="Output format")
    ap.add_argument("--suggest-pairs", action="store_true", help="Also print 5 suggested (code1, code2) pairs")
    ap.add_argument("--out", default="", help="Write output to a file path (optional)")
    ap.add_argument(
        "--output-dir",
        default="",
        help="Write output into a directory (optional). File name defaults to nsfc_code_rank.{json|md}.",
    )
    args = ap.parse_args(list(argv) if argv is not None else None)

    if args.out and args.output_dir:
        print("FAIL: use only one of --out or --output-dir.", file=sys.stderr)
        return 2

    inputs = [Path(x).expanduser().resolve() for x in args.input]
    for p in inputs:
        if not p.exists():
            print(f"FAIL: input path not found: {p}", file=sys.stderr)
            return 2
    overrides_path = Path(args.overrides).expanduser().resolve()

    overrides = load_overrides(overrides_path)
    if not overrides:
        print(f"FAIL: overrides file parsed but empty: {overrides_path}", file=sys.stderr)
        return 2

    prefixes = [x.strip() for x in args.prefix if x and x.strip()]
    if prefixes:
        overrides = {k: v for k, v in overrides.items() if k.split(".")[0] in set(prefixes)}
        if not overrides:
            print(f"FAIL: overrides filtered by --prefix but became empty: {prefixes}", file=sys.stderr)
            return 2

    files = sorted(set(iter_input_files(inputs)))
    if not files:
        print("FAIL: no readable input files found (.tex/.md/.txt).", file=sys.stderr)
        return 2

    chunks: List[str] = []
    for p in files:
        raw = _read_text(p)
        if p.suffix.lower() == ".tex":
            chunks.append(latex_to_text(raw))
        else:
            chunks.append(raw)
    proposal_text = "\n".join(chunks)

    ranked = rank_codes(proposal_text, overrides)
    top = ranked[: max(0, int(args.top_k))]

    payload = {
        "generated_at": datetime.now().strftime("%Y-%m-%d %H:%M"),
        "overrides": str(overrides_path),
        "filters": {"prefixes": prefixes},
        "inputs": [str(x) for x in inputs],
        "files_used": [str(p) for p in files],
        "top_k": int(args.top_k),
        "candidates": [
            {"rank": i + 1, "code": r.code, "score": round(r.score, 6), "recommend": r.recommend}
            for i, r in enumerate(top)
        ],
    }
    if args.suggest_pairs:
        payload["suggested_pairs"] = [{"code1": a, "code2": b} for a, b in suggest_pairs(top, k=5)]

    if args.format == "json":
        out_text = json.dumps(payload, ensure_ascii=False, indent=2)
    else:
        lines: List[str] = []
        lines.append(f"generated_at: {payload['generated_at']}")
        lines.append(f"overrides: {payload['overrides']}")
        lines.append(f"files_used: {len(files)}")
        lines.append("")
        lines.append("| rank | code | score | recommend |")
        lines.append("|---:|---|---:|---|")
        for c in payload["candidates"]:
            rec = c["recommend"]
            if len(rec) > 60:
                rec = rec[:60] + "..."
            lines.append(f"| {c['rank']} | {c['code']} | {c['score']:.6f} | {rec} |")
        if args.suggest_pairs:
            lines.append("")
            lines.append("Suggested pairs:")
            for p in payload.get("suggested_pairs", []):
                lines.append(f"- {p['code1']} + {p['code2']}")
        out_text = "\n".join(lines)

    out_path: Optional[Path] = None
    if args.out:
        out_path = Path(args.out).expanduser().resolve()
    elif args.output_dir:
        out_dir = Path(args.output_dir).expanduser().resolve()
        ext = "json" if args.format == "json" else "md"
        out_path = out_dir / f"nsfc_code_rank.{ext}"

    if out_path is not None:
        out_path.parent.mkdir(parents=True, exist_ok=True)
        out_path.write_text(out_text, encoding="utf-8")
        print(str(out_path))
    else:
        print(out_text)
    return 0


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

#!/usr/bin/env python3
"""
Deterministic validation for the nsfc-code skill folder.

Checks:
- required files exist
- overrides TOML can be parsed (non-empty)
- ranking script can run on demo input
"""

from __future__ import annotations

import json
import subprocess
import sys
import tempfile
from pathlib import Path


def main() -> int:
    skill_root = Path(__file__).resolve().parents[1]
    required = [
        skill_root / "SKILL.md",
        skill_root / "config.yaml",
        skill_root / "references" / "nsfc_code_recommend.toml",
        skill_root / "scripts" / "nsfc_code_rank.py",
        skill_root / "scripts" / "nsfc_code_new_report.py",
    ]
    missing = [str(p.relative_to(skill_root)) for p in required if not p.exists()]
    if missing:
        print("FAIL: missing required files:", file=sys.stderr)
        for p in missing:
            print(f"- {p}", file=sys.stderr)
        return 2

    # Smoke: ranking script should work on demo.
    demo_dir = skill_root / "references" / "demo"
    demo_tex = demo_dir / "proposal_excerpt.tex"
    if not demo_tex.exists():
        print("WARN: demo input missing, skip smoke run.", file=sys.stderr)
        return 0

    cmd_base = [
        sys.executable,
        str(skill_root / "scripts" / "nsfc_code_rank.py"),
        "--input",
        str(demo_dir),
        "--top-k",
        "5",
        "--prefix",
        "A",
        "--format",
        "json",
    ]
    try:
        r = subprocess.run(cmd_base, check=True, capture_output=True, text=True)
    except subprocess.CalledProcessError as e:
        print("FAIL: smoke run failed:", file=sys.stderr)
        print(e.stdout, file=sys.stderr)
        print(e.stderr, file=sys.stderr)
        return 2

    try:
        payload = json.loads(r.stdout)
    except Exception as e:
        print("FAIL: ranking script did not output valid JSON.", file=sys.stderr)
        print(str(e), file=sys.stderr)
        return 2

    candidates = payload.get("candidates")
    if not isinstance(candidates, list) or not candidates:
        print("FAIL: ranking script returned empty/invalid candidates.", file=sys.stderr)
        return 2
    required_keys = {"rank", "code", "score", "recommend"}
    if not required_keys.issubset(set(candidates[0].keys())):
        print("FAIL: candidate shape missing required keys.", file=sys.stderr)
        return 2

    # Smoke: test --output-dir behavior (should write a JSON file and print its path).
    with tempfile.TemporaryDirectory(prefix="nsfc-code-validate-") as td:
        cmd_out = list(cmd_base) + ["--output-dir", td]
        try:
            r2 = subprocess.run(cmd_out, check=True, capture_output=True, text=True)
        except subprocess.CalledProcessError as e:
            print("FAIL: smoke run (--output-dir) failed:", file=sys.stderr)
            print(e.stdout, file=sys.stderr)
            print(e.stderr, file=sys.stderr)
            return 2

        out_path = Path(r2.stdout.strip())
        if not out_path.exists():
            print("FAIL: --output-dir did not create output file.", file=sys.stderr)
            print(f"expected path: {out_path}", file=sys.stderr)
            return 2

        try:
            payload2 = json.loads(out_path.read_text(encoding="utf-8"))
        except Exception:
            print("FAIL: output file from --output-dir is not valid JSON.", file=sys.stderr)
            return 2
        if not isinstance(payload2.get("candidates"), list) or not payload2["candidates"]:
            print("FAIL: output file candidates missing/empty.", file=sys.stderr)
            return 2

    print("OK: nsfc-code skill structure looks valid.")
    return 0


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