Sync Submission

{
  "_comment": "PUBLIC author-guideline facts expressed as booleans — NOT verbatim journal text. data_required: a Data Availability statement is expected; code_required_if_ai: a Code Availability statement is expected for AI/ML studies; repository_required: data/code sharing should point to a repository rather than only 'available on reasonable request'. These are conventions; verify current instructions-to-authors at the journal site before relying on a value.",
  "schema_version": 1,
  "default": {
    "data_required": true,
    "code_required_if_ai": true,
    "repository_required": false
  },
  "journals": {
    "radiology": {"data_required": true, "code_required_if_ai": true, "repository_required": true},
    "radiology-ai": {"data_required": true, "code_required_if_ai": true, "repository_required": true},
    "ryai": {"data_required": true, "code_required_if_ai": true, "repository_required": true},
    "npj-digital-medicine": {"data_required": true, "code_required_if_ai": true, "repository_required": false},
    "nature-medicine": {"data_required": true, "code_required_if_ai": true, "repository_required": true},
    "lancet-digital-health": {"data_required": true, "code_required_if_ai": true, "repository_required": false}
  }
}

#!/usr/bin/env python3
"""Supplement assembler + structural validator (cohort/SR supplements).

Cohort and SR/MA supplements are a directory of per-section `S{N}_*.md` files +
an `00_index.md`, hand-concatenated into `_combined.md` and re-rendered. Adding
and extending sections across revisions desynchronizes the set: a declared `S{N}`
with no file (or a file with no index row), a duplicate `S{N}`, or a skipped
sub-section number after an insert (`S6.3` then `S6.5`, no `S6.4`). This script
validates that structure and rebuilds `_combined.md` in index order so the
assembly is reproducible rather than hand-maintained.

NOT an integrity detector — deliberately named `assemble_supplement.py` (not
check_/detect_/derive_) so the catalog glob does not count it. It is a build/QA
helper, run before a submission package is frozen.

INPUTS
  --dir         supplement directory holding `S{N}_*.md` (or `supplement_S{N}_*`/
                `suppl_S{N}_*`) section files and an index (`00_index.md` by
                default; override with --index).
  --index       index filename within --dir (default 00_index.md).
  --manuscript  optional manuscript .md; cross-checks which `Supplementary
                (Table|Figure|Material|Methods…) N` / `S{N}` are cited in the body
                (coverage: uncited sections + body callouts with no section file).
  --out         optional path to write the rebuilt `_combined.md` (index order).

OUTPUT
  stdout report and, with --json, a JSON artifact:
    {dir, declared[], present[], problems[{kind, detail}], coverage{...}, summary}
  problem kinds: INDEX_WITHOUT_FILE, FILE_WITHOUT_INDEX, DUPLICATE_SECTION,
  SUBSECTION_GAP, CALLOUT_WITHOUT_SECTION, SECTION_UNCITED.
  Exit 1 (with --strict) when any STRUCTURAL problem exists (the first four kinds;
  coverage findings are advisory and never fail --strict).

Stdlib-only (re / json / argparse / pathlib). Exit codes: 0 clean (or report-only),
1 structural problem(s) with --strict, 2 input/usage error.
"""

from __future__ import annotations

import argparse
import json
import re
import sys
from pathlib import Path

FILE_RE = re.compile(r"^(?:supplement_|suppl_)?S(\d+)(?:[_.]|$)", re.IGNORECASE)
# Top-level S-number tokens in the index (S1, S2 …), not sub-sections (S6.3).
INDEX_TOKEN_RE = re.compile(r"\bS(\d+)\b(?!\.\d)")
# Sub-section headings inside a file: "## S6.3 …", "### **S6.4** …".
SUBSEC_RE = re.compile(r"^#{1,4}\s*\*{0,2}\s*S(\d+)\.(\d+)\b", re.IGNORECASE | re.MULTILINE)
STRUCTURAL = {"INDEX_WITHOUT_FILE", "FILE_WITHOUT_INDEX", "DUPLICATE_SECTION", "SUBSECTION_GAP"}
# Body callouts: "Supplementary Table S3", "Supplementary Methods 2", "Table S3", "§S3", "(S3)".
CALLOUT_RE = re.compile(
    r"(?:Supplementary\s+(?:Table|Figure|Material|Methods|Appendix|Note|Data|File)s?\s*|"
    r"(?:Table|Figure|Fig\.?)\s+|§\s*|\(\s*)S(\d+)\b", re.IGNORECASE)


def scan_files(d: Path) -> dict:
    """Map S-number -> [filenames] for section files (excludes the index/_combined)."""
    out: dict[int, list[str]] = {}
    for p in sorted(d.glob("*.md")):
        if p.name.startswith("00_") or p.name.startswith("_combined"):
            continue
        m = FILE_RE.match(p.name)
        if m:
            out.setdefault(int(m.group(1)), []).append(p.name)
    return out


def declared_order(index_text: str) -> list[int]:
    """S-numbers in the order they first appear in the index."""
    seen, order = set(), []
    for m in INDEX_TOKEN_RE.finditer(index_text):
        n = int(m.group(1))
        if n not in seen:
            seen.add(n)
            order.append(n)
    return order


def subsection_gaps(text: str, n: int) -> list[str]:
    subs = sorted({int(b) for a, b in SUBSEC_RE.findall(text) if int(a) == n})
    if len(subs) < 2:
        return []
    gaps = [s for s in range(subs[0], subs[-1] + 1) if s not in subs]
    return [f"S{n}.{g}" for g in gaps]


def analyze(d: Path, index_name: str, manuscript: Path | None, out_path: Path | None) -> dict:
    if not d.is_dir():
        sys.stderr.write(f"ERROR: --dir not found: {d}\n")
        sys.exit(2)
    index_path = d / index_name
    if not index_path.is_file():
        sys.stderr.write(f"ERROR: index not found: {index_path}\n")
        sys.exit(2)
    index_text = index_path.read_text(encoding="utf-8")
    declared = declared_order(index_text)
    files = scan_files(d)
    present = sorted(files)

    problems = []
    for n in declared:
        if n not in files:
            problems.append({"kind": "INDEX_WITHOUT_FILE",
                             "detail": f"index declares S{n} but no S{n}_*.md file exists"})
    for n in present:
        if n not in declared:
            problems.append({"kind": "FILE_WITHOUT_INDEX",
                             "detail": f"file(s) {files[n]} present for S{n} but the index does not list it"})
        if len(files[n]) > 1:
            problems.append({"kind": "DUPLICATE_SECTION",
                             "detail": f"S{n} has {len(files[n])} files: {files[n]}"})
    for n in present:
        text = (d / files[n][0]).read_text(encoding="utf-8")
        for g in subsection_gaps(text, n):
            problems.append({"kind": "SUBSECTION_GAP",
                             "detail": f"{files[n][0]}: sub-section {g} is missing (numbering gap after an insert)"})

    coverage = {}
    if manuscript is not None:
        if not manuscript.is_file():
            sys.stderr.write(f"ERROR: --manuscript not found: {manuscript}\n")
            sys.exit(2)
        body = manuscript.read_text(encoding="utf-8")
        cited = sorted({int(m.group(1)) for m in CALLOUT_RE.finditer(body)})
        uncited = [n for n in present if n not in cited]
        callout_no_section = [n for n in cited if n not in files]
        coverage = {"cited": cited, "uncited_sections": uncited,
                    "callout_without_section": callout_no_section}
        for n in callout_no_section:
            problems.append({"kind": "CALLOUT_WITHOUT_SECTION",
                             "detail": f"body cites Supplementary S{n} but no S{n}_*.md section exists"})
        for n in uncited:
            problems.append({"kind": "SECTION_UNCITED",
                             "detail": f"S{n} section file exists but is never cited in the manuscript body"})

    rebuilt = None
    if out_path is not None:
        parts = []
        for n in declared:
            if n in files:
                parts.append((d / files[n][0]).read_text(encoding="utf-8").rstrip())
        rebuilt = "\n\n---\n\n".join(parts) + "\n"
        out_path.parent.mkdir(parents=True, exist_ok=True)
        out_path.write_text(rebuilt, encoding="utf-8")

    n_structural = sum(1 for p in problems if p["kind"] in STRUCTURAL)
    return {
        "dir": str(d),
        "declared": declared,
        "present": present,
        "problems": problems,
        "coverage": coverage,
        "rebuilt_to": str(out_path) if out_path else None,
        "summary": {"n_problems": len(problems), "n_structural": n_structural,
                    "verdict": "STRUCTURAL_PROBLEM" if n_structural else "OK"},
    }


