Render Pdf Doc

#!/usr/bin/env bash
# check_deps.sh — verify pandoc + xelatex + CJK font availability.
set -u

ok=0
fail=0

check() {
  local name="$1"; shift
  if "$@" >/dev/null 2>&1; then
    echo "[OK] $name"
    ok=$((ok + 1))
  else
    echo "[MISS] $name"
    fail=$((fail + 1))
  fi
}

check "pandoc" command -v pandoc
check "xelatex" command -v xelatex

if [[ "$(uname)" == "Darwin" ]]; then
  if /usr/bin/fc-list 2>/dev/null | grep -qi "Apple SD Gothic Neo" \
     || system_profiler SPFontsDataType 2>/dev/null | grep -qi "Apple SD Gothic Neo"; then
    echo "[OK] Apple SD Gothic Neo (macOS)"
    ok=$((ok + 1))
  else
    echo "[WARN] Apple SD Gothic Neo not detected — falling back to default fontconfig"
  fi
else
  if fc-list 2>/dev/null | grep -qi "Noto.*CJK.*KR"; then
    echo "[OK] Noto Sans/Serif CJK KR"
    ok=$((ok + 1))
  else
    echo "[MISS] Noto CJK KR — apt install fonts-noto-cjk"
    fail=$((fail + 1))
  fi
fi

echo
echo "Summary: $ok ok, $fail fail"
exit $fail

#!/usr/bin/env python3
"""
infer_colwidths.py — Replace pandoc pipe-table separator rows with dash-ratios
proportional to per-column content width.

Pandoc pipe tables interpret the dash count in the separator row as relative
column widths (when the total exceeds the line width). This script replaces:

    | Label | Long data column            | Other |
    |-------|-----------------------------|-------|

with widths derived from the maximum display-width of header + cells per column.
CJK glyphs count as 2 cells (East-Asian wide), ASCII as 1.

Usage:
    python infer_colwidths.py input.md [--out output.md] [--min 5] [--total 80]

If --out is omitted, writes to stdout.
"""
from __future__ import annotations

import argparse
import re
import sys
import unicodedata
from pathlib import Path


def display_width(s: str) -> int:
    """East-Asian-aware char width. Wide/Fullwidth = 2, else = 1."""
    w = 0
    for ch in s:
        if unicodedata.east_asian_width(ch) in ("W", "F"):
            w += 2
        else:
            w += 1
    return w


SEPARATOR_RE = re.compile(r"^\s*\|?[\s:\-|]+\|[\s:\-|]+\s*$")
PIPE_ROW_RE = re.compile(r"^\s*\|.*\|\s*$")


def split_row(line: str) -> list[str]:
    s = line.strip()
    if s.startswith("|"):
        s = s[1:]
    if s.endswith("|"):
        s = s[:-1]
    return [c.strip() for c in s.split("|")]


def is_separator(line: str) -> bool:
    if not SEPARATOR_RE.match(line):
        return False
    cells = split_row(line)
    if len(cells) < 2:
        return False
    for c in cells:
        if not re.match(r"^:?-{3,}:?$", c.strip()):
            return False
    return True


def parse_alignment(sep_cell: str) -> str:
    s = sep_cell.strip()
    left = s.startswith(":")
    right = s.endswith(":")
    if left and right:
        return "center"
    if right:
        return "right"
    if left:
        return "left"
    return "default"


def make_separator(widths: list[int], aligns: list[str]) -> str:
    parts = []
    for w, a in zip(widths, aligns):
        body = "-" * max(3, w)
        if a == "center":
            cell = ":" + body[1:-1] + ":" if len(body) >= 3 else ":-:"
        elif a == "left":
            cell = ":" + body[1:] if len(body) >= 2 else ":--"
        elif a == "right":
            cell = body[:-1] + ":" if len(body) >= 2 else "--:"
        else:
            cell = body
        parts.append(cell)
    return "| " + " | ".join(parts) + " |"


def find_table_blocks(lines: list[str]) -> list[tuple[int, int, int]]:
    """Return list of (header_idx, sep_idx, end_idx_exclusive) for pipe tables."""
    blocks = []
    i = 0
    while i < len(lines) - 1:
        if PIPE_ROW_RE.match(lines[i]) and is_separator(lines[i + 1]):
            header = i
            sep = i + 1
            j = sep + 1
            while j < len(lines) and PIPE_ROW_RE.match(lines[j]):
                j += 1
            blocks.append((header, sep, j))
            i = j
        else:
            i += 1
    return blocks