def main() -> int:
    ap = argparse.ArgumentParser(description="Supplement assembler + structural validator.")
    ap.add_argument("--dir", required=True, help="supplement directory")
    ap.add_argument("--index", default="00_index.md", help="index filename (default 00_index.md)")
    ap.add_argument("--manuscript", help="manuscript .md for callout coverage")
    ap.add_argument("--out", help="write rebuilt _combined.md to this path (index order)")
    ap.add_argument("--json", help="write JSON artifact to this path")
    ap.add_argument("--strict", action="store_true", help="exit 1 on any structural problem")
    ap.add_argument("--quiet", action="store_true", help="suppress stdout report")
    args = ap.parse_args()

    result = analyze(Path(args.dir), args.index,
                     Path(args.manuscript) if args.manuscript else None,
                     Path(args.out) if args.out else None)

    if not args.quiet:
        print("=" * 41)
        print(" Supplement Assembly / Structure")
        print("=" * 41)
        print(f"declared (index): {result['declared']}")
        print(f"present (files):  {result['present']}")
        for p in result["problems"]:
            print(f"  [{p['kind']}] {p['detail']}")
        if result["rebuilt_to"]:
            print(f"rebuilt _combined → {result['rebuilt_to']}")
        s = result["summary"]
        print(f"\n{'STRUCTURAL PROBLEM: ' + str(s['n_structural']) if s['n_structural'] else 'OK: supplement structure consistent.'}")

    if args.json:
        Path(args.json).parent.mkdir(parents=True, exist_ok=True)
        Path(args.json).write_text(json.dumps(result, indent=2), encoding="utf-8")
        if not args.quiet:
            print(f"wrote {args.json}")

    return 1 if (args.strict and result["summary"]["n_structural"]) else 0


if __name__ == "__main__":
    sys.exit(main())

# Author registry — example for blind_sweep.py
#
# Each reviewer entry maps an author's identifiers to their double-blind role label
# (e.g., "Reviewer 1", "Reviewer 2"). The blind_sweep.py script reads this YAML
# and performs phased substitution across supplementary, cover, and response files.
#
# Place a project-local copy under your manuscript root (e.g.,
# `<project>/_shared/authors/author_registry.yaml`) and pass its path to the script.
# Do NOT commit real author identifiers to a public repository — keep the populated
# registry alongside the manuscript, not inside this skill.

reviewers:
  - role: "Reviewer 1"
    full_names: ["Given Surname"]              # roman script, primary author
    native_names: []                            # e.g., ["성명"] for hangul / kanji
    initials_with_period: ["G.S."]
    initials_no_period: ["GS"]
    email: "first.author@example.org"
    orcid: "0000-0000-0000-0000"

  - role: "Reviewer 2"
    full_names: ["Coauthor Name"]
    native_names: []
    initials_with_period: ["C.N."]
    initials_no_period: ["CN"]
    email: null
    orcid: null

institutions:
  - replace: "Hospital A / University B"
    with: "the review team's affiliated institutions"

references:
  # Self-cited PROSPERO record or preprint
  - replace: "Given Surname, Coauthor Name. Title of Registered Review"
    with: "[Authors]. Title of Registered Review"

#!/usr/bin/env python3
"""Blind sweep — redact author identifiers across submission artifacts for double-blind review.

Usage:
  python blind_sweep.py --registry path/to/author_registry.yaml \
                        --files file1.md file2.md ... \
                        [--inplace | --out-dir staging/blinded]

Reads an author registry (YAML) describing identifiers and their role-label
replacements, then performs phased substitution (specific patterns first,
then bare forms, then regex word-boundary forms). Reports residual identifier
counts for each file after blinding.

Registry schema (YAML):
  reviewers:
    - role: "Reviewer 1"
      full_names: ["Given Surname"]      # roman script
      native_names: ["성명"]              # native script (e.g., hangul)
      initials_with_period: ["G.S."]
      initials_no_period: ["GS"]
      email: "user@example.com"
      orcid: "0000-0000-0000-0000"
    - role: "Reviewer 2"
      ...
  institutions:
    - replace: "Institution A / University B"
      with: "the review team's affiliated institutions"
  references:
    - replace: "Given Surname, Other Author. Title"
      with: "[Authors]. Title"

Order of substitution (per file):
  1. Institution and reference patterns (longest specific strings first).
  2. Role-combination patterns (e.g., "Given Surname (GS, 1st reviewer)").
  3. Bare full names and native names.
  4. Regex word-boundary patterns for initials (period and no-period forms),
     emails, ORCIDs, and combined initial patterns.

The script does NOT hard-code any author identifiers — all PII is sourced
from the registry the caller provides. This keeps the tool PII-free for OSS
distribution.
"""
from __future__ import annotations

import argparse
import pathlib
import re
import shutil
import sys
from dataclasses import dataclass, field
from typing import Iterable

try:
    import yaml  # type: ignore
except ImportError:
    print("blind_sweep requires PyYAML. Install: pip install pyyaml", file=sys.stderr)
    sys.exit(2)


@dataclass
class Reviewer:
    role: str
    full_names: list[str] = field(default_factory=list)
    native_names: list[str] = field(default_factory=list)
    initials_with_period: list[str] = field(default_factory=list)
    initials_no_period: list[str] = field(default_factory=list)
    email: str | None = None
    orcid: str | None = None


def load_registry(path: pathlib.Path) -> tuple[list[Reviewer], list[tuple[str, str]], list[tuple[str, str]]]:
    data = yaml.safe_load(path.read_text(encoding="utf-8"))
    reviewers = [Reviewer(**r) for r in data.get("reviewers", [])]
    institutions = [(i["replace"], i["with"]) for i in data.get("institutions", [])]
    references = [(r["replace"], r["with"]) for r in data.get("references", [])]
    return reviewers, institutions, references


def build_substitutions(reviewers: list[Reviewer]) -> tuple[list[tuple[str, str]], list[tuple[str, str]], list[tuple[str, str]]]:
    """Return (phase2_combined, phase3_bare, phase4_regex)."""
    phase2_combined: list[tuple[str, str]] = []
    phase3_bare: list[tuple[str, str]] = []
    phase4_regex: list[tuple[str, str]] = []

    for r in reviewers:
        for name in r.full_names:
            for init in r.initials_no_period + r.initials_with_period:
                for label in (
                    f"{name} ({init}, 1st reviewer)", f"{name} ({init}, 2nd reviewer)",
                    f"{name} ({init}, 1st)", f"{name} ({init}, 2nd)",
                    f"{name} ({init})",
                ):
                    phase2_combined.append((label, r.role))
            phase3_bare.append((name, r.role))
        for name in r.native_names:
            phase3_bare.append((name, r.role))
        for init in r.initials_with_period:
            esc = re.escape(init)
            phase4_regex.append((rf"\b{esc}", r.role))
        for init in r.initials_no_period:
            phase4_regex.append((rf"\b{re.escape(init)}\b", r.role))
        if r.email:
            phase4_regex.append((re.escape(r.email), "[redacted email]"))
        if r.orcid:
            phase4_regex.append((re.escape(r.orcid), "[redacted ORCID]"))

    # Sort phase2/phase3 by length desc so longer-specific patterns win
    phase2_combined.sort(key=lambda kv: -len(kv[0]))
    phase3_bare.sort(key=lambda kv: -len(kv[0]))
    return phase2_combined, phase3_bare, phase4_regex


def blind_text(text: str, phase1: Iterable[tuple[str, str]],
               phase2: Iterable[tuple[str, str]], phase3: Iterable[tuple[str, str]],
               phase4_regex: Iterable[tuple[str, str]]) -> tuple[str, int]:
    changes = 0
    for old, new in list(phase1) + list(phase2) + list(phase3):
        if old in text:
            count = text.count(old)
            text = text.replace(old, new)
            changes += count
    for pat, repl in phase4_regex:
        matches = re.findall(pat, text)
        if matches:
            text = re.sub(pat, repl, text)
            changes += len(matches)
    return text, changes


def residual_scan(text: str, reviewers: list[Reviewer]) -> list[str]:
    residual: list[str] = []
    for r in reviewers:
        for name in r.full_names + r.native_names:
            c = text.count(name)
            if c > 0:
                residual.append(f"{name}={c}")
        for init in r.initials_with_period:
            c = len(re.findall(rf"\b{re.escape(init)}", text))
            if c > 0:
                residual.append(f"{init}={c}")
        for init in r.initials_no_period:
            c = len(re.findall(rf"\b{re.escape(init)}\b", text))
            if c > 0:
                residual.append(f"{init}={c}")
        if r.email:
            c = text.count(r.email)
            if c > 0:
                residual.append(f"{r.email}={c}")
        if r.orcid:
            c = text.count(r.orcid)
            if c > 0:
                residual.append(f"{r.orcid}={c}")
    return residual


def main() -> int:
    ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
    ap.add_argument("--registry", required=True, type=pathlib.Path, help="Author registry YAML")
    ap.add_argument("--files", nargs="+", required=True, type=pathlib.Path, help="Files to blind")
    ap.add_argument("--inplace", action="store_true", help="Overwrite in place (default)")
    ap.add_argument("--out-dir", type=pathlib.Path, help="Write blinded copies under this directory")
    ap.add_argument("--backup-dir", type=pathlib.Path, help="Copy originals here before in-place edit")
    args = ap.parse_args()

    if not args.inplace and not args.out_dir:
        args.inplace = True

    reviewers, institutions, references = load_registry(args.registry)
    phase1 = institutions + references
    phase2, phase3, phase4_regex = build_substitutions(reviewers)

    if args.backup_dir:
        args.backup_dir.mkdir(parents=True, exist_ok=True)
    if args.out_dir:
        args.out_dir.mkdir(parents=True, exist_ok=True)

    print(f"{'FILE':<55} {'CHANGES':<8} RESIDUAL")
    overall_residual = False
    for src in args.files:
        if not src.exists():
            print(f"{src.name:<55} {'-':<8} MISSING")
            continue
        text = src.read_text(encoding="utf-8")
        if args.backup_dir:
            shutil.copy(src, args.backup_dir / src.name)
        new_text, changes = blind_text(text, phase1, phase2, phase3, phase4_regex)
        residual = residual_scan(new_text, reviewers)

        if args.out_dir:
            (args.out_dir / src.name).write_text(new_text, encoding="utf-8")
        else:
            src.write_text(new_text, encoding="utf-8")

        flag = "clean" if not residual else " ".join(residual) + "  WARN"
        if residual:
            overall_residual = True
        print(f"{src.name:<55} {changes:<8} {flag}")

    return 1 if overall_residual else 0


if __name__ == "__main__":
    sys.exit(main())

#!/usr/bin/env python3
"""
check_asset_anonymization.py — submission-stage asset/peripheral anonymization gate.

Body-text anonymization is mature; the blind spot is *peripheral artifacts*. A
double-anonymized submission was nearly broken because a flow-diagram figure,
generated by a script with a hardcoded institution label, carried the real
hospital name — invisible to any docx text scan. File metadata (docx
`dc:creator`, PDF `/Author`) is a second blind spot.

This detector scans a submission/project directory for three deterministic
classes of leak:

  1. **figure-script hardcoded institution** — a figure-generating script
     (`figures/**/*.R|*.py`, or any `*.R|*.py` under a `figures*` dir) contains
     an institution-like token (Hospital / University / Medical Center / IRB /
     병원 / 의료원 …) or a name supplied via --names-file.
  2. **figure/asset PDF rendered text** — a figure PDF's extracted text carries
     an institution token or a --names-file name (de-anonymization risk). When a
     figure carries *any* rendered text, a `visual_check` advisory is emitted
     (text scanning cannot see rasterized labels).
  3. **document metadata author** — a `.docx` `dc:creator`/`cp:lastModifiedBy`
     or a `.pdf` Author/Creator is a real person/identifier (not empty / not a
     known tool).
  4. **docx embedded absolute path** — a `word/*.xml` attribute (e.g. a drawing's
     `<pic:cNvPr descr="...">`) carries an absolute home-dir path
     (`/Users/<user>/…`, `/home/<user>/…`). pandoc writes the source image path
     into the picture description when handed an absolute path, leaking the
     username into the docx body XML where a rendered-text scan never sees it.
     Fix: use a relative image path + `pandoc --resource-path=<figdir>`.

Severity:
  - `leak`   — metadata author present, or a --names-file name found anywhere.
  - `review` — institution-token hit, or a figure carries rendered text.

Exit: 0 = clean, 1 = findings (any `leak`; also `review` under --strict),
2 = usage/error. Degrades gracefully when poppler (pdftotext/pdfinfo) is absent:
script-grep and docx-metadata checks still run; PDF text/metadata checks are
reported as skipped (poppler_available:false) rather than silently passing.

Patterns are generic — no real names are baked in. Supply institution/author
names locally with --names-file (one per line); that file is never committed.

Stdlib-only.

Usage:
    python3 check_asset_anonymization.py --dir submission/ [--names-file names.txt]
        [--out qc/asset_anon.json] [--strict] [--quiet]
"""

from __future__ import annotations

import argparse
import json
import re
import shutil
import subprocess
import sys
import zipfile
from dataclasses import dataclass, field, asdict
from pathlib import Path

# Generic institution / ethics-board tokens (English + Korean). No proper names.
INSTITUTION_RE = re.compile(
    r"\b(?:Hospital|Hospitals|University|Universit[äe]t|College of Medicine|"
    r"School of Medicine|Faculty of Medicine|Medical Cent(?:er|re)|Health System|"
    r"Cancer Cent(?:er|re)|Infirmary|Institutional Review Board|"
    r"IRB(?:[\s.:#-]*(?:No|Number|#)|\s*approval)?)\b"
    r"|병원|의료원|의과대학|대학교|연구윤리",
    re.IGNORECASE,
)

# docx/pdf metadata authorship values that are NOT a real person (tools/blanks).
TOOL_AUTHORS = (
    "unknown", "microsoft office user", "pandoc", "libreoffice", "writer",
    "openoffice", "word", "microsoft word", "google", "overleaf", "latex",
    "pdftex", "pdflatex", "xelatex", "lualatex", "quarto", "rmarkdown",
    "knitr", "wps", "author",
)