def infer_widths_for_block(
    lines: list[str], header: int, sep: int, end: int, min_dashes: int
) -> tuple[list[int], list[str]]:
    header_cells = split_row(lines[header])
    sep_cells = split_row(lines[sep])
    n = len(header_cells)

    aligns = [parse_alignment(c) for c in sep_cells]
    if len(aligns) < n:
        aligns += ["default"] * (n - len(aligns))
    aligns = aligns[:n]

    widths = [display_width(h) for h in header_cells]
    for r in range(sep + 1, end):
        cells = split_row(lines[r])
        for k in range(min(n, len(cells))):
            widths[k] = max(widths[k], display_width(cells[k]))

    widths = [max(min_dashes, w) for w in widths]
    return widths, aligns


def process(text: str, min_dashes: int, scale: float) -> str:
    lines = text.splitlines()
    blocks = find_table_blocks(lines)
    for header, sep, end in blocks:
        widths, aligns = infer_widths_for_block(lines, header, sep, end, min_dashes)
        if scale != 1.0:
            widths = [max(min_dashes, int(round(w * scale))) for w in widths]
        lines[sep] = make_separator(widths, aligns)
    return "\n".join(lines) + ("\n" if text.endswith("\n") else "")


def main() -> int:
    ap = argparse.ArgumentParser(description=__doc__)
    ap.add_argument("input", type=Path, help="Input markdown file")
    ap.add_argument("--out", type=Path, default=None, help="Output path (default: stdout)")
    ap.add_argument("--min", type=int, default=5, help="Minimum dashes per column (default: 5)")
    ap.add_argument("--scale", type=float, default=1.0, help="Multiply all widths (default: 1.0)")
    args = ap.parse_args()

    text = args.input.read_text(encoding="utf-8")
    out = process(text, min_dashes=args.min, scale=args.scale)
    if args.out:
        args.out.write_text(out, encoding="utf-8")
        print(f"[infer_colwidths] {args.input} → {args.out}", file=sys.stderr)
    else:
        sys.stdout.write(out)
    return 0


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

#!/usr/bin/env bash
# render_pdf.sh — pandoc + xelatex wrapper for Korean academic markdown.
#
# Usage:
#   render_pdf.sh -i input.md [-o output.pdf] [--infer-colwidths]
#                 [--font "Apple SD Gothic Neo"] [--cjk-font "Apple SD Gothic Neo"]
#                 [-- <extra pandoc args>]
#
# Defaults:
#   - macOS: mainfont/CJKmainfont = "Apple SD Gothic Neo"
#   - Linux: mainfont = "Noto Serif CJK KR", CJKmainfont = "Noto Sans CJK KR"
#   - Output path = <input>.pdf
#   - geometry = margin=0.85in, fontsize = 11pt (override via frontmatter)
#
# The frontmatter in input.md takes precedence over CLI/auto-detected defaults.

set -euo pipefail

SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"

INPUT=""
OUTPUT=""
INFER_COLWIDTHS=0
MAINFONT=""
CJKFONT=""
EXTRA=()

usage() {
  cat >&2 <<EOF
Usage: $(basename "$0") -i <input.md> [-o <output.pdf>] [options] [-- <pandoc args>]

Options:
  -i  Input markdown
  -o  Output PDF (default: <input>.pdf)
  --infer-colwidths     Run scripts/infer_colwidths.py on a temp copy first
  --font NAME           mainfont (default: OS-detected)
  --cjk-font NAME       CJKmainfont (default: OS-detected)
  -h | --help           Help

Pass-through: any args after '--' go directly to pandoc.
EOF
  exit 1
}

while [[ $# -gt 0 ]]; do
  case "$1" in
    -i) INPUT="$2"; shift 2 ;;
    -o) OUTPUT="$2"; shift 2 ;;
    --infer-colwidths) INFER_COLWIDTHS=1; shift ;;
    --font) MAINFONT="$2"; shift 2 ;;
    --cjk-font) CJKFONT="$2"; shift 2 ;;
    -h|--help) usage ;;
    --) shift; EXTRA=("$@"); break ;;
    *) EXTRA+=("$1"); shift ;;
  esac
done

[[ -z "$INPUT" ]] && usage
[[ -f "$INPUT" ]] || { echo "ERROR: input not found: $INPUT" >&2; exit 2; }
[[ -z "$OUTPUT" ]] && OUTPUT="${INPUT%.md}.pdf"