def _is_tool_author(value: str) -> bool:
    """True if a metadata author value is blank or a known tool (not a person)."""
    v = value.strip().lower()
    if not v:
        return True
    return any(v == t or v.startswith(t) for t in TOOL_AUTHORS)

FIG_SCRIPT_GLOBS = ("*.R", "*.r", "*.py")
DC_CREATOR_RE = re.compile(r"<dc:creator>([^<]*)</dc:creator>")
LAST_MOD_RE = re.compile(r"<cp:lastModifiedBy>([^<]*)</cp:lastModifiedBy>")
# Absolute home-dir path leaked into an OOXML attribute (e.g. a drawing's
# <pic:cNvPr descr="/Users/<user>/.../fig.png">). pandoc embeds the source image
# path as the picture description when given an absolute path; it carries the
# username into the docx body XML, invisible to a rendered-text scan.
DOCX_ABS_PATH_RE = re.compile(r'(?:descr|name|title)="(/(?:Users|home)/[^"]+)"')


@dataclass
class Finding:
    type: str
    severity: str  # "leak" | "review"
    path: str
    detail: str


@dataclass
class Report:
    findings: list[Finding] = field(default_factory=list)
    scanned: dict[str, int] = field(default_factory=dict)
    poppler_available: bool = False
    skipped: list[str] = field(default_factory=list)

    @property
    def has_leak(self) -> bool:
        return any(f.severity == "leak" for f in self.findings)

    def submission_safe(self, strict: bool) -> bool:
        if self.has_leak:
            return False
        if strict and any(f.severity == "review" for f in self.findings):
            return False
        return True

    def as_dict(self, strict: bool) -> dict:
        return {
            "submission_safe": self.submission_safe(strict),
            "strict": strict,
            "poppler_available": self.poppler_available,
            "scanned": self.scanned,
            "skipped": self.skipped,
            "summary": {
                "leak": sum(1 for f in self.findings if f.severity == "leak"),
                "review": sum(1 for f in self.findings if f.severity == "review"),
            },
            "findings": [asdict(f) for f in self.findings],
        }


def _is_under_figures(p: Path) -> bool:
    return any(part.lower().startswith(("figure", "fig", "graphic")) for part in p.parts)


def _load_names(names_file: Path | None) -> list[str]:
    if not names_file:
        return []
    out = []
    for line in names_file.read_text(encoding="utf-8", errors="replace").splitlines():
        s = line.strip()
        if s and not s.startswith("#"):
            out.append(s)
    return out


def _name_hits(text: str, names: list[str]) -> list[str]:
    low = text.lower()
    return [n for n in names if n.lower() in low]


def _pdftotext(pdf: Path) -> str | None:
    try:
        r = subprocess.run(["pdftotext", "-q", str(pdf), "-"],
                           capture_output=True, text=True, timeout=60)
        return r.stdout
    except Exception:
        return None


def _pdf_author(pdf: Path) -> str | None:
    try:
        r = subprocess.run(["pdfinfo", str(pdf)], capture_output=True, text=True, timeout=30)
    except Exception:
        return None
    author = creator = ""
    for line in r.stdout.splitlines():
        if line.startswith("Author:"):
            author = line.split(":", 1)[1].strip()
        elif line.startswith("Creator:"):
            creator = line.split(":", 1)[1].strip()
    for v in (author, creator):
        if v and not _is_tool_author(v):
            return v
    return None


def _docx_authors(docx: Path) -> list[str]:
    try:
        with zipfile.ZipFile(docx) as z:
            if "docProps/core.xml" not in z.namelist():
                return []
            core = z.read("docProps/core.xml").decode("utf-8", errors="replace")
    except Exception:
        return []
    vals = []
    for m in (*DC_CREATOR_RE.finditer(core), *LAST_MOD_RE.finditer(core)):
        v = m.group(1).strip()
        if v and not _is_tool_author(v):
            vals.append(v)
    return vals


def _docx_embedded_abs_paths(docx: Path) -> list[str]:
    """Absolute home-dir paths leaked into word/*.xml attributes (e.g. a
    pandoc-embedded image's pic descr). Returns the offending path strings."""
    hits: list[str] = []
    try:
        with zipfile.ZipFile(docx) as z:
            parts = [n for n in z.namelist()
                     if n.startswith("word/") and n.endswith(".xml")]
            for name in parts:
                xml = z.read(name).decode("utf-8", errors="replace")
                for m in DOCX_ABS_PATH_RE.finditer(xml):
                    hits.append(m.group(1))
    except Exception:
        return []
    # de-dup, preserve order
    seen: set[str] = set()
    out = []
    for h in hits:
        if h not in seen:
            seen.add(h)
            out.append(h)
    return out


def build_report(root: Path, names: list[str], poppler: bool) -> Report:
    rep = Report(poppler_available=poppler)
    scripts = docx_files = pdf_files = 0

    for p in sorted(root.rglob("*")):
        if not p.is_file() or "__pycache__" in p.parts:
            continue
        suffix = p.suffix.lower()
        rel = str(p.relative_to(root))

        # 1. figure-generating scripts
        if suffix in (".r", ".py") and _is_under_figures(p):
            scripts += 1
            text = p.read_text(encoding="utf-8", errors="replace")
            for i, line in enumerate(text.splitlines(), 1):
                if INSTITUTION_RE.search(line):
                    rep.findings.append(Finding(
                        "figure_script_institution", "review", f"{rel}:{i}",
                        f"institution-like token in figure script: {line.strip()[:120]}"))
                for n in _name_hits(line, names):
                    rep.findings.append(Finding(
                        "figure_script_name", "leak", f"{rel}:{i}",
                        f"name '{n}' hardcoded in figure script"))

        # 2 + 3. docx metadata
        elif suffix == ".docx":
            docx_files += 1
            for a in _docx_authors(p):
                rep.findings.append(Finding(
                    "docx_metadata_author", "leak", rel,
                    f"docx author metadata: '{a}'"))
            # 4. absolute home-dir path embedded in word/*.xml (e.g. pic descr)
            for ap_ in _docx_embedded_abs_paths(p):
                rep.findings.append(Finding(
                    "docx_embedded_abs_path", "leak", rel,
                    f"absolute path in docx XML (username leak; use a relative "
                    f"image path + pandoc --resource-path): {ap_}"))

        # PDFs: metadata + (figure) rendered-text
        elif suffix == ".pdf":
            pdf_files += 1
            if poppler:
                a = _pdf_author(p)
                if a:
                    rep.findings.append(Finding(
                        "pdf_metadata_author", "leak", rel, f"pdf author/creator: '{a}'"))
                if _is_under_figures(p):
                    txt = _pdftotext(p)
                    if txt is None:
                        rep.skipped.append(f"pdftotext failed: {rel}")
                    elif txt.strip():
                        rep.findings.append(Finding(
                            "figure_rendered_text", "review", rel,
                            "figure PDF carries rendered text — visual-check for "
                            "institution/IRB#/author labels a text scan cannot see"))
                        if INSTITUTION_RE.search(txt):
                            rep.findings.append(Finding(
                                "figure_text_institution", "review", rel,
                                "institution-like token in figure PDF text"))
                        for n in _name_hits(txt, names):
                            rep.findings.append(Finding(
                                "figure_text_name", "leak", rel,
                                f"name '{n}' in figure PDF text"))
            else:
                rep.skipped.append(f"poppler unavailable, PDF not scanned: {rel}")

    rep.scanned = {"figure_scripts": scripts, "docx": docx_files, "pdf": pdf_files}
    return rep


def main(argv: list[str] | None = None) -> int:
    ap = argparse.ArgumentParser(
        description="Submission-stage asset/figure/metadata anonymization gate.")
    ap.add_argument("--dir", type=Path, default=Path.cwd(),
                    help="Root directory to scan (default: cwd).")
    ap.add_argument("--names-file", type=Path, default=None,
                    help="Newline-separated institution/author names to flag (local only).")
    ap.add_argument("--out", type=Path, default=None, help="Write JSON report here.")
    ap.add_argument("--strict", action="store_true",
                    help="Also fail on 'review' findings (institution tokens, rendered text).")
    ap.add_argument("--quiet", action="store_true", help="Suppress stdout summary.")
    args = ap.parse_args(argv)

    if not args.dir.is_dir():
        print(f"ERROR: --dir not a directory: {args.dir}", file=sys.stderr)
        return 2
    if args.names_file is not None and not args.names_file.is_file():
        print(f"ERROR: --names-file not a file: {args.names_file}", file=sys.stderr)
        return 2

    poppler = shutil.which("pdftotext") is not None and shutil.which("pdfinfo") is not None
    names = _load_names(args.names_file)
    rep = build_report(args.dir, names, poppler)
    safe = rep.submission_safe(args.strict)

    if args.out is not None:
        args.out.parent.mkdir(parents=True, exist_ok=True)
        args.out.write_text(json.dumps(rep.as_dict(args.strict), indent=2), encoding="utf-8")

    if not args.quiet:
        if not poppler:
            print("NOTE: poppler (pdftotext/pdfinfo) not found — PDF text/metadata "
                  "checks skipped; install poppler-utils for full coverage.")
        if safe:
            n = len(rep.findings)
            print(f"PASS: no anonymization leak ({rep.scanned}; {n} advisory finding(s)).")
        else:
            print(f"FAIL: anonymization findings — {rep.as_dict(args.strict)['summary']}")
            for f in rep.findings:
                print(f"  - [{f.severity}] {f.type} {f.path}: {f.detail}")

    return 0 if safe else 1


if __name__ == "__main__":
    sys.exit(main())

#!/usr/bin/env python3
"""
check_cross_artifact_stale.py — submission-stage cross-artifact staleness gate.

Body-text QC is mature; peripheral artifacts lag. A late correction fixed in the
manuscript body can persist — sometimes *reversed* — in a supplement footnote,
and a reporting checklist is often generated against an older manuscript version
(stale section/line references and a stale version label). Both reach reviewers.

Two deterministic checks:

  1. **labeled-value drift** — for a small set of reconciliation-prone labels
     (missingness, complete-case, kappa/κ, agreement, prevalence, incidence,
     response rate, follow-up, pack-years, mortality), collect every numeric
     value the *body* attaches to each label, and every value an *auxiliary*
     file (supplement, e-table, caption, checklist) attaches to the same label.
     An auxiliary value for a label the body also reports, but which the body
     never states, is a `labeled_value_drift` (the supplement disagrees with the
     corrected body).

  2. **checklist version staleness** — a reporting checklist (file name contains
     `checklist`/`strobe`/`prisma`/`consort`/`stard`/`tripod`/`claim`) that
     embeds a manuscript-version marker (`manuscript_v6`, `v6 (2026-04-20)`,
     `Target manuscript: ... v6`) which differs from the current version
     (`--manuscript-version`, or a `vN` in the manuscript filename) is flagged
     `checklist_version_stale` — its line/section refs no longer match.

Exit: 0 = clean, 1 = findings, 2 = usage/error. Stdlib-only.

Usage:
    python3 check_cross_artifact_stale.py --manuscript manuscript.md \
        --aux supplement/ --aux qc/ [--manuscript-version v8] \
        [--out qc/cross_artifact.json] [--strict] [--quiet]
"""

from __future__ import annotations

import argparse
import json
import re
import sys
from dataclasses import dataclass, field, asdict
from pathlib import Path

# Reconciliation-prone labels → a regex fragment matching the label.
LABELS: dict[str, str] = {
    "missingness": r"missing(?:ness)?",
    "complete_case": r"complete[-\s]?case",
    "kappa": r"κ|kappa",
    "agreement": r"agreement",
    "prevalence": r"prevalence",
    "incidence": r"incidence",
    "response_rate": r"response\s+rate",
    "follow_up": r"follow[-\s]?up",
    "pack_years": r"pack[-\s]?years?",
    "mortality": r"mortality",
}

# A number near a label: label … (within 40 chars) … value, optional %.
VALUE_RE = r"[^\n.]{0,40}?(\d+(?:\.\d+)?)\s*(%?)"

CHECKLIST_NAME_RE = re.compile(
    r"(checklist|strobe|prisma|consort|stard|tripod|claim|squire|arrive|care)",
    re.IGNORECASE,
)
# Manuscript-version markers a checklist might embed.
VERSION_MARKER_RE = re.compile(
    r"(?:manuscript[_\s]*|target\s+manuscript[^\n]*?\bv|version[^\n]*?\bv|\bv)"
    r"(\d{1,3})\b",
    re.IGNORECASE,
)
FILENAME_VERSION_RE = re.compile(r"[_\-.]v(\d{1,3})\b", re.IGNORECASE)


@dataclass
class Finding:
    type: str
    severity: str  # "stale" | "version_stale"
    path: str
    detail: str


@dataclass
class Report:
    findings: list[Finding] = field(default_factory=list)
    scanned: dict[str, int] = field(default_factory=dict)

    @property
    def submission_safe(self) -> bool:
        return not self.findings

    def as_dict(self) -> dict:
        return {
            "submission_safe": self.submission_safe,
            "scanned": self.scanned,
            "summary": {
                "stale": sum(1 for f in self.findings if f.severity == "stale"),
                "version_stale": sum(1 for f in self.findings if f.severity == "version_stale"),
            },
            "findings": [asdict(f) for f in self.findings],
        }


def label_values(text: str) -> dict[str, set[str]]:
    """Map each known label to the set of numeric values stated near it."""
    out: dict[str, set[str]] = {}
    for key, frag in LABELS.items():
        vals: set[str] = set()
        for m in re.finditer(frag + VALUE_RE, text, re.IGNORECASE):
            num, pct = m.group(1), m.group(2)
            vals.add(num + ("%" if pct else ""))
        if vals:
            out[key] = vals
    return out


def _iter_files(paths: list[Path]) -> list[Path]:
    files: list[Path] = []
    for p in paths:
        if p.is_dir():
            files += [q for q in sorted(p.rglob("*"))
                      if q.is_file() and q.suffix.lower() in (".md", ".txt", ".csv", ".tsv", ".yaml", ".yml")]
        elif p.is_file():
            files.append(p)
    return files


def _manuscript_version(manuscript: Path, explicit: str | None) -> int | None:
    if explicit:
        m = re.search(r"\d+", explicit)
        if m:
            return int(m.group(0))
    m = FILENAME_VERSION_RE.search(manuscript.name)
    return int(m.group(1)) if m else None


def build_report(manuscript: Path, aux_paths: list[Path], version: int | None) -> Report:
    rep = Report()
    body = manuscript.read_text(encoding="utf-8", errors="replace")
    body_labels = label_values(body)

    aux_files = [f for f in _iter_files(aux_paths) if f.resolve() != manuscript.resolve()]
    for f in aux_files:
        text = f.read_text(encoding="utf-8", errors="replace")
        rel = str(f)

        # 1. labeled-value drift vs the body
        for key, vals in label_values(text).items():
            if key not in body_labels:
                continue  # body does not report this label — not a reconciliation target
            drift = vals - body_labels[key]
            for v in sorted(drift):
                rep.findings.append(Finding(
                    "labeled_value_drift", "stale", rel,
                    f"'{key}' = {v} here, but the body reports "
                    f"{sorted(body_labels[key])} — possible stale value"))

        # 2. checklist version staleness
        if version is not None and CHECKLIST_NAME_RE.search(f.name):
            embedded = {int(m.group(1)) for m in VERSION_MARKER_RE.finditer(text)}
            older = sorted(v for v in embedded if v < version)
            if older:
                rep.findings.append(Finding(
                    "checklist_version_stale", "version_stale", rel,
                    f"references manuscript version(s) v{older} but current is v{version}"))

    rep.scanned = {"aux_files": len(aux_files), "body_labels": len(body_labels)}
    return rep