# OS-based font defaults
if [[ -z "$MAINFONT" || -z "$CJKFONT" ]]; then
  if [[ "$(uname)" == "Darwin" ]]; then
    : "${MAINFONT:=Apple SD Gothic Neo}"
    : "${CJKFONT:=Apple SD Gothic Neo}"
  else
    : "${MAINFONT:=Noto Serif CJK KR}"
    : "${CJKFONT:=Noto Sans CJK KR}"
  fi
fi

command -v pandoc >/dev/null || { echo "ERROR: pandoc not installed" >&2; exit 3; }
command -v xelatex >/dev/null || { echo "ERROR: xelatex not installed (install mactex / texlive-xetex)" >&2; exit 3; }

WORK="$INPUT"
TMPDIR=""
if [[ "$INFER_COLWIDTHS" == "1" ]]; then
  TMPDIR="$(mktemp -d)"
  trap 'rm -rf "$TMPDIR"' EXIT
  WORK="$TMPDIR/$(basename "$INPUT")"
  python3 "$SCRIPT_DIR/infer_colwidths.py" "$INPUT" --out "$WORK"
fi

ARGS=(
  --pdf-engine=xelatex
  -V "mainfont=${MAINFONT}"
  -V "CJKmainfont=${CJKFONT}"
  -V "geometry:margin=0.85in"
  -V "fontsize=11pt"
  -V "linestretch=1.25"
  -V "colorlinks=true"
  -o "$OUTPUT"
)

echo "[render_pdf] in=$INPUT out=$OUTPUT mainfont='$MAINFONT' CJK='$CJKFONT' infer=$INFER_COLWIDTHS" >&2
pandoc "${ARGS[@]}" ${EXTRA[@]+"${EXTRA[@]}"} "$WORK"
echo "[render_pdf] ok → $OUTPUT" >&2

#!/usr/bin/env python3
"""Scientific-symbol + CJK glyph-coverage scanner for xelatex PDF builds.

xelatex **silently drops** a character the chosen font does not cover — the PDF
renders with the glyph simply missing, no error. Academic markdown routinely
carries glyphs a default Latin font misses: transition arrows (→ ↑ ↓ ↔), math
operators (− ≤ ≥ ± √ ∪ × ≈ ≠), stats Greek (κ μ σ β χ), bullets/marks (• ★ ✓),
and CJK. This scans the SOURCE markdown, groups the risky non-ASCII glyphs it
finds by class, and (when a font file + fonttools are available) reports which are
genuinely absent from the font's cmap. The DOCX is authoritative; the PDF is a
convenience copy, so the goal is to surface a likely silent drop before it ships.

NOT an integrity detector — named `scan_glyph_coverage.py` (not check_/detect_/
derive_) so the catalog glob does not count it; it is a render-time QA helper.

INPUT
  markdown   one or more .md files (positional).
  --font     optional path to the .ttf/.otf that will render the body; with
             `fonttools` installed, glyphs absent from its cmap are reported as
             MISSING (the real coverage check). Without it, the scan is advisory
             (presence by class — verify your mainfont/CJKmainfont covers them).

OUTPUT
  stdout report and, with --json, an artifact:
    {files, classes{name:[chars]}, missing_in_font[], summary}
  Exit 1 (with --strict) when risky glyphs are present AND no font verified them,
  or when --font is given and any glyph is genuinely missing from it.

Stdlib-only core (re/json/argparse/unicodedata); fonttools optional. Exit codes:
0 clean/advisory-ok, 1 risky-uncovered (with --strict), 2 input/usage error.
"""

from __future__ import annotations

import argparse
import json
import sys
import unicodedata
from pathlib import Path

# Risky glyph classes (codepoint ranges / explicit points) that a default Latin
# font (Helvetica/Times) commonly misses and xelatex drops silently.
CLASSES = {
    "arrows": [(0x2190, 0x21FF)],
    "math_operators": [(0x2212, 0x2212), (0x2264, 0x2265), (0x00B1, 0x00B1),
                       (0x221A, 0x221A), (0x222A, 0x222A), (0x00D7, 0x00D7),
                       (0x2248, 0x2248), (0x2260, 0x2260), (0x2211, 0x2211),
                       (0x220F, 0x220F), (0x2265, 0x2265), (0x2243, 0x2243)],
    "greek_stats": [(0x0370, 0x03FF)],
    "marks_bullets": [(0x2605, 0x2606), (0x2713, 0x2714), (0x2022, 0x2022),
                      (0x2020, 0x2021), (0x00A7, 0x00A7)],
    "cjk": [(0x3040, 0x30FF), (0x3400, 0x4DBF), (0x4E00, 0x9FFF),
            (0xAC00, 0xD7A3), (0xF900, 0xFAFF)],
}