def main(argv: list[str] | None = None) -> int:
    ap = argparse.ArgumentParser(
        description="Cross-artifact staleness gate (labeled-value drift + checklist version).")
    ap.add_argument("--manuscript", type=Path, required=True, help="Body manuscript markdown.")
    ap.add_argument("--aux", type=Path, action="append", default=[],
                    help="Auxiliary file or directory (supplement/checklist/captions). Repeatable.")
    ap.add_argument("--manuscript-version", default=None,
                    help="Current manuscript version, e.g. v8 (else inferred from filename).")
    ap.add_argument("--out", type=Path, default=None, help="Write JSON report here.")
    ap.add_argument("--strict", action="store_true",
                    help="(Reserved) all findings already fail; flag kept for interface parity.")
    ap.add_argument("--quiet", action="store_true", help="Suppress stdout summary.")
    args = ap.parse_args(argv)

    if not args.manuscript.is_file():
        print(f"ERROR: --manuscript not a file: {args.manuscript}", file=sys.stderr)
        return 2
    if not args.aux:
        print("ERROR: at least one --aux is required", file=sys.stderr)
        return 2

    version = _manuscript_version(args.manuscript, args.manuscript_version)
    rep = build_report(args.manuscript, args.aux, version)

    if args.out is not None:
        args.out.parent.mkdir(parents=True, exist_ok=True)
        args.out.write_text(json.dumps(rep.as_dict(), indent=2), encoding="utf-8")

    if not args.quiet:
        if rep.submission_safe:
            print(f"PASS: no cross-artifact staleness ({rep.scanned}).")
        else:
            print(f"FAIL: cross-artifact staleness — {rep.as_dict()['summary']}")
            for f in rep.findings:
                print(f"  - [{f.severity}] {f.type} {f.path}: {f.detail}")

    return 0 if rep.submission_safe else 1


if __name__ == "__main__":
    sys.exit(main())

#!/usr/bin/env python3
"""AI-disclosure + data/code-availability statement detector (sync-submission).

Top medical-AI journals (Lancet Digital Health, Radiology / Radiology:AI, npj
Digital Medicine, Nature Medicine) now require, before peer review:
  - an AI/LLM-use disclosure that itself names the tool **version**, the **access
    channel**, the **date / date-range**, and the **responsible party** (the four
    tokens FLAIR F1.6 / TRIPOD-LLM / MI-CLEAR-LLM demand; the tool NAME, e.g.
    ChatGPT/Claude, is the applicability identifier that triggers the check, NOT
    one of the four required tokens), with no unresolved placeholders;
  - a Data Availability statement (not a hollow "available on reasonable request"
    when the journal expects a repository);
  - a Code Availability statement with a resolvable URL/DOI for an AI/ML study.

This detector scans the manuscript for those statements and checks them against
references/journal_availability_policy.json (public facts, journal-keyed). It is
deterministic and stdlib-only.

INPUTS
  --manuscript   markdown file (required).
  --journal      journal stem (selects the policy row; falls back to "default").
  --policy       path to journal_availability_policy.json (default: alongside skill).
  --ai-study     treat as an AI/ML study (code availability becomes expected).
  --require      repeatable hard-required statement(s): ai_disclosure |
                 data_availability | code_availability | funding | coi. An absent
                 required statement is a BLOCKER regardless of --strict.
  --strict       promote advisory (P1) findings to blockers.
  --out          JSON report path (default: qc/disclosure_availability_report.json).

VERDICT / EXIT
  CLEAN        no findings.
  ADVISORY     only P1 (warn) findings.
  BLOCKER      a hard rule failed: a --require'd statement absent, OR an AI
               disclosure present but missing a required token / carrying a
               placeholder.
  Exit: 0 clean/advisory (or report-only); 1 BLOCKER (or ADVISORY under --strict);
        2 input/usage error.

Stdlib-only.
"""

from __future__ import annotations

import argparse
import json
import re
import sys
from pathlib import Path

AI_TRIGGER = re.compile(
    r"generative ai|large language model|\bLLM\b|ai[- ]assisted|"
    r"assisted (?:the|with|in) (?:writing|drafting|editing)|"
    r"\bChatGPT\b|\bGPT-?[0-9]|\bClaude\b|\bCopilot\b|\bGemini\b|\bLlama\b",
    re.IGNORECASE,
)
TOKEN_VERSION = re.compile(r"\b\d+\.\d+\b|\bGPT-?\d|\b(?:Claude|Gemini|Llama|GPT)\s+\d", re.IGNORECASE)
TOKEN_CHANNEL = re.compile(r"\bAPI\b|\bchat\b|\bweb\b|\bBedrock\b|\bAzure\b|\binterface\b|\bapp\b", re.IGNORECASE)
TOKEN_DATE = re.compile(r"\b20\d{2}\b")
TOKEN_RESPONSIBLE = re.compile(
    r"\bby [A-Z]\.\s?[A-Z]\.|the authors|reviewed by|deployed by|operated by|under the supervision",
    re.IGNORECASE,
)
PLACEHOLDER = re.compile(r"\[(?:version|date|tool|name|model|n)\]|\bTODO\b|XXXX|\bTBD\b", re.IGNORECASE)

REASONABLE_REQUEST = re.compile(r"available (?:from the (?:corresponding )?author )?on (?:reasonable )?request", re.IGNORECASE)
RESOLVABLE = re.compile(r"https?://|doi\.org/|\bgithub\.com\b|\bzenodo\b|\bosf\.io\b|10\.\d{4,}/", re.IGNORECASE)

SECTION_LABELS = {
    "data_availability": r"data availability|availability of data",
    "code_availability": r"code availability|availability of code|software availability",
    "funding": r"funding|financial support|grant support",
    "coi": r"conflicts? of interest|competing interests?|declaration of interests?|disclosure",
}


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


def load_policy(path: Path, journal: str | None) -> dict:
    data = json.loads(path.read_text(encoding="utf-8"))
    if journal:
        row = data.get("journals", {}).get(journal.strip().lower())
        if row:
            return row
    return data.get("default", {})


def find_section(text: str, pattern: str) -> str | None:
    """Return the block of text under a heading/bold label matching `pattern`."""
    lines = text.splitlines()
    head = re.compile(r"^\s*(?:#{1,6}\s*|\*\*\s*)?(?:" + pattern + r")\b", re.IGNORECASE)
    start = None
    for i, ln in enumerate(lines):
        if head.search(ln):
            start = i
            break
    if start is None:
        return None
    out = [lines[start]]
    for ln in lines[start + 1:]:
        if re.match(r"^\s*#{1,6}\s+\S", ln):
            break
        out.append(ln)
    return "\n".join(out).strip()


def ai_disclosure_block(text: str) -> str | None:
    """Find the paragraph that carries the AI-use disclosure (the one that trips
    AI_TRIGGER), preferring an explicit AI-disclosure-style heading if present."""
    for pat in (r"ai (?:use )?disclosure|use of (?:generative )?ai|artificial intelligence",):
        blk = find_section(text, pat)
        if blk and AI_TRIGGER.search(blk):
            return blk
    # else: the first paragraph that mentions an AI tool
    for para in re.split(r"\n\s*\n", text):
        if AI_TRIGGER.search(para):
            return para.strip()
    return None


def check(text: str, policy: dict, ai_study: bool, require: set[str], strict: bool) -> dict:
    findings: list[dict] = []

    # --- AI disclosure (only when the manuscript actually used/mentioned an AI tool) ---
    blk = ai_disclosure_block(text)
    if blk is not None:
        tokens = {
            "version": bool(TOKEN_VERSION.search(blk)),
            "access channel": bool(TOKEN_CHANNEL.search(blk)),
            "date": bool(TOKEN_DATE.search(blk)),
            "responsible party": bool(TOKEN_RESPONSIBLE.search(blk)),
        }
        missing = [k for k, v in tokens.items() if not v]
        if missing:
            findings.append({"rule": "ai_disclosure_tokens", "severity": "hard",
                             "detail": f"AI disclosure missing required token(s): {', '.join(missing)}"})
        if PLACEHOLDER.search(blk):
            findings.append({"rule": "ai_disclosure_placeholder", "severity": "hard",
                             "detail": "AI disclosure contains an unresolved placeholder ([version]/[date]/TODO/...)"})
    elif "ai_disclosure" in require:
        findings.append({"rule": "ai_disclosure_present", "severity": "hard",
                         "detail": "no AI-use disclosure found, but --require ai_disclosure was set"})

    # --- Data availability ---
    data_blk = find_section(text, SECTION_LABELS["data_availability"])
    data_required = policy.get("data_required", False) or ("data_availability" in require)
    if data_blk is None:
        if data_required:
            findings.append({"rule": "data_availability_present", "severity": "hard",
                             "detail": "no Data Availability statement found"})
    else:
        if policy.get("repository_required") and REASONABLE_REQUEST.search(data_blk) and not RESOLVABLE.search(data_blk):
            findings.append({"rule": "data_availability_hollow", "severity": "soft",
                             "detail": "Data Availability is 'available on request' but the journal expects a repository/DOI"})

    # --- Code availability (AI/ML studies) ---
    code_blk = find_section(text, SECTION_LABELS["code_availability"])
    code_required = ("code_availability" in require) or (ai_study and policy.get("code_required_if_ai", False))
    if code_blk is None:
        if code_required:
            findings.append({"rule": "code_availability_present", "severity": "hard",
                             "detail": "no Code Availability statement found for an AI/ML study"})
    elif not RESOLVABLE.search(code_blk):
        findings.append({"rule": "code_availability_resolvable", "severity": "soft",
                         "detail": "Code Availability statement has no resolvable URL/DOI (github/zenodo/doi.org)"})

    # --- Funding / COI presence ---
    for key in ("funding", "coi"):
        blk2 = find_section(text, SECTION_LABELS[key])
        if blk2 is None:
            sev = "hard" if key in require else "soft"
            findings.append({"rule": f"{key}_present", "severity": sev,
                             "detail": f"no {key.upper() if key == 'coi' else key.title()} statement found"})

    hard = any(f["severity"] == "hard" for f in findings)
    if hard:
        verdict = "BLOCKER"
    elif findings:
        verdict = "BLOCKER" if strict else "ADVISORY"
    else:
        verdict = "CLEAN"
    return {"verdict": verdict, "ai_disclosure_found": blk is not None, "findings": findings}


def main() -> int:
    ap = argparse.ArgumentParser(description="Check AI-disclosure + data/code-availability statements.")
    ap.add_argument("--manuscript", required=True)
    ap.add_argument("--journal")
    ap.add_argument("--policy")
    ap.add_argument("--ai-study", action="store_true")
    ap.add_argument("--require", action="append", default=[],
                    choices=["ai_disclosure", "data_availability", "code_availability", "funding", "coi"])
    ap.add_argument("--strict", action="store_true")
    ap.add_argument("--out")
    args = ap.parse_args()

    man = Path(args.manuscript)
    if not man.is_file():
        return _err(f"manuscript not found: {man}")
    policy_path = Path(args.policy) if args.policy else \
        Path(__file__).resolve().parent.parent / "references" / "journal_availability_policy.json"
    if not policy_path.is_file():
        return _err(f"policy not found: {policy_path}")

    policy = load_policy(policy_path, args.journal)
    report = check(man.read_text(encoding="utf-8"), policy, args.ai_study, set(args.require), args.strict)

    out_path = Path(args.out) if args.out else Path("qc") / "disclosure_availability_report.json"
    out_path.parent.mkdir(parents=True, exist_ok=True)
    out_path.write_text(json.dumps(report, indent=2) + "\n", encoding="utf-8")

    print("=" * 41)
    print(" Disclosure & Availability")
    print("=" * 41)
    print(f"journal: {args.journal or 'default'}   ai-study: {args.ai_study}")
    print(f"verdict: {report['verdict']}")
    for f in report["findings"]:
        print(f"  [{f['severity']}] {f['rule']}: {f['detail']}")
    print(f"report: {out_path}")

    if report["verdict"] == "BLOCKER":
        print("\nDISCLOSURE_AVAILABILITY_BLOCKER", file=sys.stderr)
        return 1
    return 0


if __name__ == "__main__":
    sys.exit(main())

#!/usr/bin/env python3
"""Body-word-count vs journal cap gate (the revision-inflation trap).

A revise loop monotonically *adds* words — resolving reviewer majors appends
sentences, sensitivity analyses, and caveats — and silently pushes the body over
the target journal's word limit. It is caught, if at all, only by a manual
measurement late in the cycle. This gate makes the measurement deterministic and
cheap enough to re-run after every `/revise` pass.

It counts the manuscript **body** (Introduction → Discussion), excluding YAML
front matter, the abstract, references, tables/figures, supplementary, and the
declaration sections (the same skip set as the cover-letter drift check, vendored
here so this script is self-contained), and compares it to a word cap.

THE BINDING NUMBER IS THE RENDERED WORD COUNT. pandoc citeproc expands each
`[@key]` to "(Author Year)", so the rendered DOCX counts higher than the markdown.
This gate approximates the rendered count as `body_words + n_inline_citations *
--citation-expansion` (default 1.6). When you have the authoritative rendered
count (e.g. Word's count on the built DOCX), pass it with `--rendered-words N` and
that is used verbatim.

CAP SOURCE
  --limit N                 the body word cap (deterministic; preferred).
  --journal-profile P       a find-journal profile .md; the cap is parsed from the
    [--article-type T]      article-type line (default match: "Original"). If the
                            cap cannot be parsed to a single integer, the script
                            errors and asks for --limit (no fuzzy guessing).

OUTPUT
  stdout summary and, with --out, a JSON artifact:
    {manuscript, body_words, n_inline_citations, rendered_words_est, limit,
     near_threshold, ratio, verdict}
  WORDCOUNT_OVER_CAP (Major) when the effective count exceeds the cap;
  WORDCOUNT_NEAR_CAP (Minor) when it exceeds near_threshold * cap (default 0.95).
  Exit 1 (with --strict) when WORDCOUNT_OVER_CAP fires.

Stdlib-only (re / json / argparse / pathlib). Exit codes: 0 clean / near (or
report-only), 1 over cap (with --strict), 2 input/usage error.
"""

from __future__ import annotations

import argparse
import json
import re
import sys
from pathlib import Path

# --- measurement (vendored from cover_letter_drift_check.py; keep in sync) -----