def _classify(ch: str) -> str | None:
    cp = ord(ch)
    if cp < 0x80:
        return None
    for name, ranges in CLASSES.items():
        for lo, hi in ranges:
            if lo <= cp <= hi:
                return name
    return None


def scan(paths: list[Path]) -> dict:
    classes: dict[str, dict[str, int]] = {}
    all_chars: set[str] = set()
    for p in paths:
        if not p.is_file():
            sys.stderr.write(f"ERROR: file not found: {p}\n")
            sys.exit(2)
        for ch in p.read_text(encoding="utf-8"):
            cls = _classify(ch)
            if cls:
                classes.setdefault(cls, {}).setdefault(ch, 0)
                classes[cls][ch] += 1
                all_chars.add(ch)
    return {"classes": classes, "chars": sorted(all_chars)}


def font_missing(chars: list[str], font_path: Path) -> tuple[list[str], bool]:
    """Return (missing_chars, checked). checked=False if fonttools/font unavailable."""
    try:
        from fontTools.ttLib import TTFont  # type: ignore
    except Exception:
        return [], False
    if not font_path.is_file():
        sys.stderr.write(f"WARN: --font not found: {font_path}\n")
        return [], False
    try:
        font = TTFont(str(font_path))
        cmap = set()
        for t in font["cmap"].tables:
            cmap.update(t.cmap.keys())
    except Exception as e:
        sys.stderr.write(f"WARN: could not read font cmap: {e}\n")
        return [], False
    return [c for c in chars if ord(c) not in cmap], True


def main() -> int:
    ap = argparse.ArgumentParser(description="Scientific-symbol + CJK glyph-coverage scanner.")
    ap.add_argument("markdown", nargs="+", help="markdown file(s) to scan")
    ap.add_argument("--font", help="path to body font (.ttf/.otf) — checks real cmap if fonttools present")
    ap.add_argument("--json", help="write JSON artifact")
    ap.add_argument("--strict", action="store_true",
                    help="exit 1 if risky glyphs are present and unverified, or genuinely missing from --font")
    ap.add_argument("--quiet", action="store_true")
    args = ap.parse_args()

    res = scan([Path(m) for m in args.markdown])
    classes = res["classes"]
    missing, checked = ([], False)
    if args.font:
        missing, checked = font_missing(res["chars"], Path(args.font))

    n_risky = sum(sum(d.values()) for d in classes.values())
    out = {
        "files": args.markdown,
        "classes": {k: sorted(v) for k, v in classes.items()},
        "font_checked": checked,
        "missing_in_font": sorted(missing),
        "summary": {"n_risky_glyphs": n_risky, "n_classes": len(classes),
                    "n_missing_in_font": len(missing)},
    }

    if not args.quiet:
        print("=" * 41)
        print(" Glyph Coverage (xelatex silent-drop scan)")
        print("=" * 41)
        for cls, chars in out["classes"].items():
            names = ", ".join(f"{c} (U+{ord(c):04X} {unicodedata.name(c, '?')[:24]})" for c in chars[:8])
            print(f"  {cls}: {names}{' …' if len(chars) > 8 else ''}")
        if not classes:
            print("  (no risky non-ASCII glyphs found)")
        if checked:
            print(f"\nfont cmap checked: {len(missing)} glyph(s) MISSING from the font"
                  + (f": {' '.join(missing)}" if missing else ""))
        elif classes:
            print("\nADVISORY: risky glyphs present; verify mainfont/CJKmainfont cover them "
                  "(pass --font with fonttools for a real cmap check). DOCX is authoritative.")

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

    if args.strict:
        if checked:
            return 1 if missing else 0
        return 1 if n_risky else 0
    return 0


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

schema_version: 2
name: render-pdf-doc
layer: A
owner_domain: document_layout
maturity: official
when_to_use:
  - Render a non-bibliography Korean/English academic markdown to publication-quality PDF
  - Research proposals, IRB cover letters, briefing handouts, anchor docs, reference tables
  - Auto-infer pipe-table column widths for content-proportional layout
  - CJK-font-aware PDF on macOS (Apple SD Gothic Neo) or Linux (Noto Sans CJK KR)
when_NOT_to_use:
  - Manuscripts with bibliography (use /manage-refs scripts/render_pandoc.sh — owns CSL pipeline)
  - Filling institutional Word form templates (use /fill-protocol)
  - Figures, plots, or PPTX (use /make-figures or /present-paper)
  - Hand-typing CSV data into tables (forbidden — see numerical-safety rule)