SKIP_SECTION_RE = re.compile(
    r"^#{1,3}\s+\*{0,2}\s*("
    r"Abstract|References?|Table\s+Captions?|Table\s+Legends?|Figure\s+Legends?|"
    r"Tables?|Figures?|Supplementary\s+(Materials?|Tables?|Figures?|Appendix)|"
    r"Acknowled[gd]e?ments?|Funding|Conflicts?\s+of\s+Interest|COI|"
    r"Author\s+Contributions?|Data\s+Availability|Code\s+Availability|"
    r"AI\s+Disclosure|Artificial\s+Intelligence\s+Disclosure"
    r")\s*\*{0,2}\s*:?\s*$",
    re.IGNORECASE,
)
YAML_FENCE_RE = re.compile(r"^---\s*$")
WORD_RE = re.compile(r"[A-Za-z0-9][A-Za-z0-9'./%\-]*")
# pandoc inline citations: [@key], [@k1; @k2], [-@k]. Count each @key.
CITE_RE = re.compile(r"@[A-Za-z0-9_][A-Za-z0-9_:.\-]*")
HEADER_RE = re.compile(r"^#{1,3}\s")


def _strip_yaml_front_matter(lines: list[str]) -> list[str]:
    if not lines or not YAML_FENCE_RE.match(lines[0].rstrip()):
        return lines
    for i, line in enumerate(lines[1:], start=1):
        if YAML_FENCE_RE.match(line.rstrip()):
            return lines[i + 1:]
    return lines


def measure_body(manuscript_path: Path) -> tuple[int, int]:
    """Return (body_words, n_inline_citations) over the non-skipped body."""
    lines = manuscript_path.read_text(encoding="utf-8").splitlines()
    body_lines = _strip_yaml_front_matter(lines)
    in_skip = False
    in_code_fence = False
    words = 0
    cites = 0
    for line in body_lines:
        stripped = line.rstrip()
        if stripped.startswith("```"):
            in_code_fence = not in_code_fence
            continue
        if in_code_fence:
            continue
        if HEADER_RE.match(stripped):
            in_skip = bool(SKIP_SECTION_RE.match(stripped))
            continue
        if in_skip:
            continue
        if stripped.startswith("|") or stripped.startswith("<!--"):
            continue
        cites += len(CITE_RE.findall(stripped))
        # Don't count the citation tokens themselves as prose words.
        prose = CITE_RE.sub(" ", stripped)
        words += len(WORD_RE.findall(prose))
    return words, cites


# --- cap from a journal profile --------------------------------------------

# "Original Article (4,000 words ...)" / "Original Research Article (≤ 5,000 words ...)"
PROFILE_LIMIT_RE = re.compile(r"(?:≤|<=|<|up to|max(?:imum)?)?\s*([0-9][0-9,]{2,})\s*[- ]?words?",
                              re.IGNORECASE)


def parse_cap_from_profile(profile: Path, article_type: str) -> int:
    if not profile.is_file():
        sys.stderr.write(f"ERROR: journal profile not found: {profile}\n")
        sys.exit(2)
    want = article_type.lower()
    candidates: list[int] = []
    for line in profile.read_text(encoding="utf-8").splitlines():
        if want in line.lower():
            nums = [int(m.group(1).replace(",", "")) for m in PROFILE_LIMIT_RE.finditer(line)]
            # the first "N words" on the article-type line is the body cap
            if nums:
                candidates.append(nums[0])
    uniq = sorted(set(candidates))
    if len(uniq) != 1:
        sys.stderr.write(
            f"ERROR: could not parse a single body word cap for article type "
            f"'{article_type}' from {profile.name} (found {uniq or 'none'}). "
            f"Pass --limit N explicitly.\n")
        sys.exit(2)
    return uniq[0]


# --- core ------------------------------------------------------------------

def analyze(manuscript: Path, limit: int, citation_expansion: float,
            near_threshold: float, rendered_words: int | None) -> dict:
    if not manuscript.is_file():
        sys.stderr.write(f"ERROR: manuscript not found: {manuscript}\n")
        sys.exit(2)
    body_words, n_cites = measure_body(manuscript)
    if rendered_words is not None:
        effective = rendered_words
        basis = "rendered_words (authoritative)"
    else:
        effective = body_words + round(n_cites * citation_expansion)
        basis = f"body_words + {n_cites} citations x {citation_expansion}"
    ratio = effective / limit if limit else 0.0
    if effective > limit:
        verdict, severity = "WORDCOUNT_OVER_CAP", "Major"
    elif effective > near_threshold * limit:
        verdict, severity = "WORDCOUNT_NEAR_CAP", "Minor"
    else:
        verdict, severity = "OK", None
    return {
        "manuscript": str(manuscript),
        "body_words": body_words,
        "n_inline_citations": n_cites,
        "rendered_words_est": effective,
        "rendered_basis": basis,
        "limit": limit,
        "near_threshold": near_threshold,
        "ratio": round(ratio, 4),
        "verdict": verdict,
        "severity": severity,
    }


def main() -> int:
    ap = argparse.ArgumentParser(description="Body word count vs journal cap gate.")
    ap.add_argument("--manuscript", required=True, help="manuscript markdown")
    ap.add_argument("--limit", type=int, help="body word cap (preferred; deterministic)")
    ap.add_argument("--journal-profile", help="find-journal profile .md to parse the cap from")
    ap.add_argument("--article-type", default="Original",
                    help="article-type label to match in the profile (default: 'Original')")
    ap.add_argument("--rendered-words", type=int,
                    help="authoritative rendered (DOCX) body word count; overrides the estimate")
    ap.add_argument("--citation-expansion", type=float, default=1.6,
                    help="rendered words added per inline citation (citeproc expansion; default 1.6)")
    ap.add_argument("--near-threshold", type=float, default=0.95,
                    help="fraction of the cap that triggers WORDCOUNT_NEAR_CAP (default 0.95)")
    ap.add_argument("--out", help="write JSON artifact to this path")
    ap.add_argument("--strict", action="store_true", help="exit 1 if over cap")
    ap.add_argument("--quiet", action="store_true", help="suppress stdout summary")
    args = ap.parse_args()

    if args.limit is None and not args.journal_profile:
        sys.stderr.write("ERROR: pass --limit N or --journal-profile <path>\n")
        return 2
    limit = args.limit
    if limit is None:
        limit = parse_cap_from_profile(Path(args.journal_profile), args.article_type)

    result = analyze(Path(args.manuscript), limit, args.citation_expansion,
                     args.near_threshold, args.rendered_words)

    if not args.quiet:
        print("=" * 41)
        print(" Word-Count vs Journal Cap")
        print("=" * 41)
        print(f"body words (md)      : {result['body_words']:,}")
        print(f"inline citations     : {result['n_inline_citations']:,}")
        print(f"rendered est         : {result['rendered_words_est']:,}  [{result['rendered_basis']}]")
        print(f"journal cap          : {result['limit']:,}  (ratio {result['ratio']:.2f})")
        if result["verdict"] == "WORDCOUNT_OVER_CAP":
            print(f"\nMAJOR: body exceeds the cap by {result['rendered_words_est'] - result['limit']:,} "
                  f"words. Relocate methods/sensitivity detail to the Supplement; the binding "
                  f"number is the rendered DOCX count.")
        elif result["verdict"] == "WORDCOUNT_NEAR_CAP":
            print(f"\nMINOR: body is within {round((1 - result['ratio']) * 100)}% of the cap — a "
                  f"further revise pass will likely breach it.")
        else:
            print("\nOK: body is within the journal cap.")

    if args.out:
        Path(args.out).parent.mkdir(parents=True, exist_ok=True)
        Path(args.out).write_text(json.dumps(result, indent=2), encoding="utf-8")
        if not args.quiet:
            print(f"\nwrote {args.out}")

    return 1 if (args.strict and result["verdict"] == "WORDCOUNT_OVER_CAP") else 0


if __name__ == "__main__":
    sys.exit(main())