inputs:
  - markdown_file (non-bibliography academic doc — proposal, briefing, anchor doc, IRB cover, reference table)
  - frontmatter (optional; mainfont, CJKmainfont, geometry, fontsize, linestretch)
outputs:
  - pdf_file (default: same dir, same stem, .pdf)
  - intermediate.colwidths.md (optional, when --infer-colwidths is run as separate step)
deterministic_scripts:
  - scripts/render_pdf.sh
  - scripts/infer_colwidths.py
  - scripts/check_deps.sh
side_effects:
  - writes_pdf_artifacts
  - reads_os_font_table  # for CJK font detection (Apple SD Gothic Neo / Noto Sans CJK KR)
downstream_consumers:
  - intake-project
  - manage-project
  - write-protocol  # when no institutional .docx form exists; see fill-protocol for the form-fill alternative
forbidden_actions:
  - bibliography_rendering  # delegate /manage-refs scripts/render_pandoc.sh
  - citation_key_modification
  - institutional_word_form_filling  # delegate /fill-protocol
  - figure_or_pptx_generation  # delegate /make-figures or /present-paper
  - hand_typing_csv_data_into_tables  # ~/.claude/rules/numerical-safety.md
provenance:
  origin: "P3 spinoff from /write-paper Phase 7.6 split (2026-05-01)"
  precedent: "an education-research calibration anchor PDF — manual fix x2 → skill"
quality_gates:
  - check_deps.sh: hard exit if pandoc + xelatex + CJK-font dependencies are not installed
  - infer_colwidths.py: enforce content-proportional dashes unless the equal-split (--equal) option is specified
  - circulation_redaction: for circulation PDFs, enforce frontmatter `redact_internal: true` or keep change history / version numbers / PI attribution out of the body

# v2.1 quality card
purpose: "Render a Markdown manuscript to a styled DOCX/PDF (tables, column widths, dependencies checked)."
safety_boundaries:
  - "Delegates bibliography rendering to manage-refs and figures/PPTX to make-figures/present-paper; does not modify citation keys."
  - "Does not hand-type CSV data into tables (numerical-safety)."
known_limitations:
  - "Output fidelity depends on installed render dependencies (checked by check_deps.sh)."
  - "Institutional Word forms are out of scope (use fill-protocol)."
validation_commands:
  - "bash scripts/check_deps.sh"
  - "bash scripts/render_pdf.sh <manuscript.md>"
  - "bash tests/test_glyph_coverage.sh"
evidence_surface: bundled_script

#!/usr/bin/env bash
# Regression test for the scientific-symbol + CJK glyph-coverage scanner (G43).
# Synthetic, PII-free fixtures: a doc with risky glyphs (arrow →, ±, ≤, κ, CJK,
# ★) that xelatex would silently drop under a default Latin font, and a plain
# ASCII doc. Stdlib-only (python3); fonttools optional (not required here).
set -u

HERE="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
SCRIPT="$HERE/../scripts/scan_glyph_coverage.py"
RISKY="$HERE/fixtures/glyph_risky.md"
PLAIN="$HERE/fixtures/glyph_plain.md"
OUT="$(mktemp -t glyph_XXXX).json"
trap 'rm -f "$OUT"' EXIT

fail=0
check() { local label="$1"; shift
    if "$@" >/dev/null 2>&1; then printf '  PASS  %s\n' "$label"
    else printf '  FAIL  %s\n' "$label"; fail=$((fail+1)); fi
}
has_class() { python3 -c "
import json; d=json.load(open('$OUT')); assert '$1' in d['classes'], '$1 missing'"; }

[[ -f "$SCRIPT" ]] || { echo "ENV-ERR: script missing" >&2; exit 2; }

# (1) risky doc -> exit 1 under --strict (risky glyphs present, unverified font)
python3 "$SCRIPT" "$RISKY" --json "$OUT" --strict --quiet >/dev/null 2>&1
check "exit 1 (risky glyphs, no font)" test "$?" -eq 1
check "arrows class detected"        has_class arrows
check "math_operators class detected" has_class math_operators
check "cjk class detected"           has_class cjk

# (2) plain ASCII doc -> exit 0, no classes
python3 "$SCRIPT" "$PLAIN" --json "$OUT" --strict --quiet >/dev/null 2>&1
check "exit 0 on plain ASCII" test "$?" -eq 0
check "no risky classes on plain doc" python3 -c "
import json; d=json.load(open('$OUT')); assert d['classes']=={}, d['classes']"

echo "fail=$fail"; [[ "$fail" -eq 0 ]] && echo "ALL PASS" || echo "FAILURES: $fail"
exit "$fail"